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
  return 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 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)
  ((send(channel, bg) - send(channel, color)).to_f / 
      (send(channel, bg) - send(channel, mask)).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 fade(color, factor)
  new_alpha = int8_mult(a(color), factor)
  (color & 0xffffff00) | new_alpha
end

def from_hex(hex_value, opacity = nil)
  if HEX_COLOR_REGEXP =~ hex_value
    base_color = $1.hex << 8
    opacity  ||= $2 ? $2.hex : 0xff
    base_color | opacity
  else 
    raise ArgumentError, "Not a valid hex color notation: #{hex_value.inspect}!"
  end
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 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 int8_mult(a, b)
  t = a * b + 0x80
  ((t >> 8) + t) >> 8
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 ChunkyPNG::Color::HEX_COLOR_REGEXP;  ChunkyPNG::Color.from_hex(source.to_s)
    when ChunkyPNG::Color::HTML_COLOR_REGEXP; ChunkyPNG::Color.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 numer 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_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_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