class ChunkyPNG::Canvas

def self.from_canvas(canvas)
  new(canvas.width, canvas.height, canvas.pixels.dup)
end

def [](x, y)
  assert_xy!(x, y)
  @pixels[y * width + x]
end

def []=(x, y, color)
  assert_xy!(x, y)
  @pixels[y * width + x] = ChunkyPNG::Color.parse(color)
end

def area
  pixels.length
end

def assert_height!(vector_length)
  if height != vector_length
    raise ChunkyPNG::ExpectationFailed,
      "The length of the vector (#{vector_length}) does not match the canvas height (#{height})!"
  end
  true
end

def assert_size!(matrix_width, matrix_height)
  if width  != matrix_width
    raise ChunkyPNG::ExpectationFailed,
      'The width of the matrix does not match the canvas width!'
  end
  if height != matrix_height
    raise ChunkyPNG::ExpectationFailed,
      'The height of the matrix does not match the canvas height!'
  end
  true
end

def assert_width!(vector_length)
  if width != vector_length
    raise ChunkyPNG::ExpectationFailed,
      "The length of the vector (#{vector_length}) does not match the canvas width (#{width})!"
  end
  true
end

def assert_x!(x)
  unless include_x?(x)
    raise ChunkyPNG::OutOfBounds, "Column index #{x} out of bounds!"
  end
  true
end

def assert_xy!(x, y)
  unless include_xy?(x, y)
    raise ChunkyPNG::OutOfBounds, "Coordinates (#{x},#{y}) out of bounds!"
  end
  true
end

def assert_y!(y)
  unless include_y?(y)
    raise ChunkyPNG::OutOfBounds, "Row index #{y} out of bounds!"
  end
  true
end

def column(x)
  assert_x!(x)
  (0...height).inject([]) { |pixels, y| pixels << get_pixel(x, y) }
end

def dimension
  ChunkyPNG::Dimension.new(width, height)
end

def eql?(other)
  other.kind_of?(self.class) && other.pixels == self.pixels &&
        other.width == self.width && other.height == self.height
end

def get_pixel(x, y)
  @pixels[y * width + x]
end

def include_point?(*point_like)
  dimension.include?(ChunkyPNG::Point(*point_like))
end

def include_x?(x)
  x >= 0 && x < width
end

def include_xy?(x, y)
  y >= 0 && y < height && x >= 0 && x < width
end

def include_y?(y)
  y >= 0 && y < height
end

def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
  @width, @height = width, height
  if initial.kind_of?(Array)
    unless initial.length == width * height
      raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!"
    end
    @pixels = initial
  else
    @pixels = Array.new(width * height, ChunkyPNG::Color.parse(initial))
  end
end

def initialize_copy(other)
  @width, @height = other.width, other.height
  @pixels = other.pixels.dup
end

def inspect
  inspected = "<#{self.class.name} #{width}x#{height} ["
  for y in 0...height
    inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(' ') << ']'
  end
  inspected << "\n]>"
end

def palette
  ChunkyPNG::Palette.from_canvas(self)
end

def replace_canvas!(new_width, new_height, new_pixels)
  unless new_pixels.length == new_width * new_height
    raise ArgumentError, "The provided pixel array should have #{new_width * new_height} items"
  end
  @width, @height, @pixels = new_width, new_height, new_pixels
  self
end

def replace_column!(x, vector)
  assert_x!(x) && assert_height!(vector.length)
  for y in 0...height do
    set_pixel(x, y, vector[y])
  end
end

def replace_row!(y, vector)
  assert_y!(y) && assert_width!(vector.length)
  pixels[y * width, width] = vector
end

def row(y)
  assert_y!(y)
  pixels.slice(y * width, width)
end

def set_pixel(x, y, color)
  @pixels[y * width + x] = color
end

def set_pixel_if_within_bounds(x, y, color)
  return unless include_xy?(x, y)
  @pixels[y * width + x] = color
end

def to_image
  ChunkyPNG::Image.from_canvas(self)
end