module ChunkyPNG::Color

def a(value)
  value & 0x000000ff
end

def alpha_decomposable?(color, mask, bg, tolerance = 1)
  components = decompose_alpha_components(color, mask, bg)
  sum = components.inject(0) { |a,b| a + b }
  max = components.max * 3
  components.max <= 255 && components.min >= 0 && (sum + tolerance * 3) >= max
end

def b(value)
  (value & 0x0000ff00) >> 8
end

def blend(fg, bg)
  (fg + bg) >> 1
end

def compose_precise(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)
  fg_a  = a(fg).to_f / MAX
  bg_a  = a(bg).to_f / MAX
  a_com = (1.0 - fg_a) * bg_a
  new_r = (fg_a * r(fg) + a_com * r(bg)).round
  new_g = (fg_a * g(fg) + a_com * g(bg)).round
  new_b = (fg_a * b(fg) + a_com * b(bg)).round
  new_a = ((fg_a + a_com) * MAX).round
  rgba(new_r, new_g, new_b, new_a)
end

def compose_quick(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)
  a_com = int8_mult(0xff - a(fg), a(bg))
  new_r = int8_mult(a(fg), r(fg)) + int8_mult(a_com, r(bg))
  new_g = int8_mult(a(fg), g(fg)) + int8_mult(a_com, g(bg))
  new_b = int8_mult(a(fg), b(fg)) + int8_mult(a_com, b(bg))
  new_a = a(fg) + a_com
  rgba(new_r, new_g, new_b, new_a)
end

def cylindrical_to_cubic(hue, saturation, y_component, chroma)
  hue_prime = hue.fdiv(60)
  x = chroma * (1 - (hue_prime % 2 - 1).abs)
  case hue_prime
  when (0...1); [chroma, x, 0]
  when (1...2); [x, chroma, 0]
  when (2...3); [0, chroma, x]
  when (3...4); [0, x, chroma]
  when (4...5); [x, 0, chroma]
  when (5..6);  [chroma, 0, x]
  end
end

def decompose_alpha(color, mask, bg)
  components = decompose_alpha_components(color, mask, bg)
  (components.inject(0) { |a,b| a + b } / 3.0).round
end

def decompose_alpha_component(channel, color, mask, bg)
  cc, mc, bc = send(channel, color), send(channel, mask), send(channel, bg)
  return 0x00 if bc == cc
  return 0xff if bc == mc
  return 0xff if cc == mc
  (((bc - cc).to_f / (bc - mc).to_f) * MAX).round
end

def decompose_alpha_components(color, mask, bg)
  [
    decompose_alpha_component(:r, color, mask, bg),
    decompose_alpha_component(:g, color, mask, bg),
    decompose_alpha_component(:b, color, mask, bg)
  ]
end

def decompose_color(color, mask, bg, tolerance = 1)
  if alpha_decomposable?(color, mask, bg, tolerance)
    mask & 0xffffff00 | decompose_alpha(color, mask, bg)
  else
    mask & 0xffffff00
  end
end

def euclidean_distance_rgba(pixel_after, pixel_before)
  Math.sqrt(
    (r(pixel_after) - r(pixel_before))**2 +
    (g(pixel_after) - g(pixel_before))**2 +
    (b(pixel_after) - b(pixel_before))**2 +
    (a(pixel_after) - a(pixel_before))**2
  )
end

def fade(color, factor)
  new_alpha = int8_mult(a(color), factor)
  (color & 0xffffff00) | new_alpha
end

def from_hex(hex_value, opacity = nil)
  base_color = case hex_value
               when HEX3_COLOR_REGEXP
                 $1.gsub(/([0-9a-f])/i, '\1\1').hex << 8
               when HEX6_COLOR_REGEXP
                 $1.hex << 8
               else
                 raise ArgumentError, "Not a valid hex color notation: #{hex_value.inspect}!"
               end
  opacity  ||= $2 ? $2.hex : 0xff
  base_color | opacity
end

def from_hsl(hue, saturation, lightness, alpha = 255)
  raise ArgumentError, "Hue #{hue} was not between 0 and 360" unless (0..360).include?(hue)
  raise ArgumentError, "Saturation #{saturation} was not between 0 and 1" unless (0..1).include?(saturation)
  raise ArgumentError, "Lightness #{lightness} was not between 0 and 1" unless (0..1).include?(lightness)
  chroma = (1 - (2 * lightness - 1).abs) * saturation
  rgb    = cylindrical_to_cubic(hue, saturation, lightness, chroma)
  rgb.map! { |component| ((component + lightness - 0.5 * chroma) * 255).to_i }
  rgb << alpha
  self.rgba(*rgb)
end

def from_hsv(hue, saturation, value, alpha = 255)
  raise ArgumentError, "Hue must be between 0 and 360" unless (0..360).include?(hue)
  raise ArgumentError, "Saturation must be between 0 and 1" unless (0..1).include?(saturation)
  raise ArgumentError, "Value/brightness must be between 0 and 1" unless (0..1).include?(value)
  chroma = value * saturation
  rgb    = cylindrical_to_cubic(hue, saturation, value, chroma)
  rgb.map! { |component| ((component + value - chroma) * 255).to_i }
  rgb << alpha
  self.rgba(*rgb)
end

def from_rgb_stream(stream, pos = 0)
  rgb(*stream.unpack("@#{pos}C3"))
end

def from_rgba_stream(stream, pos = 0)
  rgba(*stream.unpack("@#{pos}C4"))
end

def fully_transparent?(value)
  a(value) == 0x00000000
end

def g(value)
  (value & 0x00ff0000) >> 16
end

def grayscale(teint)
  teint << 24 | teint << 16 | teint << 8 | 0xff
end

def grayscale?(value)
  r(value) == b(value) && b(value) == g(value)
end

def grayscale_alpha(teint, a)
  teint << 24 | teint << 16 | teint << 8 | a
end

def grayscale_teint(color)
  (r(color) * 0.3 + g(color) * 0.59 + b(color) * 0.11).round
end

def html_color(color_name, opacity = nil)
  if color_name.to_s =~ HTML_COLOR_REGEXP
    opacity ||= $2 ? ($2.to_f * 255.0).round : 0xff
    base_color_name = $1.gsub(/[^a-z]+/i, '').downcase.to_sym
    return PREDEFINED_COLORS[base_color_name] | opacity if PREDEFINED_COLORS.has_key?(base_color_name)
  end
  raise ArgumentError, "Unknown color name #{color_name}!"
end

def hue_and_chroma(color)
  scaled_rgb      = to_truecolor_bytes(color)
  scaled_rgb.map! { |component| component.fdiv(255) }
  min, max = scaled_rgb.minmax
  chroma   = max - min
  r, g, b   = scaled_rgb
  hue_prime = chroma.zero? ? 0 : case max
                                 when r; (g - b).fdiv(chroma)
                                 when g; (b - r).fdiv(chroma) + 2
                                 when b; (r - g).fdiv(chroma) + 4
                                 else 0
                                 end
  hue = 60 * hue_prime
  return hue.round, chroma, max, min
end

def int8_mult(a, b)
  t = a * b + 0x80
  ((t >> 8) + t) >> 8
end

def interpolate_quick(fg, bg, alpha)
  return fg if alpha >= 255
  return bg if alpha <= 0
  alpha_com = 255 - alpha
  new_r = int8_mult(alpha, r(fg)) + int8_mult(alpha_com, r(bg))
  new_g = int8_mult(alpha, g(fg)) + int8_mult(alpha_com, g(bg))
  new_b = int8_mult(alpha, b(fg)) + int8_mult(alpha_com, b(bg))
  new_a = int8_mult(alpha, a(fg)) + int8_mult(alpha_com, a(bg))
  rgba(new_r, new_g, new_b, new_a)
end

def opaque!(value)
  value | 0x000000ff
end

def opaque?(value)
  a(value) == 0x000000ff
end

def parse(source)
  return source if source.kind_of?(Integer)
  case source.to_s
    when /^\d+$/; source.to_s.to_i
    when HEX3_COLOR_REGEXP, HEX6_COLOR_REGEXP; from_hex(source.to_s)
    when HTML_COLOR_REGEXP; html_color(source.to_s)
    else raise ArgumentError, "Don't know how to create a color from #{source.inspect}!"
  end
end

def pass_bytesize(color_mode, depth, width, height)
  return 0 if width == 0 || height == 0
  (scanline_bytesize(color_mode, depth, width) + 1) * height
end

def pixel_bitsize(color_mode, depth = 8)
  samples_per_pixel(color_mode) * depth
end

def pixel_bytesize(color_mode, depth = 8)
  return 1 if depth < 8
  (pixel_bitsize(color_mode, depth) + 7) >> 3
end

def r(value)
  (value & 0xff000000) >> 24
end

def rgb(r, g, b)
  r << 24 | g << 16 | b << 8 | 0xff
end

def rgba(r, g, b, a)
  r << 24 | g << 16 | b << 8 | a
end

def samples_per_pixel(color_mode)
  case color_mode
    when ChunkyPNG::COLOR_INDEXED;         1
    when ChunkyPNG::COLOR_TRUECOLOR;       3
    when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; 4
    when ChunkyPNG::COLOR_GRAYSCALE;       1
    when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; 2
    else raise ChunkyPNG::NotSupported, "Don't know the number of samples for this colormode: #{color_mode}!"
  end
end

def scanline_bytesize(color_mode, depth, width)
  ((pixel_bitsize(color_mode, depth) * width) + 7) >> 3
end

def to_grayscale(color)
  grayscale_alpha(grayscale_teint(color), a(color))
end

def to_grayscale_alpha_bytes(color)
  [b(color), a(color)] # assumption r == g == b
end

def to_grayscale_bytes(color)
  [b(color)] # assumption r == g == b
end

def to_hex(color, include_alpha = true)
  include_alpha ? ('#%08x' % color) : ('#%06x' % [color >> 8])
end

def to_hsl(color, include_alpha = false)
  hue, chroma, max, min = hue_and_chroma(color)
  lightness  = 0.5 * (max + min)
  saturation = chroma.zero? ? 0.0 : chroma.fdiv(1 - (2 * lightness - 1).abs)
  include_alpha ? [hue, saturation, lightness, a(color)] :
                  [hue, saturation, lightness]
end

def to_hsv(color, include_alpha = false)
  hue, chroma, max, _ = hue_and_chroma(color)
  value      = max
  saturation = chroma.zero? ? 0.0 : chroma.fdiv(value)
  include_alpha ? [hue, saturation, value, a(color)] :
                  [hue, saturation, value]
end

def to_truecolor_alpha_bytes(color)
  [r(color), g(color), b(color), a(color)]
end

def to_truecolor_bytes(color)
  [r(color), g(color), b(color)]
end