class SuperDiff::Csi::EightBitColor

# File lib/super_diff/csi/eight_bit_color.rb, line 44
def initialize(
  value = nil,
  layer: nil,
  red: nil,
  green: nil,
  blue: nil,
  type: nil,
  index: nil
)
  if value
    case value
    when Symbol
      @code = interpret_color_name!(value)
      @layer = interpret_layer!(layer)
    when Array
      @code = interpret_pair!(type: type, index: index)
      @layer = interpret_layer!(layer)
    else
      if value.is_a?(String) && value.start_with?("\e[")
        pair = interpret_sequence!(value)
        @code = pair.fetch(:code)
        @layer = pair.fetch(:layer)
      else
        @code = interpret_code!(value)
        @layer = interpret_layer!(layer)
      end
    end
  else
    @code = interpret_triplet!(red: red, green: green, blue: blue)
    @layer = interpret_layer!(layer)
  end
end

# File lib/super_diff/csi/eight_bit_color.rb, line 40
def self.opening_regex
  OPENING_REGEX
end

# File lib/super_diff/csi/eight_bit_color.rb, line 81
def to_foreground
  self.class.new(code, layer: :foreground)
end

# File lib/super_diff/csi/eight_bit_color.rb, line 77
def to_s
  "\e[#{leading_code};#{SERIAL_CODE};#{code}m"
end

# File lib/super_diff/csi/eight_bit_color.rb, line 165
def interpret_code!(code)
  if !VALID_CODE_RANGE.cover?(code)
    raise ArgumentError.new(
      "#{code.inspect} is not a valid color code " +
      "(must be between 0 and 255).",
    )
  end

  code
end

# File lib/super_diff/csi/eight_bit_color.rb, line 109
def interpret_color_name!(name)
  if !VALID_CODES_BY_NAME.include?(name)
    message =
      "#{name.inspect} is not a valid color name.\n" +
      "Valid names are:\n"

    VALID_CODES_BY_NAME.keys.each do |valid_name|
      message << "- #{valid_name}\n"
    end

    raise ArgumentError.new(message)
  end

  VALID_CODES_BY_NAME[name]
end

# File lib/super_diff/csi/eight_bit_color.rb, line 157
def interpret_layer!(value)
  if value.to_s.to_i > 0
    LAYERS_BY_LEADING_CODE.fetch(value.to_s.to_i)
  else
    super
  end
end

# File lib/super_diff/csi/eight_bit_color.rb, line 125
def interpret_pair!(type:, index:)
  if !VALID_PAIR_TYPES.include?(type)
    raise ArgumentError.new(
      "Given pair did not have a valid type. " +
      "Type must be one of: #{VALID_PAIR_TYPES}",
    )
  end

  valid_range = VALID_PAIR_INDEX_RANGES[type]

  if !valid_range.cover?(index)
    raise ArgumentError.new(
      "Given pair did not have a valid index. " +
      "For #{type}, index must be between #{valid_range.begin} and " +
      "#{valid_range.end}.",
    )
  end

  STARTING_INDICES[type] + index
end

# File lib/super_diff/csi/eight_bit_color.rb, line 146
def interpret_sequence!(sequence)
  match = sequence.match(OPENING_REGEX)

  if match
    {
      layer: interpret_layer!(match[1]),
      code: interpret_code!(match[2].to_i),
    }
  end
end

# File lib/super_diff/csi/eight_bit_color.rb, line 93
def interpret_triplet!(red:, green:, blue:)
  if invalid_triplet?(red, green, blue)
    raise ArgumentError.new(
      "(#{red},#{green},#{blue}) is not a valid color " +
      "specification. All components must be between " +
      "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}.",
    )
  end

  16 + 36 * red + 6 * green + blue
end

# File lib/super_diff/csi/eight_bit_color.rb, line 105
def invalid_triplet?(*values)
  values.none? { |component| VALID_COMPONENT_RANGE.cover?(component) }
end

# File lib/super_diff/csi/eight_bit_color.rb, line 89
def leading_code
  LEADING_CODES_BY_LAYER.fetch(layer)
end