class Cucumber::Ast::Table

def self.default_arg_name #:nodoc:
  "table"
end

def accept(visitor) #:nodoc:
  return if $cucumber_interrupted
  cells_rows.each do |row|
    visitor.visit_table_row(row)
  end
  nil
end

def arguments_replaced(arguments) #:nodoc:
  raw_with_replaced_args = raw.map do |row|
    row.map do |cell|
      cell_with_replaced_args = cell
      arguments.each do |name, value|
        if cell_with_replaced_args && cell_with_replaced_args.include?(name)
          cell_with_replaced_args = value ? cell_with_replaced_args.gsub(name, value) : nil
        end
      end
      cell_with_replaced_args
    end
  end
  Table.new(raw_with_replaced_args)
end

def cell_matrix #:nodoc:
  @cell_matrix
end

def cells_rows #:nodoc:
  @rows ||= cell_matrix.map do |cell_row|
    @cells_class.new(self, cell_row)
  end
end

def clear_cache! #:nodoc:
  @hashes = @rows_hash = @rows = @columns = nil
end

def col_width(col) #:nodoc:
  columns[col].__send__(:width)
end

def columns #:nodoc:
  @columns ||= cell_matrix.transpose.map do |cell_row|
    @cells_class.new(self, cell_row)
  end
end

def convert_columns! #:nodoc:
  cell_matrix.transpose.each do |col|
    conversion_proc = @conversion_procs[col[0].value]
    col[1..-1].each do |cell|
      cell.value = conversion_proc.call(cell.value)
    end
  end
end

def create_cell_matrix(raw) #:nodoc:
  @cell_matrix = raw.map do |raw_row|
    line = raw_row.line rescue -1
    raw_row.map do |raw_cell|
      new_cell(raw_cell, line)
    end
  end
end

def diff!(other_table, options={})
  options = {:missing_row => true, :surplus_row => true, :missing_col => true, :surplus_col => false}.merge(options)
  other_table = ensure_table(other_table)
  other_table.convert_columns!
  ensure_green!
  original_width = cell_matrix[0].length
  other_table_cell_matrix = pad!(other_table.cell_matrix)
  padded_width = cell_matrix[0].length
  missing_col = cell_matrix[0].detect{|cell| cell.status == :undefined}
  surplus_col = padded_width > original_width
  require_diff_lcs
  cell_matrix.extend(Diff::LCS)
  convert_columns!
  changes = cell_matrix.diff(other_table_cell_matrix).flatten
  inserted = 0
  missing  = 0
  row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
  last_change = nil
  missing_row_pos = nil
  insert_row_pos  = nil
  
  changes.each do |change|
    if(change.action == '-')
      missing_row_pos = change.position + inserted
      cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
      row_indices.insert(missing_row_pos, nil)
      missing += 1
    else # '+'
      insert_row_pos = change.position + missing
      inserted_row = change.element
      inserted_row.each{|cell| cell.status = :comment}
      cell_matrix.insert(insert_row_pos, inserted_row)
      row_indices[insert_row_pos] = nil
      inspect_rows(cell_matrix[missing_row_pos], inserted_row) if last_change && last_change.action == '-'
      inserted += 1
    end
    last_change = change
  end
  other_table_cell_matrix.each_with_index do |other_row, i|
    row_index = row_indices.index(i)
    row = cell_matrix[row_index] if row_index
    if row
      (original_width..padded_width).each do |col_index|
        surplus_cell = other_row[col_index]
        row[col_index].value = surplus_cell.value if row[col_index]
      end
    end
  end
  
  clear_cache!
  should_raise = 
    missing_row_pos && options[:missing_row] ||
    insert_row_pos  && options[:surplus_row] ||
    missing_col     && options[:missing_col] ||
    surplus_col     && options[:surplus_col]
  raise Different.new(self) if should_raise
end

def dup
  self.class.new(raw.dup, @conversion_procs.dup)
end

def each_cell(&proc) #:nodoc:
  cell_matrix.each{|row| row.each(&proc)}
end

def each_cells_row(&proc) #:nodoc:
  cells_rows.each(&proc)
end

def ensure_array_of_array(array)
  Hash === array[0] ? hashes_to_array(array) : array
end

def ensure_green! #:nodoc:
  each_cell{|cell| cell.status = :passed}
end

def ensure_table(table_or_array) #:nodoc:
  return table_or_array if Table === table_or_array
  Table.new(table_or_array)
end

def has_text?(text) #:nodoc:
  raw.flatten.compact.detect{|cell_value| cell_value.index(text)}
end

def hashes
  @hashes ||= cells_rows[1..-1].map do |row|
    row.to_hash
  end
end

def hashes_to_array(hashes) #:nodoc:
  header = hashes[0].keys
  [header] + hashes.map{|hash| header.map{|key| hash[key]}}
end

def header_cell(col) #:nodoc:
  cells_rows[0][col]
end

def headers #:nodoc:
  raw.first
end

def index(cells) #:nodoc:
  cells_rows.index(cells)
end

def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup)
  @cells_class = Cells
  @cell_class = Cell
  raw = ensure_array_of_array(raw)
  # Verify that it's square
  transposed = raw.transpose
  create_cell_matrix(raw)
  @conversion_procs = conversion_procs
end

def inspect_rows(missing_row, inserted_row) #:nodoc:
  missing_row.each_with_index do |missing_cell, col|
    inserted_cell = inserted_row[col]
    if(missing_cell.value != inserted_cell.value && (missing_cell.value.to_s == inserted_cell.value.to_s))
      missing_cell.inspect!
      inserted_cell.inspect!
    end
  end
end

def map_column!(column_name, strict=true, &conversion_proc)
  verify_column(column_name) if strict
  @conversion_procs[column_name] = conversion_proc
end

def map_headers(mappings={})
  table = self.dup
  table.map_headers!(mappings)
  table
end

def map_headers!(mappings={}, &block)
  header_cells = cell_matrix[0]
  if block_given?
    header_values = header_cells.map { |cell| cell.value } - mappings.keys
    mappings = mappings.merge(Hash[*header_values.zip(header_values.map(&block)).flatten])
  end
  mappings.each_pair do |pre, post|
    mapped_cells = header_cells.select{|cell| pre === cell.value}
    raise "No headers matched #{pre.inspect}" if mapped_cells.empty?
    raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map{|c| c.value}.inspect}" if mapped_cells.length > 1
    mapped_cells[0].value = post
    if @conversion_procs.has_key?(pre)
      @conversion_procs[post] = @conversion_procs.delete(pre)
    end
  end
end

def mark_as_missing(col) #:nodoc:
  col.each do |cell|
    cell.status = :undefined
  end
end

def match(pattern)
  header_to_match = "table:#{headers.join(',')}"
  pattern.match(header_to_match)
end

def new_cell(raw_cell, line) #:nodoc:
  @cell_class.new(raw_cell, self, line)
end

def pad!(other_cell_matrix) #:nodoc:
  clear_cache!
  cols = cell_matrix.transpose
  unmapped_cols = other_cell_matrix.transpose
  mapped_cols = []
  cols.each_with_index do |col, col_index|
    header = col[0]
    candidate_cols, unmapped_cols = unmapped_cols.partition do |other_col|
      other_col[0] == header
    end
    raise "More than one column has the header #{header}" if candidate_cols.size > 2
    other_padded_col = if candidate_cols.size == 1
      # Found a matching column
      candidate_cols[0]
    else
      mark_as_missing(cols[col_index])
      (0...other_cell_matrix.length).map do |row|
        val = row == 0 ? header.value : nil
        SurplusCell.new(val, self, -1)
      end
    end
    mapped_cols.insert(col_index, other_padded_col)
  end
  unmapped_cols.each_with_index do |col, col_index|
    empty_col = (0...cell_matrix.length).map do |row| 
      SurplusCell.new(nil, self, -1)
    end
    cols << empty_col
  end
  @cell_matrix = cols.transpose
  (mapped_cols + unmapped_cols).transpose
end

def raw
  cell_matrix.map do |row|
    row.map do |cell|
      cell.value
    end
  end
end

def require_diff_lcs #:nodoc:
  begin
    require 'diff/lcs'
  rescue LoadError => e
    e.message << "\n Please gem install diff-lcs\n"
    raise e
  end
end

def rows
  raw[1..-1]
end

def rows_hash
  return @rows_hash if @rows_hash
  verify_table_width(2)
  @rows_hash = self.transpose.hashes[0]
end

def to_hash(cells) #:nodoc:
  hash = Hash.new do |hash, key|
    hash[key.to_s] if key.is_a?(Symbol)
  end
  raw[0].each_with_index do |column_name, column_index|
    value = @conversion_procs[column_name].call(cells.value(column_index))
    hash[column_name] = value
  end
  hash
end

def to_json
  raw.to_json
end

def to_s(options = {}) #:nodoc:
  options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
  io = StringIO.new
  c = Term::ANSIColor.coloring?
  Term::ANSIColor.coloring = options[:color]
  formatter = Formatter::Pretty.new(nil, io, options)
  formatter.instance_variable_set('@indent', options[:indent])
  TreeWalker.new(nil, [formatter]).visit_multiline_arg(self)
  
  Term::ANSIColor.coloring = c
  io.rewind
  s = "\n" + io.read + (" " * (options[:indent] - 2))
  s
end

def to_sexp #:nodoc:
  [:table, *cells_rows.map{|row| row.to_sexp}]
end

def transpose
  self.class.new(raw.transpose, @conversion_procs.dup)
end

def verify_column(column_name) #:nodoc:
  raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name)
end

def verify_table_width(width) #:nodoc:
  raise %{The table must have exactly #{width} columns} unless raw[0].size == width
end