package game

import (
	"log"
	"strings"
	"testing"

	"muhq.space/muhqs-game/go/utils"
)

func TestPioneerFullAction(t *testing.T) {
	mapDef := `map: |1-
 HST
 H H
  FW
symbols:
  T: tower
  H: house
  F: farm
  S: street
  W: deep water
`
	s := NewLocalState()

	m, _ := readMap(strings.NewReader(mapDef))
	s.SetMap(m)

	player := s.AddNewPlayer("p", NewDeck())

	p := s.addNewUnit(NewCard("base/pioneer"), Position{1, 1}, player)
	sword := s.addNewEquipment(NewCard("base/sword"), Position{0, 1}, player)
	palisade := s.addNewArtifact(NewCard("base/palisade"), Position{0, 0}, player)

	a := p.FullActions[0]
	opts := a.Target().Options()
	if len(opts) != 11 {
		log.Printf("%q\n", opts)
		t.Fatal("expexted 11 targets to neutralize")
	}

	if !utils.InterfaceSliceContains(opts, sword) {
		t.Fatal("sword is missing")
	}

	if !utils.InterfaceSliceContains(opts, palisade) {
		t.Fatal("palisade is missing")
	}

	_ = a.Target().AddSelection(m.TileAt(Position{0, 1}))
	s.ResolveAction(a)
	if m.TileAt(Position{0, 1}).Type != TileTypes.Neutral {
		t.Fatal("tile not neutralized")
	}

	a = p.FullActions[0]
	if len(a.Target().Selection()) != 0 {
		t.Fatal("full action still has target selection")
	}

	_ = a.Target().AddSelection(palisade)
	s.ResolveAction(a)
	if m.TileAt(Position{0, 0}).Permanent != nil {
		t.Fatal("palisade not destroyed")
	}
}

func TestPikemanRange(t *testing.T) {
	mapDef := `map: |1-
 SSS
 SSS
 SHS
symbols:
  S: street
  H: house
`
	s := NewLocalState()

	m, _ := readMap(strings.NewReader(mapDef))
	s.SetMap(m)

	player := s.AddNewPlayer("p", NewDeck())
	opo := s.AddNewPlayer("o", NewDeck())

	p := s.addNewUnit(NewCard("base/pikeman"), Position{0, 0}, player)
	c := s.addNewUnit(NewCard("base/cavalry"), Position{0, 2}, opo)
	prot := s.addNewUnit(NewCard("base/cavalry_archer"), Position{1, 2}, opo)
	ca := s.addNewUnit(NewCard("base/cavalry_archer"), Position{2, 1}, opo)
	k := s.addNewUnit(NewCard("base/knight"), Position{2, 0}, opo)

	attackable := utils.TypedSliceToInterfaceSlice(p.AttackableEnemyPermanents())
	if !utils.InterfaceSliceContains(attackable, c) {
		t.Fatal("cavalry not attackable")
	}
	if !utils.InterfaceSliceContains(attackable, ca) {
		t.Fatal("cavalry archer not attackable")
	}
	if utils.InterfaceSliceContains(attackable, k) {
		t.Fatal("knight is attackable")
	}
	if utils.InterfaceSliceContains(attackable, prot) {
		t.Fatal("cavalry is protected")
	}

	a := NewAttackAction(p)
	err := a.Target().AddSelection(c)
	if err != nil {
		t.Fatal("invalid target:", err)
	}

	s.ResolveAction(a)
	if !c.IsDestroyed() {
		t.Fatal("cavalry not destroyed")
	}

	a.Target().ClearSelection()
	err = a.Target().AddSelection(ca)
	if err != nil {
		t.Fatal("invalid target:", err)
	}
	s.ResolveAction(a)
	if !c.IsDestroyed() {
		t.Fatal("cavalry archer not destroyed")
	}
	if p.Damage() != 1 {
		t.Fatal("pikeman not damaged")
	}

	a.Target().ClearSelection()
	err = a.Target().AddSelection(k)
	if err == nil {
		t.Fatal("unexpected valid target")
	}
}