module ChunkyPNG::Canvas::Operations

def border(size, color = ChunkyPNG::Color::BLACK)
  dup.border!(size, color)
end

def border!(size, color = ChunkyPNG::Color::BLACK)
  new_width  = width  + size * 2
  new_height = height + size * 2
  bg = Canvas.new(new_width, new_height, color).replace(self, size, size)
  replace_canvas!(new_width, new_height, bg.pixels)
end

def check_size_constraints!(other, offset_x, offset_y)
  if width  < other.width  + offset_x
    raise ChunkyPNG::OutOfBounds, 'Background image width is too small!'
  end
  if height < other.height + offset_y
    raise ChunkyPNG::OutOfBounds, 'Background image height is too small!'
  end
end

def compose(other, offset_x = 0, offset_y = 0)
  dup.compose!(other, offset_x, offset_y)
end

def compose!(other, offset_x = 0, offset_y = 0)
  check_size_constraints!(other, offset_x, offset_y)
  for y in 0...other.height do
    for x in 0...other.width do
      set_pixel(x + offset_x,
                y + offset_y,
                ChunkyPNG::Color.compose(other.get_pixel(x, y),
                                         get_pixel(x + offset_x,
                                                   y + offset_y)))
    end
  end
  self
end

def crop(x, y, crop_width, crop_height)
  dup.crop!(x, y, crop_width, crop_height)
end

def crop!(x, y, crop_width, crop_height)
  if crop_width + x > width
    raise ChunkyPNG::OutOfBounds, 'Original image width is too small!'
  end
  if crop_height + y > height
    raise ChunkyPNG::OutOfBounds, 'Original image height is too small!'
  end
  if crop_width == width && x == 0
    # We only need to crop off the top and/or bottom, so we can take a
    # shortcut.
    replace_canvas!(crop_width, crop_height,
                    pixels.slice(y * width, width * crop_height))
  else
    new_pixels = []
    for cy in 0...crop_height do
      new_pixels.concat pixels.slice((cy + y) * width + x, crop_width)
    end
    replace_canvas!(crop_width, crop_height, new_pixels)
  end
end

def flip_horizontally
  dup.flip_horizontally!
end

def flip_horizontally!
  for y in 0..((height - 1) >> 1) do
    other_y   = height - (y + 1)
    other_row = row(other_y)
    replace_row!(other_y, row(y))
    replace_row!(y, other_row)
  end
  self
end

def flip_vertically
  dup.flip_vertically!
end

def flip_vertically!
  for y in 0...height do
    replace_row!(y, row(y).reverse)
  end
  self
end

def grayscale
  dup.grayscale!
end

def grayscale!
  pixels.map! { |pixel| ChunkyPNG::Color.to_grayscale(pixel) }
  self
end

def replace(other, offset_x = 0, offset_y = 0)
  dup.replace!(other, offset_x, offset_y)
end

def replace!(other, offset_x = 0, offset_y = 0)
  check_size_constraints!(other, offset_x, offset_y)
  for y in 0...other.height do
    for d in 0...other.width
      pixels[(y + offset_y) * width + offset_x + d] = other.pixels[y * other.width + d]
    end
  end
  self
end

def rotate_180
  dup.rotate_180!
end

def rotate_180!
  pixels.reverse!
  self
end

def rotate_left
  dup.rotate_left!
end

def rotate_left!
  new_pixels = []
  (width - 1).downto(0) { |i| new_pixels += column(i) }
  replace_canvas!(height, width, new_pixels)
end

def rotate_right
  dup.rotate_right!
end

def rotate_right!
  new_pixels = []
  0.upto(width - 1) { |i| new_pixels += column(i).reverse }
  replace_canvas!(height, width, new_pixels)
end

def trim(border = pixels.first)
  dup.trim!
end

def trim!(border = pixels.first)
  x1 = [*0...width].index   { |c| column(c).uniq != [border] }
  x2 = [*0...width].rindex  { |c| column(c).uniq != [border] }
  y1 = [*0...height].index  { |r|    row(r).uniq != [border] }
  y2 = [*0...height].rindex { |r|    row(r).uniq != [border] }
  crop! x1, y1, x2 - x1 + 1, y2 - y1 + 1
end