class GridStruct

# File lib/grid_struct.rb, line 10
def initialize(rows, columns, store = [])
  @rows = rows
  @columns = columns
  @store = store || []
end

# File lib/grid_struct.rb, line 111
def ==(other)
  @store == other.instance_variable_get(:@store)
end

# File lib/grid_struct.rb, line 84
def column(n)
  GridStruct::Selector.new(self,*@rows.times.map do |row|
    get_index(row,n)
  end)
end

# File lib/grid_struct.rb, line 90
def diagonals(row,column)
  selectors = []

  first = diagonal_builder({row: row, column: column})
  second = diagonal_builder({row: row, column: column}, 1, -1)

  selectors.push(GridStruct::Selector.new(self, *first)) if first.size > 1
  selectors.push(GridStruct::Selector.new(self, *second)) if second.size > 1

  return selectors
end

# File lib/grid_struct.rb, line 38
def each
  @store.fill(nil,@store.size...size).each.with_index do |value, index|
    row_column = get_row_column_at(index)
    yield(value,row_column[:row],row_column[:column])
  end
end

# File lib/grid_struct.rb, line 45
def each_slice(rows,columns)
  sub_rows = (@rows / rows.to_f).ceil
  sub_columns = (@columns / columns.to_f).ceil

  sub_rows.times.each do |sub_row|
    sub_columns.ceil.times.each do |sub_column|

      index = sub_column + (sub_row * sub_columns)
      yield(slice(index, rows: rows, columns: columns), index)

    end
  end
end

# File lib/grid_struct.rb, line 59
def get(row,column)
  @store[get_index(row,column)]
end

# File lib/grid_struct.rb, line 20
def map!
  size.times.map do |index|
    value = @store[index]
    row_column = get_row_column_at(index)
    @store[index] = yield(value, row_column[:row], row_column[:column])
  end
  return self
end

# File lib/grid_struct.rb, line 33
def map_column!(n, &block)
  return map_line!(n, @rows, false, &block)
end

# File lib/grid_struct.rb, line 29
def map_row!(n, &block)
  return map_line!(n, @columns, true, &block)
end

# File lib/grid_struct.rb, line 78
def row(n)
  start_index = (n * @columns)
  end_index = start_index + @columns
  GridStruct::Selector.new(self,*(start_index...end_index))
end

# File lib/grid_struct.rb, line 16
def set(row,column)
  @store[get_index(row,column)] = yield
end

# File lib/grid_struct.rb, line 102
def size
  @rows * @columns
end

# File lib/grid_struct.rb, line 65
def slice(index,dimensions)
  rows = dimensions[:rows]
  columns = dimensions[:columns]
  sub_columns = (@columns / columns.to_f).ceil

  sub_row = index / sub_columns
  sub_column = index - (sub_row * sub_columns)

  indexes = retrieve_sliced_indexes(rows,columns,sub_row,sub_column)

  return GridStruct::Selector.new(self, *indexes).dimensions(rows,columns)
end

# File lib/grid_struct.rb, line 106
def to_a
  store_size = @store.size
  return @store.dup.fill(nil,store_size...size)
end

# File lib/grid_struct.rb, line 115
def within_bounds?(row,column)
  row_within_bounds?(row) && column_within_bounds?(column)
end

# File lib/grid_struct.rb, line 155
def column_within_bounds?(column)
  line_within_bounds?(column, @columns)
end

# File lib/grid_struct.rb, line 169
def diagonal_builder(coordinates, row_direction = 1, column_direction = 1, diagonal_indexes = [], action = :push)
  row = coordinates[:row]
  column = coordinates[:column]
  index = get_index(row,column)

  if !diagonal_indexes.include?(index) && within_bounds?(row, column)
    diagonal_indexes.method(action).call(get_index(row,column))

    fetch_diagonal_index(row, column, row_direction, column_direction, diagonal_indexes, -1)
    fetch_diagonal_index(row, column, row_direction, column_direction, diagonal_indexes, 1)
  end

  return diagonal_indexes
end

# File lib/grid_struct.rb, line 184
def fetch_diagonal_index(row, column, row_direction, column_direction, diagonal_indexes, sign)
  row = row + sign * row_direction
  column = column + sign * column_direction
  action = sign > 0 ? :push : :unshift

  diagonal_builder({ row: row,
                     column: column },
                   row_direction,
                   column_direction,
                   diagonal_indexes,
                   action)
end

# File lib/grid_struct.rb, line 121
def fit_selection_within_same_row(start_index, end_index)
  start_row = get_row_column_at(start_index)[:row]
  end_row = get_row_column_at(end_index)[:row]

  if start_row != end_row
    extras = [0,(end_index - @columns)].max % @columns
    end_index -= extras
  end

  return start_index...end_index
end

# File lib/grid_struct.rb, line 159
def get_index(row,column)
  (row * @columns) + column
end

# File lib/grid_struct.rb, line 163
def get_row_column_at(index)
  row = index / @columns
  column = index - (row * @columns)
  return { row: row, column: column }
end

# File lib/grid_struct.rb, line 147
def line_within_bounds?(n, axis_size)
  n >= 0 && n < axis_size
end

# File lib/grid_struct.rb, line 197
def map_line!(n, other_axis_size, is_row)
  other_axis_size.times.each do |other_axis|
    index = is_row ? get_index(n,other_axis) : get_index(other_axis,n)
    value = @store[index]
    @store[index] = yield(value,other_axis)
  end
  return self
end

# File lib/grid_struct.rb, line 133
def retrieve_sliced_indexes(rows, columns, sub_row, sub_column)
  rows.times.inject([]) do |memo, r|
    start_index = (r * @columns) +
      (sub_row * rows * @columns) +
      (sub_column * columns)
    end_index = start_index + columns

    final_row_indexes = fit_selection_within_same_row(start_index, end_index).to_a
    final_row_indexes.fill(nil,final_row_indexes.size...columns)

    memo += final_row_indexes
  end
end

# File lib/grid_struct.rb, line 151
def row_within_bounds?(row)
  line_within_bounds?(row, @rows)
end