class Sashite::Snn::Style

def self.parse(snn_string)
  string_value = String(snn_string)
  validate_snn_string(string_value)
  # Determine side from case
  style_side = string_value == string_value.upcase ? FIRST_PLAYER : SECOND_PLAYER
  # Use the letter directly as symbol
  style_letter = string_value.to_sym
  new(style_letter, style_side)
end

def self.valid?(snn_string)
  return false unless snn_string.is_a?(::String)
  snn_string.match?(SNN_PATTERN)
end

def self.valid_letter?(letter)
  return false unless letter.is_a?(::Symbol)
  letter_string = letter.to_s
  return false if letter_string.empty?
  # Must be exactly one ASCII letter
  letter_string.match?(SNN_PATTERN)
end

def self.validate_letter(letter)
  return if valid_letter?(letter)
  raise ::ArgumentError, format(ERROR_INVALID_LETTER, letter.inspect)
end

def self.validate_side(side)
  return if VALID_SIDES.include?(side)
  raise ::ArgumentError, format(ERROR_INVALID_SIDE, side.inspect)
end

def self.validate_snn_string(string)
  return if string.match?(SNN_PATTERN)
  raise ::ArgumentError, format(ERROR_INVALID_SNN, string)
end

def ==(other)
  return false unless other.is_a?(self.class)
  letter == other.letter && side == other.side
end

def first_player?
  side == FIRST_PLAYER
end

def flip
  new_letter = first_player? ? letter.to_s.downcase.to_sym : letter.to_s.upcase.to_sym
  self.class.new(new_letter, opposite_side)
end

def hash
  [self.class, letter, side].hash
end

def initialize(letter, side)
  self.class.validate_letter(letter)
  self.class.validate_side(side)
  @letter = letter
  @side = side
  freeze
end

def opposite_side
  first_player? ? SECOND_PLAYER : FIRST_PLAYER
end

def same_letter?(other)
  return false unless other.is_a?(self.class)
  letter.to_s.upcase == other.letter.to_s.upcase
end

def same_side?(other)
  return false unless other.is_a?(self.class)
  side == other.side
end

def second_player?
  side == SECOND_PLAYER
end

def to_s
  letter.to_s
end

def with_letter(new_letter)
  self.class.validate_letter(new_letter)
  return self if letter == new_letter
  # Ensure the new letter has the correct case for the current side
  adjusted_letter = first_player? ? new_letter.to_s.upcase.to_sym : new_letter.to_s.downcase.to_sym
  self.class.new(adjusted_letter, side)
end

def with_side(new_side)
  self.class.validate_side(new_side)
  return self if side == new_side
  # Adjust letter case for the new side
  new_letter = new_side == FIRST_PLAYER ? letter.to_s.upcase.to_sym : letter.to_s.downcase.to_sym
  self.class.new(new_letter, new_side)
end