class Jan < Hash
  def initialize(option={rep:"-"})
    @Initial = ["000000","001011","001101","001110","010011","011001","011100","010101","010110","011010"]
    @StartCode = ["a","b","W","d","X","f","g","h","i","j"]
    @Bar = [["0","1","2","3","4","5","6","7","8","9"],["A","B","C","D","E","F","G","H","I","J"],["L","M","N","O","P","Q","R","S","T","U"]]
    @option = option
  end
  
  def [](key=nil)
    case
      when key.instance_of?(Symbol)
        super(key)
      when key.instance_of?(String), key.instance_of?(Bignum), key.instance_of?(Fixnum)
        stmp = jan(key)
        if stmp
          self[key.to_s.to_sym] = stmp
        end
      when key.instance_of?(Array)
        atmp = Array.new
        key.flatten.each {|k|
          ktmp = jan(k)
          if ktmp
            self[k.to_s.to_sym] = ktmp
            atmp << ktmp
          else
            atmp << nil
          end
        }
        return atmp
#      when key.instance_of?(Hash)
#        return nil
      else
        return nil
    end
  end
  
  def jan(obj=nil)
    case
      when obj.instance_of?(String)
        obj = rep(obj)
        if numeric?(obj)
          s = obj.size
          case s
            when 7,8
              return seven(obj)
            when 12,13
              return twelve(obj)
            else
              return nil
          end
        else
          return nil
        end
      when obj.instance_of?(Bignum)
        return jan(obj.to_s)
      when obj.instance_of?(Fixnum)
        return jan(obj.to_s)
      when obj.instance_of?(Array)
        a = Array.new
        obj.each {|tmp|
          a << jan(tmp)
        }
        return a
      else
        return nil
    end
  end

  def numeric?(str)
    Integer(str)
    true
  rescue
    false
  end

  def rep(obj)
    rtmp = @option[:rep]
    if rtmp.instance_of?(String)
      return obj.gsub!(rtmp, "") || obj
    elsif rtmp.instance_of?(Array)
      tmpobj = ""
      rtmp.each {|v|
        tmpobj = obj.gsub!(v, "") || obj
      }
      return tmpobj
    else
      return obj
    end
  end

  def seven(n)
    strJan = ""
    strJan = "Y"
    4.times {|i| strJan << n[i] }
    strJan << "K"
    for i in 4..6
      strJan << @Bar[2][n[i].to_i]
    end
    strJan << @Bar[2][jancd(n)]
    strJan << "Z"
    return strJan
  end

  def twelve(n)
    strJan = ""
    strJan << @StartCode[n[0].to_i]
    6.times {|i| strJan << @Bar[@Initial[n[0].to_i][i].to_i][n[i+1].to_i] }
    strJan << "K"
    for i in 7..11
      strJan << @Bar[2][n[i].to_i]
    end
    strJan << @Bar[2][jancd(n)]
    strJan << "Z"
    return strJan
  end

  def jancd(n)
    s,m,g,k,h = n.size,"",0,0,0
    case s
      when 7,8
        m = ("00000" + n.to_s)[0..11]
      when 12,13
        m = n.to_s[0..11]
      else
        return nil
    end
    -1.step(-12,-2) {|i|
      g += m[i].to_i
      k += m[i-1].to_i
    }
    h = (g * 3 + k).to_s[-1].to_i
    return h == 0 ? 0 : 10 - h
  end
  
  def options
    return @option
  end
  
  def replace(obj=nil)
    case
      when obj.instance_of?(String)
        add_replace(obj)
        return @option
      when obj.instance_of?(Array)
        obj.each {|v|
          add_replace(v)
        }
        return @option
      when obj.instance_of?(Hash)
        tmp = obj[:rep]
        if tmp
          replace(tmp)
        end
        return @option
      else
        return "nil"
    end
  end
  
  def add_replace(obj)
    if @option[:rep].instance_of?(String)
      a = Array.new
      tmp = @option[:rep]
      a << tmp
      a << obj
      @option[:rep] = a
    else
      @option[:rep] << obj
    end
    @option[:rep].uniq!
  end
  private :add_replace
end