require "set"

module Lace

  class Netlist

    attr_reader :components
    attr_reader :nets

    def initialize(&p)
      @components = {}
      @nets = {}

      edit(&p) if p
    end

    def definitive_net(n)
      nn = @nets[n.object_id]
      return n if nn.object_id == n.object_id
      return definitive_net(nn)
    end

    def merge_nets(a, b)
      da = definitive_net(a)
      db = definitive_net(b)
      return da if da.object_id == db.object_id
      into = @nets[[da.object_id, db.object_id].min]
      if da.name
        raise "Nets #{into.name} and #{da.name} merged!" if into.name and into.name != da.name
        into.name = da.name
      end
      if db.name
        raise "Nets #{into.name} and #{db.name} merged!" if into.name and into.name != db.name
        into.name = db.name
      end
      @nets.each do | id, n |
        dn = definitive_net(n)
        if dn.object_id != into.object_id and (dn.object_id == da.object_id or dn.object_id == db.object_id)
          @nets[id] = into
        end
      end
      return into
    end

    def edit(&p)
      instance_eval &p
    end

    def comp(*args)
      c = Component.new(self, *args)
      @components[c.object_id] = c
      return c
    end

    def net(*args)
      n = Net.new(self, *args)
      @nets[n.object_id] = n
      return n
    end

    def pair(left, right)
      x = Wireable.new(self, left, right)
      return x
    end

    def real_refs
      refs = {}
      counters = {}
      seen = Set.new
      @components.each do | id, comp |
        next if seen.member?(comp.object_id)
        seen.add(comp.object_id)
        counter = counters[comp.refbase] || 1
        counters[comp.refbase] = counter + 1
        ref = "#{comp.refbase}#{counter}"
        refs[ref] = comp
      end
      return refs
    end

    def real_nets(refs)
      n = 1
      nets = {}
      seen = Set.new
      @nets.each do | id, net |
        next if seen.member?(net.object_id)
        seen.add(net.object_id)
        name = net.name
        unless name
          name = "$unnamed#{n}"
          n += 1
        end
        raise "Multiple disconnected nets named #{name}" if nets.member?(name)
        nodes = []
        refs.each do | ref, comp |
          comp.pins.each do | pin, pinnet |
            nodes << {:ref => ref, :pin => pin} if definitive_net(pinnet).object_id == net.object_id
          end
        end
        nets[name] = nodes if nodes.size > 1
      end
      return nets
    end

    def real
      refs = real_refs
      nets = real_nets(refs)
      return [refs, nets]
    end

    def kicad(stream=$stdout)
      refs, nets = real
      stream.write(<<END)
(export
  (version D)
  (components
END
      refs.each do | ref, comp |
        stream.write(<<END)
    (comp
      (ref #{ref.inspect})
      (footprint #{comp.footprint.inspect})
      (value #{comp.value.inspect})
      (libsource (lib NO_LIB) (part #{comp.name.inspect}))
    )
END
      end
      stream.write(<<END)
  )
  (nets
END
      n = 1
      nets.each do | name, nodes |
        stream.write(<<END)
    (net
      (code #{n})
      (name #{name.inspect})
END
        nodes.each do | node |
          stream.write(<<END)
      (node
        (ref #{node[:ref].inspect})
        (pin #{node[:pin]})
      )
END
        end
        stream.write(<<END)
    )
END
        n += 1
      end
      stream.write(<<END)
  )
)
END
    end

    def summary(stream=$stdout)
      refs, nets = real
      refs.each do | ref, comp |
        stream.write("#{ref} is a #{comp.footprint} #{comp.desc}\n")
      end
      nets.each do | name, nodes |
        stream.write("Net #{name}:\n")
        nodes.each do | node |
          stream.write("  #{node[:ref]}[#{node[:pin]}]\n")
        end
      end
    end

    def bom
      bom = {}
      real_refs.each do | ref, comp |
        desc = "#{comp.footprint} #{comp.desc}"
        bom[desc] = 0 unless bom.member?(desc)
        bom[desc] += 1
      end
      return bom
    end
  end

  class Wireable

    attr_reader :netlist

    attr_reader :left
    attr_reader :right

    def initialize(netlist, left=nil, right=nil)
      @netlist = netlist

      @left = left
      @right = right || left
    end

    def left_net
      x = left
      return x if x.instance_of?(Net)
      return x.left_net
    end

    def right_net
      x = right
      return x if x.instance_of?(Net)
      return x.right_net
    end

    def -(that)
      @netlist.merge_nets(right_net, that.left_net)
      return Wireable.new(@netlist, left_net, that.right_net)
    end

  end

  class Component < Wireable

    attr_reader :refbase
    attr_reader :footprint
    attr_reader :name
    attr_reader :value

    attr_reader :pins

    def initialize(netlist, refbase, footprint, name, value=nil)
      super(netlist)

      @refbase = refbase
      @footprint = footprint
      @name = name
      @value = value || name

      @pins = {}
    end

    def left
      return self[1]
    end

    def right
      return self[2]
    end

    def [](pin)
      unless pins.member?(pin)
        n = @netlist.net
        pins[pin] = n
      end
      return pins[pin]
    end

    def desc
      return "\"#{@value}\" #{@name}" if @name != @value
      return @name
    end

  end

  class Net < Wireable

    attr_accessor :name

    def initialize(netlist, name=nil)
      super(netlist, self)

      @name = name
    end

  end

end