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

VER="(d4e2ac8)"
ME="blfmt: "
$rs=78

$quiet=false
$wib=false
$incl=[]
$excl=[]
$map=nil

mode="txt"

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

def block_ok?(hdr)
  return false if /^#!/.match(hdr) and not $wib
  return false if not $incl.empty?() and not in_list(hdr,$incl)
  return false if in_list(hdr,$excl)
  return true
end

$ft=[]
def fix_cols(tmp,col,s=nil)
  $err=nil
  c=col.length
  tl=0
  i=0
  j=0
  t=0
  ret=""
  if tmp[0].empty?
    if !s or $ft.empty? or tmp.length<2
      $err="broken file?"
      return nil
    end
    tc=/\t+/.match(s)[0].length
    j=$ft.index(tc)
    if !j or j<1
      $err="broken file?"
      return nil
    end
    t=0
    i=0
    while i<j
      j+=1 if col[i].start_with?("+")
      t+=col[i].to_i
      i+=1
    end
    ret="\t"*t
    tl=t*8
    j=1
    t=0
  end
  row=[]
  while i<c
    if col[i].start_with?("!")
      row.push(tmp[j])
      j+=1
      next
    end
    if col[i].start_with?("-")
      row.push(tmp[j])
      i+=1
      j+=1
      next
    end
    if col[i].start_with?("+")
      cs=col[i].to_i*8
      cs=$rs-tl if cs==0
      tl+=cs
      ret+="\t"*t+"?"
      t=col[i].to_i
      row.push("?")
      i+=1
      next
    end
    break if !tmp[j]
    l=tmp[j].length
    row.push(tmp[j])
    cs=col[i].to_i*8
    if cs==0 or (j>0 and !tmp[j+1])
      cs=$rs-tl if !col[i+1] or not col[i+1].start_with?("+")
      if l>cs
        $err="column #{i+1} exceed specified size"
        return nil
      end
    else
      if l>=cs
        $err="column #{i+1} exceed specified size"
        return nil
      end
    end
    tl+=cs
    ret+="\t"*t+tmp[j]
    t=col[i].to_i-(l/8)
    i+=1
    j+=1
  end
  if tl>$rs
    $err="row length exceeded"
    return nil
  end
  if tmp[j]
    $err="column count mismatch"
    return nil
  end
  $ls=row if not tmp[0].empty?
  return ret
end

def remap(row)
  tmp=[]
  $map.each { |i| tmp<<row[i] }
  return tmp
end

def p_txt(sbuf,col)
  dbuf=[]
  inbl=igbl=false
  hdr=fld=nil
  for s in sbuf
    if igbl
      dbuf.push(s)
      if s.start_with?("-----")
        hdr=fld=nil
        inbl=igbl=false
      end
      next
    end
    if inbl
      if s.start_with?("-----")
        dbuf.push(s)
        hdr=fld=nil
        inbl=igbl=false
        next
      end
      tmp=s.split(/\t+/)
      if !ret=fix_cols(tmp,col,s)
        $stderr.puts ME+$err
        exit
      end
      dbuf.push(ret)
      next
    end
    if s.start_with?("#")
      hdr=s
      next
    end
    if s.start_with?("-----")
      if block_ok?(hdr)
        $ft=[0]
        tmp=fld.scan(/[^\t]*\t*/)
        tmp.pop
        tc=0
        for t in tmp
          tc+=t.count("\t")+t.count("^\t")/8
          $ft<<tc
        end
        tmp=fld.split(/\t+/)
        if !fld=fix_cols(tmp,col,s)
          $stderr.puts ME+$err
          exit
        end
        dbuf.push(hdr)
        dbuf.push(fld)
        dbuf.push(s)
        inbl=true
        next
      end
      dbuf.push(hdr)
      dbuf.push(fld)
      dbuf.push(s)
      igbl=true
      next
    end
    if hdr
      fld=s
      next
    end
    dbuf.push(s)
  end
  return dbuf
end

def p_txt_check(sbuf)
  err=false
  line=0
  inbl=igbl=false
  col=[]
  hdr=fld=sep=cc=nil
  zt=zf=0
  for s in sbuf
    line+=1
    if igbl
      if s.start_with?("-----")
        hdr=fld=sep=cc=nil
        col=[]
        zt=zf=0
        inbl=igbl=false
      end
      next
    end
    if inbl
      if s.start_with?("-----")
        if s!=sep
          $stderr.puts ME+"line #{line}: separator mismatch" if not $quiet
          err=true
        end
        hdr=fld=sep=cc=nil
        col=[]
        zt=zf=0
        inbl=igbl=false
        next
      end
      if s.empty?
        $stderr.puts ME+"line #{line}: empty line inside block" if not $quiet
        err=true
        next
      end
      if /^#/.match(s)
        $stderr.puts ME+"line #{line}: header found inside block" if not $quiet
        err=true
        break
      end
      ti=0
      ti=/^\t+/.match(s)[0].length if s.start_with?("\t")
      zf=0 if ti==0
      if zf>0 and ti!=zf
        $stderr.puts ME+"line #{line}: secondary line misalign" if not $quiet
        err=true
        next
      end
      tmp=s.split(/\t+/)
      if tmp.length<1
        $stderr.puts ME+"line #{line}: empty line inside block" if not $quiet
        err=true
        next
      end
      if tmp.length>cc
        $stderr.puts ME+"line #{line}: columns mismatch" if not $quiet
        err=true
        next
      end
      if zt==0 or zt!=ti
        if !ret=fix_cols(tmp,col,s)
          $stderr.puts ME+"line #{line}: "+$err if not $quiet
          err=true
          next
        end
        if ret!=s
          $stderr.puts ME+"line #{line}: format error" if not $quiet
          err=true
          next
        end
      else
        zf=zt
        if tmp.length>2 or s.count("\t")!=zt
          $stderr.puts ME+"line #{line}: format error" if not $quiet
          err=true
          next
        end
      end
      if /[ \t]$/.match(s)
        $stderr.puts ME+"line #{line}: whitespace at the end of line" if not $quiet
        err=true
        next
      end
      t=tmp.shift
      if / $/.match(t)
        $stderr.puts ME+"line #{line}: whitespace at the end of column" if not $quiet
        err=true
        next
      end
      for t in tmp
        if t.include?("  ")
          $stderr.puts ME+"line #{line}: double space detected" if not $quiet
          err=true
          break
        end
        if /^ /.match(t)
          $stderr.puts ME+"line #{line}: whitespace at the begining of column" if not $quiet
          err=true
          break
        end
        if / $/.match(t)
          $stderr.puts ME+"line #{line}: whitespace at the end of column" if not $quiet
          err=true
          break
        end
      end
      next
    end
    if s.start_with?("#")
      hdr=s
      next
    end
    if s.start_with?("-----")
      if !hdr or !fld
        $stderr.puts ME+"line #{line}: missing block header" if not $quiet
        err=true
        break
      end
      sep=s
      if block_ok?(hdr)
        if fld.include?("  ")
          $stderr.puts ME+"line #{line}: double space detected" if not $quiet
          err=true
          break
        end
        cc=fld.split(/\t+/).length
        $ft=[]
        tc=0
        for t in fld.scan(/[^\t]+\t*/)
          n=t.count("\t")+t.count("^\t")/8
          if t.start_with?("_")
            zt=tc
            u=col.pop
            col<<n+u
          else
            $ft<<tc
            if t.count("\t")==0
              col<<0
            else
              col<<n
            end
          end
          tc+=n
        end
        col.collect! { |t| (t==0) ? "." : t.to_s }
        inbl=true
        next
      end
      igbl=true
      next
    end
    if hdr
      fld=s
      next
    end
  end
  if inbl
    $stderr.puts ME+"line #{line}: missing block ending separator" if not $quiet
    err=true
  end
  return err
end

def p_csv(sbuf,col)
  buf=[]
  str=nil
  i,j=nil
  ok=nil
  for s in sbuf
    if str
      str+=" "+s
      next if !j=str.index('"',i)
      i=j+1
    else
      str=s
      i=0
    end
    ok=true
    while j=str.index('"',i)
      i=j+1
      if !j=str.index('"',i)
        ok=false
        break
      end
      i=j+1
    end
    if ok
      buf<<str
      str=nil
    end
  end
  dbuf=["# ?"]
  fld=nil
  c=col.length
  for s in buf
    break if s.empty?
    l=s.length
    i=0
    p=0
    row=[]
    while i<l
      if s[i]==34
        i+=1
        p=i
        while j=s.index('"',i)
          if s[j+1]==34
            i=j+2
            next
          end
          break
        end
        q=j-1
        str=s.slice(p..q)
        str.gsub!(/""/,'"')
        row.push(str)
        i=j+2
        p=i
        next
      end
      if !j=s.index(",",i)
        str=s.slice(i,l)
        row.push((str.empty?) ? "-" : str)
        break
      end
      q=j-1
      str=s.slice(p..q)
      row.push((str.empty?) ? "-" : str)
      i=j+1
      p=i
    end
    if $map
      row=remap(row)
    else
      row=row.slice(0,col.length)
    end
    if fld
      if !ret=fix_cols(row,col)
        $stderr.puts ME+$err
        exit
      end
      dbuf.push(ret) if not ret.empty?
      next
    end
    if !fld=fix_cols(row,col)
      $stderr.puts ME+$err
      exit
    end
    dbuf.push(fld)
    dbuf.push("-"*$rs)
  end
  dbuf.push("-"*$rs)
  return dbuf
end

def usage
  me=ME.delete(":")
  puts "Usage: "+me+"[-n] [-B <pattern>] [-S <pattern>] <file> [<cols>]"
  exit
end

outfn=nil
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]=="-i"
    i+=1
    $wib=true
    next
  end
  if ARGV[i]=="-n"
    i+=1
    mode="check"
    $wib=true
    next
  end
  if ARGV[i]=="-q"
    i+=1
    $quiet=true
    next
  end
  if ARGV[i]=="-o"
    i+=1
    if !ARGV[i]
      $stderr.puts ME+"Need argument for '-o' option"
      exit
    end
    outfn=ARGV[i]
    i+=1
    next
  end
  if ARGV[i]=="-long"
    i+=1
    $rs=254
    next
  end
  if ARGV[i]=="-csv"
    i+=1
    mode="csv"
    $rs=254
    next
  end
  if ARGV[i]=="-map"
    i+=1
    if !ARGV[i]
      $stderr.puts ME+"Need argument for '-map' option"
      exit
    end
    $map=ARGV[i].split(",").collect { |t| t.to_i-1 }
    i+=1
    next
  end
  if ARGV[i]=="-B"
    i+=1
    if !ARGV[i]
      $stderr.puts ME+"Need argument for '-B' option"
      exit
    end
    $wib=true if ARGV[i].start_with?("!")
    str=regexfix2(ARGV[i])
    $incl.push(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
    $wib=true if ARGV[i].start_with?("!")
    str=regexfix2(ARGV[i])
    $excl.push(Regexp.new(str,true))
    i+=1
    next
  end
  $stderr.puts ME+"Unknown option: "+ARGV[i]
  exit
end

if i>=ARGV.length
  fn=nil
else
  fn=ARGV[i]
  if mode!="check"
    usage if i+1>=ARGV.length
    col=ARGV[i+1].split(",")
  end
end

sbuf=[]
err=false
if !fn or fn=="-"
  for l in $stdin
    err=l.include?("\r") if not err
    l.chop!
    sbuf.push(l)
  end
else
  begin
    f=File.open(fn,"r")
  rescue
    $stderr.puts ME+"unable to open file"
    exit
  end
  for l in f
    err=l.include?("\r") if not err
    l.chop!
    sbuf.push(l)
  end
  f.close
end

if mode=="check"
  if err
    $stderr.puts ME+"file is not in UNIX format" if not $quiet
    exit(1)
  end
  if not sbuf[0].start_with?("! vim:")
    $stderr.puts ME+"line 1: VIM options not found" if not $quiet
    exit(1)
  end
  if m=/^! blrs:([0-9]+)/.match(sbuf[1])
    $rs=m[1].to_i
  end
  exit(1) if p_txt_check(sbuf)
  exit(0)
end

if !outfn
  if mode=="csv"
    tmp=fn.split(".")
    tmp.pop if tmp.length>1
    tmp.push("txt")
    outfn=tmp.join(".")
  else
    outfn=fn
  end
end

if mode=="txt"
  dbuf=p_txt(sbuf,col)
end
if mode=="csv"
  dbuf=p_csv(sbuf,col)
end

if outfn=="-"
  dbuf.each { |l| $stdout.puts l }
  exit
end
begin
  f=File.open(outfn,"w")
rescue
  $stderr.puts ME+"unable to open file"
  exit
end
dbuf.each { |l| f.puts l }
f.close