class Cucumber::MultilineArgument::DataTable

def self.default_arg_name
  'table'
end

def append_to(array)
  array << self
end

def build_hashes
  convert_headers!
  convert_columns!
  cells_rows[1..].map(&:to_hash)
end

def cells_rows
  @rows ||= cell_matrix.map do |cell_row|
    Cells.new(self, cell_row)
  end
end

def cells_to_hash(cells)
  hash = Hash.new do |hash_inner, key|
    hash_inner[key.to_s] if key.is_a?(Symbol)
  end
  column_names.each_with_index do |column_name, column_index|
    hash[column_name] = cells.value(column_index)
  end
  hash
end

def clear_cache!
  @hashes = @rows_hash = @column_names = @rows = @columns = nil
end

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

def column_names
  @column_names ||= cell_matrix[0].map(&:value)
end

def columns
  @columns ||= cell_matrix.transpose.map do |cell_row|
    Cells.new(self, cell_row)
  end
end

def convert_columns!
  @conversion_procs.each do |column_name, conversion_proc|
    verify_column(column_name) if conversion_proc[:strict]
  end
  cell_matrix.transpose.each do |col|
    column_name = col[0].value
    conversion_proc = @conversion_procs[column_name][:proc]
    col[1..].each do |cell|
      cell.value = conversion_proc.call(cell.value)
    end
  end
end

def convert_headers!
  header_cells = cell_matrix[0]
  if @header_conversion_proc
    header_values = header_cells.map(&:value) - @header_mappings.keys
    @header_mappings = @header_mappings.merge(Hash[*header_values.zip(header_values.map(&@header_conversion_proc)).flatten])
  end
  @header_mappings.each_pair do |pre, post|
    mapped_cells = header_cells.select { |cell| pre.is_a?(Regexp) ? cell.value.match?(pre) : cell.value == pre }
    raise "No headers matched #{pre.inspect}" if mapped_cells.empty?
    raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map(&:value).inspect}" if mapped_cells.length > 1
    mapped_cells[0].value = post
    @conversion_procs[post] = @conversion_procs.delete(pre) if @conversion_procs.key?(pre)
  end
end

def create_cell_matrix(ast_table)
  ast_table.raw.map do |raw_row|
    line = begin
      raw_row.line
    rescue StandardError
      -1
    end
    raw_row.map do |raw_cell|
      Cell.new(raw_cell, self, line)
    end
  end
end

def describe_to(visitor, *args)
  visitor.legacy_table(self, *args)
end

def diff!(other_table, options = {})
  other_table = ensure_table(other_table)
  other_table.convert_headers!
  other_table.convert_columns!
  convert_headers!
  convert_columns!
  DiffMatrices.new(cell_matrix, other_table.cell_matrix, options).call
end

def each_cells_row(&proc)
  cells_rows.each(&proc)
end

def ensure_table(table_or_array)
  return table_or_array if table_or_array.instance_of?(DataTable)
  DataTable.from(table_or_array)
end

def from(data)
  case data
  when Array
    from_array(data)
  when String
    parse(data)
  else
    raise ArgumentError, 'expected data to be a String or an Array.'
  end
end

def from_array(data)
  new Core::Test::DataTable.new(data)
end

def hashes
  @hashes ||= build_hashes
end

def header_cell(col)
  cells_rows[0][col]
end

def headers
  raw.first
end

def index(cells)
  cells_rows.index(cells)
end

def initialize(data, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
  raise ArgumentError, 'data must be a Core::Test::DataTable' unless data.is_a? Core::Test::DataTable
  ast_table = data
  # Verify that it's square
  ast_table.transpose
  @cell_matrix = create_cell_matrix(ast_table)
  @conversion_procs = conversion_procs
  @header_mappings = header_mappings
  @header_conversion_proc = header_conversion_proc
  @ast_table = ast_table
end

def location
  @ast_table.location
end

def map_column(column_name, strict: true, &conversion_proc)
  conversion_procs = @conversion_procs.dup
  conversion_procs[column_name.to_s] = { strict: strict, proc: conversion_proc }
  self.class.new(Core::Test::DataTable.new(raw), conversion_procs, @header_mappings.dup, @header_conversion_proc)
end

def map_headers(mappings = {}, &block)
  self.class.new(Core::Test::DataTable.new(raw), @conversion_procs.dup, mappings, block)
end

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

def parse(text)
  builder = Builder.new
  parser = Cucumber::Gherkin::DataTableParser.new(builder)
  parser.parse(text)
  from_array(builder.rows)
end

def raw
  cell_matrix.map do |row|
    row.map(&:value)
  end
end

def rows
  hashes.map do |hash|
    hash.values_at(*headers)
  end
end

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

def symbolic_hashes
  @symbolic_hashes ||=
    hashes.map do |string_hash|
      string_hash.transform_keys { |a| symbolize_key(a) }
    end
end

def symbolize_key(key)
  key.downcase.tr(' ', '_').to_sym
end

def text?(text)
  Cucumber.deprecate(
    'This method is no longer supported for checking text',
    '#text?',
    '11.0.0'
  )
  raw.flatten.compact.detect { |cell_value| cell_value.index(text) }
end

def to_hash
  cells_rows.map { |cells| cells.map(&:value) }
end

def to_json(*args)
  raw.to_json(*args)
end

def to_s(options = {})
  indentation = options.key?(:indent) ? options[:indent] : 2
  prefixes = options.key?(:prefixes) ? options[:prefixes] : TO_S_PREFIXES
  DataTablePrinter.new(self, indentation, prefixes).to_s
end

def to_step_definition_arg
  dup
end

def transpose
  self.class.new(Core::Test::DataTable.new(raw.transpose), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
end

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

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