# In your Gemfile
gem "sashite-pan"

require "sashite/pan"

# Validate PAN strings
Sashite::Pan.valid?("e2-e4")      # => true
Sashite::Pan.valid?("d1+f3")      # => true
Sashite::Pan.valid?("...")        # => true
Sashite::Pan.valid?("invalid")    # => false

# Parse PAN strings into action objects
action = Sashite::Pan.parse("e2-e4")
action.type          # => :move
action.source        # => "e2"
action.destination   # => "e4"
action.to_s          # => "e2-e4"

# Create actions programmatically
action = Sashite::Pan::Action.move("e2", "e4")
action.to_s          # => "e2-e4"

promotion = Sashite::Pan::Action.move("e7", "e8", transformation: "Q")
promotion.to_s       # => "e7-e8=Q"

capture = Sashite::Pan::Action.capture("d1", "f3")
capture.to_s         # => "d1+f3"

# Drop actions (shogi-style)
drop = Sashite::Pan::Action.drop("e5", piece: "P")
drop.to_s            # => "P*e5"

# Pass action
pass = Sashite::Pan::Action.pass
pass.to_s            # => "..."

# Query action properties
action.move?         # => true
action.pass?         # => false
capture.capture?     # => true

Sashite::Pan.valid?(pan_string)

Sashite::Pan.valid?("e2-e4")       # => true
Sashite::Pan.valid?("P*d4")        # => true
Sashite::Pan.valid?("...")         # => true
Sashite::Pan.valid?("invalid")     # => false

Sashite::Pan.parse(pan_string)

Sashite::Pan.parse("e2-e4")        # => #<Pan::Action type=:move ...>
Sashite::Pan.parse("d1+f3")        # => #<Pan::Action type=:capture ...>
Sashite::Pan.parse("...")          # => #<Pan::Action type=:pass>

Sashite::Pan::Action.pass

action = Sashite::Pan::Action.pass
action.to_s  # => "..."

Sashite::Pan::Action.move(source, destination, transformation: nil)

Sashite::Pan::Action.move("e2", "e4")
# => "e2-e4"

Sashite::Pan::Action.move("e7", "e8", transformation: "Q")
# => "e7-e8=Q"

Sashite::Pan::Action.move("a7", "a8", transformation: "+R")
# => "a7-a8=+R"

Sashite::Pan::Action.capture(source, destination, transformation: nil)

Sashite::Pan::Action.capture("d1", "f3")
# => "d1+f3"

Sashite::Pan::Action.capture("b7", "a8", transformation: "R")
# => "b7+a8=R"

Sashite::Pan::Action.special(source, destination, transformation: nil)

Sashite::Pan::Action.special("e1", "g1")
# => "e1~g1" (castling)

Sashite::Pan::Action.special("e5", "f6")
# => "e5~f6" (en passant)

Sashite::Pan::Action.static_capture(square)

Sashite::Pan::Action.static_capture("d4")
# => "+d4"

Sashite::Pan::Action.drop(destination, piece: nil, transformation: nil)

Sashite::Pan::Action.drop("e5", piece: "P")
# => "P*e5"

Sashite::Pan::Action.drop("d4")
# => "*d4" (piece type inferred from context)

Sashite::Pan::Action.drop("c3", piece: "S", transformation: "+S")
# => "S*c3=+S"

Sashite::Pan::Action.drop_capture(destination, piece: nil, transformation: nil)

Sashite::Pan::Action.drop_capture("b4", piece: "L")
# => "L.b4"

Sashite::Pan::Action.modify(square, piece)

Sashite::Pan::Action.modify("e4", "+P")
# => "e4=+P"

Sashite::Pan::Action.modify("c3", "k'")
# => "c3=k'"

action.type

action.source

action.destination

action.piece

action.transformation

action.to_s

Sashite::Pan::Action.move("e2", "e4").to_s
# => "e2-e4"

Sashite::Pan::Action.drop("e5", piece: "P").to_s
# => "P*e5"

action.pass?
action.move?
action.capture?
action.special?
action.static_capture?
action.drop?
action.drop_capture?
action.modify?
action.movement?        # true for move, capture, or special
action.drop_action?     # true for drop or drop_capture

action = Sashite::Pan.parse("e2-e4")
action.move?       # => true
action.movement?   # => true
action.pass?       # => false

pass = Sashite::Pan::Action.pass
pass.pass?         # => true

drop = Sashite::Pan.parse("P*e5")
drop.drop?         # => true
drop.drop_action?  # => true

action == other

action1 = Sashite::Pan.parse("e2-e4")
action2 = Sashite::Pan::Action.move("e2", "e4")
action1 == action2  # => true

# Parse a sequence of moves
moves = %w[e2-e4 e7-e5 g1-f3 b8-c6]
actions = moves.map { |move| Sashite::Pan.parse(move) }

# Analyze action types
actions.count(&:move?)     # => 4
actions.all?(&:movement?)  # => true

# Extract coordinates
sources = actions.map(&:source)
destinations = actions.map(&:destination)

def describe_action(pan_string)
  action = Sashite::Pan.parse(pan_string)

  case action.type
  when :pass
    "Player passes"
  when :move
    "Move from #{action.source} to #{action.destination}"
  when :capture
    "Capture at #{action.destination}"
  when :special
    "Special move: #{action.source} to #{action.destination}"
  when :drop
    piece_str = action.piece ? "#{action.piece} " : ""
    "Drop #{piece_str}at #{action.destination}"
  when :modify
    "Transform piece at #{action.square} to #{action.piece}"
  end
end

describe_action("e2-e4")   # => "Move from e2 to e4"
describe_action("d1+f3")   # => "Capture at f3"
describe_action("P*e5")    # => "Drop P at e5"
describe_action("...")     # => "Player passes"

def has_promotion?(pan_string)
  action = Sashite::Pan.parse(pan_string)
  !action.transformation.nil?
end

has_promotion?("e2-e4")      # => false
has_promotion?("e7-e8=Q")    # => true
has_promotion?("P*e5")       # => false
has_promotion?("S*c3=+S")    # => true

class MoveBuilder
  def initialize(source)
    @source = source
  end

  def to(destination)
    Sashite::Pan::Action.move(@source, destination)
  end

  def captures(destination)
    Sashite::Pan::Action.capture(@source, destination)
  end

  def to_promoting(destination, piece)
    Sashite::Pan::Action.move(@source, destination, transformation: piece)
  end
end

# Usage
builder = MoveBuilder.new("e7")
builder.to("e8").to_s                    # => "e7-e8"
builder.to_promoting("e8", "Q").to_s     # => "e7-e8=Q"
builder.captures("d8").to_s              # => "e7+d8"

def safe_parse(pan_string)
  return nil unless Sashite::Pan.valid?(pan_string)

  Sashite::Pan.parse(pan_string)
rescue ArgumentError
  nil
end

safe_parse("e2-e4")      # => #<Pan::Action ...>
safe_parse("invalid")    # => nil

def analyze(action)
  case action
  in { type: :move, source:, destination:, transformation: nil }
    "Simple move: #{source} → #{destination}"
  in { type: :move, transformation: piece }
    "Promotion to #{piece}"
  in { type: :capture, source:, destination: }
    "Capture: #{source} takes #{destination}"
  in { type: :drop, piece:, destination: }
    "Drop #{piece} at #{destination}"
  in { type: :pass }
    "Pass"
  else
    "Other action"
  end
end

action = Sashite::Pan.parse("e7-e8=Q")
analyze(action)  # => "Promotion to Q"