#!/usr/bin/ruby
# vim: et sw=2

VER="(16548c4-dirty)"
ME="bldx: "
$chdr="1;36"
$cinf="1;37"
$cadd="1;32"
$cdel="1;31"
$incl=[]
$excl=[]
$fld=nil
$opt=nil
$mode="normal"

def in_list(s,list)
  for i in list
    if i.match(s)
      return true
    end
  end
  return false
end

def regexfix2(str)
  tmp=[]
  for t in str.scan(/(_)|(\|)|([^_\|]*)/).flatten.compact
    tmp.push(t) if not t.empty?
  end
  res=""
  while t=tmp.shift
    case t
      when "_" then res+=(tmp.empty? or tmp[0]=="|") ? '([ ."\[\]\(\)\{\}]+|$)' : '[ ."\[\]\(\)\{\}]+'
      when "|" then res+="|"
      else res+="#{t}"
    end
  end
  return res
end

class Block
  attr_reader :la, :name
  Line=Struct.new :port, :ln, :lp, :arr, :del, :add, :ln2, :lp2

  def initialize(h)
    @hdr=h
    @fld=nil
    @sep=nil
    @flds=[]
    @ft=[]
    @la=[]
    @ca=[]
    @arr=[]
    @name=/^#!? ([^ ]*)/.match(h)[1]
  end

  def hdr(h)
    @hdr=h
  end

  def fld(f,s)
    @fld=f
    @sep=s
    tmp=@fld.scan(/[^\t]*\t*/)
    tmp.delete_if { |t| t.empty? }
    tc=0
    for t in tmp
      @flds<<t.delete("\t")
      @ft<<tc
      tc+=t.count("\t")+t.count("^\t")/8
    end
  end

  def ignore?
    return true if not $incl.empty? and not in_list(@hdr,$incl)
    return true if in_list(@hdr,$excl)
    return true if not @flds.include?($fld)
    return false
  end

  def line(l,st=" ")
    st1=l.split(/\t+/)
    if st1[0].empty?
      tc=/\t+/.match(l)[0].length
      return if !i=@ft.index(tc)
      n=@flds.index($fld)
      return if i>n
      k=1+(n-i)
      return if k>=st1.length
      str=st1[k]
      z=@la.last
      if i==1 and !z.ln2 and not (st1[1].start_with?("!") or st1[1].start_with?("-"))
        st2=st1[1].split(":")
        z.ln2=st2[0]
        z.lp2=st2[1]
      end
    else
      return if st1.length<2
      return if st1[0]=="-" or st1[1].start_with?("-")
      port=st1[0]
      st2=st1[1].split(":")
      ln=st2[0]
      lp=st2[1]
      i=@flds.index($fld)
      return if i>=st1.length
      str=st1[i]
      if !z=find(port)
        z=Line.new(port,ln,lp,[],[],[])
        @la<<z
      end
    end
    return if str.start_with?("-") or str.start_with?("!")
    arr=[]
    for v in str.split(",")
      if v.include?("-")
        t=v.split("-")
        t[0].to_i.upto(t[1].to_i) { |x| arr<<x.to_s }
      else
        arr<<v
      end
    end
    z.arr.concat(arr) if st==" "
    z.del.concat(arr) if st=="-"
    z.add.concat(arr) if st=="+"
    return
  end

  def list(l)
    tmp=l.split(/\t+/)
    if tmp[0].empty?
      tc=/\t+/.match(l)[0].length
      return if !i=@ft.index(tc)
      n=@flds.index($fld)
      return if i>n
      i=1+(n-i)
      return if i>=tmp.length
      str=tmp[i]
    else
      i=@flds.index($fld)
      return if i>=tmp.length
      str=tmp[i]
    end
    return if str.start_with?("-") or str.start_with?("!")
    arr=[]
    for v in str.split(",")
      if v.include?("-")
        t=v.split("-")
        t[0].to_i.upto(t[1].to_i) { |x| arr<<x.to_s }
      else
        arr<<v
      end
    end
    @arr.concat(arr)
    @arr.uniq!
    return
  end

  def cmp(b)
    for l1 in @la
      next if l1.ln!=b.name and l1.ln2!=b.name
      for l2 in b.la
        next if l2.ln!=@name and l2.ln2!=@name
        next if l2.lp!=l1.port and l2.lp2!=l1.port
        arr=l1.arr-l2.arr
        if not arr.empty?
          @ca<<Line.new(l1.port,l1.ln,l1.lp,arr) if l1.ln==b.name
          @ca<<Line.new(l1.port,l1.ln2,l1.lp2,arr) if l1.ln2==b.name
        end
        break
      end
    end
  end

  def output(out)
    if $opt=="list"
      return if @arr.empty?
      @arr.sort! do |x,y|
        next -1 if x.start_with?("+") or x.start_with?("*")
        next 1 if y.start_with?("+") or y.start_with?("*")
        next x.to_i<=>y.to_i
      end
      arr=combine(@arr)
      c=$chdr
      out.puts "\e[#{c}m%s\e[m" % @hdr
      out.puts "#{$fld}: %s" % to_str(arr)
      return
    end
    if $opt=="cmp"
      return if @ca.empty?
      c=$chdr
      out.puts "\e[#{c}m%s\e[m" % @hdr
      for l in @ca
        next if l.arr.empty?
        arr=combine(l.arr)
        str=l.ln
        str+=":"+l.lp if l.lp
        c=$cinf
        out.puts "\e[#{c}mport: %s\e[m  link: %s" % [l.port,str]
        out.puts "#{$fld}: %s" % to_str(arr)
      end
      return
    end
    if $opt=="get"
      c=$chdr
      out.puts "\e[#{c}m%s\e[m" % @hdr
      for l in @la
        next if l.arr.empty?
        arr=combine(l.arr)
        str=l.ln
        str+=":"+l.lp if l.lp
        c=$cinf
        out.puts "\e[#{c}mport: %s\e[m  link: %s" % [l.port,str]
        out.puts "#{$fld}: %s" % to_str(arr)
      end
      return
    end
    return if prepare<1
    c=$chdr
    out.puts "\e[#{c}m%s\e[m" % @hdr
    for l in @la
      next if l.del.empty? and l.add.empty?
      str=l.ln
      str+=":"+l.lp if l.lp
      c=$cinf
      out.puts "\e[#{c}mport: %s\e[m  link: %s" % [l.port,str]
      c=$cdel
      out.puts "del: \e[#{c}m%s\e[m" % to_str(l.del) if not l.del.empty?
      c=$cadd
      out.puts "add: \e[#{c}m%s\e[m" % to_str(l.add) if not l.add.empty?
    end
    return
  end

  private

  def find(port)
    for l in @la
      return l if l.port==port
    end
    return nil
  end

  def to_str(arr)
    if $mode=="huawei"
      tmp=[]
      for s in arr
        (tmp<<s; next) if not s.include?("-")
        s.sub!("-"," to ")
        tmp<<s
      end
      return tmp.join(" ")
    end
    return arr.join(",")
  end

  def combine(list)
    arr=[]
    u=nil
    for v in list
      if u and v.to_i==u+1
        u+=1
        next
      end
      if u and arr.last.to_i<u
        z=arr.pop
        arr<<"%s-%d" % [z,u]
        u=nil
      end
      if not (v.start_with?("+") or v.start_with?("*"))
        u=v.to_i
      end
      arr<<v
    end
    if u and arr.last.to_i<u
      z=arr.pop
      arr<<"%s-%d" % [z,u]
    end
    return arr
  end

  def prepare
    cnt=0
    for l in @la
      l.del.uniq!
      l.add.uniq!
      arr=l.del&l.add
      l.del=l.del-arr
      l.add=l.add-arr
      next if l.del.empty? and l.add.empty?
      cnt+=1
      l.del.sort! do |x,y|
        next -1 if x.start_with?("+") or x.start_with?("*")
        next 1 if y.start_with?("+") or y.start_with?("*")
        next x.to_i<=>y.to_i
      end
      l.add.sort! do |x,y|
        next -1 if x.start_with?("+") or x.start_with?("*")
        next 1 if y.start_with?("+") or y.start_with?("*")
        next x.to_i<=>y.to_i
      end
      l.del=combine(l.del)
      l.add=combine(l.add)
    end
    return cnt
  end
end

def usage
  me=ME.delete(":")
  puts "Usage: "+me+"<fld>"
  puts "  -B <pattern>  - include blocks matching RegEx <pattern>"
  puts "  -S <pattern>  - skip blocks matching RegEx <pattern>"
  puts "  -l            - make list from input (aggregation)"
  puts "  -cmp          - compare given links <fld>"
  puts "  -get          - get given links <fld>"
  exit
end

def p_diff(isdf)
  blocks=[]
  bl=fld=nil
  inbl=false
  igbl=false
  st=" "
  for l in $stdin
    l.chop!
    next if l.empty?
    st=l.slice!(0,1) if isdf
    if inbl
      if l.start_with?("-----")
        blocks<<bl if not igbl
        bl=fld=nil
        inbl=false
        igbl=false
        next
      end
      bl.line(l,st) if not igbl
      next
    end
    if l.start_with?("#")
      if bl
        bl.hdr(l)
        next
      end
      bl=Block.new(l)
      next
    end
    if bl
      if not l.start_with?("-----")
        fld=l
        next
      end
      if !fld
        bl=nil
        next
      end
      bl.fld(fld,l)
      inbl=true
      igbl=bl.ignore?
      next
    end
  end
  return blocks
end

def p_data
  blocks=[]
  bl=fld=nil
  inbl=false
  igbl=false
  for l in $stdin
    l.chop!
    next if l.empty?
    if inbl
      if l.start_with?("-----")
        blocks<<bl if not igbl
        bl=fld=nil
        inbl=false
        igbl=false
        next
      end
      bl.list(l) if not igbl
      next
    end
    if l.start_with?("#")
      if bl
        bl.hdr(l)
        next
      end
      bl=Block.new(l)
      next
    end
    if bl
      if not l.start_with?("-----")
        fld=l
        next
      end
      if !fld
        bl=nil
        next
      end
      bl.fld(fld,l)
      inbl=true
      igbl=bl.ignore?
      next
    end
  end
  return blocks
end

def do_cmp(blocks)
  c=blocks.length
  i=0
  while i<c
    b1=blocks[i]
    i+=1
    j=i
    while j<c
      b2=blocks[j]
      j+=1
      b1.cmp(b2)
      b2.cmp(b1)
    end
  end
end

$istty=$stdout.isatty
i=0
while i<ARGV.length
  if ARGV[i]=="--"
    i+=1
    break
  end
  break if ARGV[i]=="-"
  break if not ARGV[i].start_with?("-")
  usage if ARGV[i]=="--help"
  if ARGV[i]=="--version"
    me=ME.delete(":")
    puts me+VER+" by Borg."
    exit
  end

  if ARGV[i]=="-l"
    i+=1
    if $opt
      $stderr.puts ME+"Cannot mix '-l' with other options"
      exit
    end
    $opt="list"
    next
  end
  if ARGV[i]=="-cmp"
    i+=1
    if $opt
      $stderr.puts ME+"Cannot mix '-cmp' with other options"
      exit
    end
    $opt="cmp"
    next
  end
  if ARGV[i]=="-get"
    i+=1
    if $opt
      $stderr.puts ME+"Cannot mix '-cfg' with other options"
      exit
    end
    $opt="get"
    next
  end
  if ARGV[i]=="-B"
    i+=1
    if !ARGV[i]
      $stderr.puts ME+"Need argument for '-B' option"
      exit
    end
    str=regexfix2(ARGV[i])
    $incl<<Regexp.new(str,true)
    i+=1
    next
  end
  if ARGV[i]=="-S"
    i+=1
    if !ARGV[i]
      $stderr.puts ME+"Need argument for '-S' option"
      exit
    end
    str=regexfix2(ARGV[i])
    $excl<<Regexp.new(str,true)
    i+=1
    next
  end
  if ARGV[i]=="-huawei"
    i+=1
    $mode="huawei"
    next
  end
  $stderr.puts ME+"Unknown option: "+ARGV[i]
  exit
end

usage if i>=ARGV.length
$fld=ARGV[i]
case $opt
  when "cmp" then blocks=p_diff(false)
  when "get" then blocks=p_diff(false)
  when "list" then blocks=p_data
  else blocks=p_diff(true)
end

exit if blocks.empty?
do_cmp(blocks) if $opt=="cmp"
if $istty
  out=IO.popen("less -fqRFX","w")
else
  out=$stdout
end
begin
  blocks.each { |b| b.output(out) }
rescue Errno::EPIPE
end
out.close if out!=$stdout