class ChunkyPNG::Palette

def self.from_canvas(canvas)
  # Although we don't need to call .uniq.sort before initializing, because
  # Palette subclasses SortedSet, we get significantly better performance
  # by doing so.
  new(canvas.pixels.uniq.sort)
end

def self.from_chunks(palette_chunk, transparency_chunk = nil)
  return nil if palette_chunk.nil?
  decoding_map = []
  index = 0
  palatte_bytes = palette_chunk.content.unpack("C*")
  alpha_channel = transparency_chunk ? transparency_chunk.content.unpack("C*") : []
  index = 0
  palatte_bytes.each_slice(3) do |bytes|
    bytes << alpha_channel.fetch(index, ChunkyPNG::Color::MAX)
    decoding_map << ChunkyPNG::Color.rgba(*bytes)
    index += 1
  end
  new(decoding_map, decoding_map)
end

def self.from_pixels(pixels)
  new(pixels)
end

def [](index)
  @decoding_map[index]
end

def best_color_settings
  if black_and_white?
    [ChunkyPNG::COLOR_GRAYSCALE, 1]
  elsif grayscale?
    if opaque?
      [ChunkyPNG::COLOR_GRAYSCALE, 8]
    else
      [ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8]
    end
  elsif indexable?
    [ChunkyPNG::COLOR_INDEXED, determine_bit_depth]
  elsif opaque?
    [ChunkyPNG::COLOR_TRUECOLOR, 8]
  else
    [ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8]
  end
end

def black_and_white?
  entries == [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
end

def can_decode?
  !@decoding_map.nil?
end

def can_encode?
  !@encoding_map.empty?
end

def determine_bit_depth
  case size
  when 1..2 then 1
  when 3..4 then 2
  when 5..16 then 4
  when 17..256 then 8
  end
end

def grayscale?
  all? { |color| Color.grayscale?(color) }
end

def index(color)
  color.nil? ? 0 : @encoding_map[color]
end

def indexable?
  size <= 256
end

def initialize(enum, decoding_map = nil)
  super(enum.sort.freeze)
  @decoding_map = decoding_map if decoding_map
  @encoding_map = {}
  freeze
end

def opaque?
  all? { |color| Color.opaque?(color) }
end

def opaque_palette
  self.class.new(map { |c| ChunkyPNG::Color.opaque!(c) })
end

def to_plte_chunk
  @encoding_map.clear
  colors = []
  each_with_index do |color, index|
    @encoding_map[color] = index
    colors += ChunkyPNG::Color.to_truecolor_bytes(color)
  end
  ChunkyPNG::Chunk::Palette.new("PLTE", colors.pack("C*"))
end

def to_trns_chunk
  ChunkyPNG::Chunk::Transparency.new("tRNS", map { |c| ChunkyPNG::Color.a(c) }.pack("C*"))
end