package game

import (
	"reflect"
	"slices"
	"strings"
	"testing"
)

func parseMapString(t *testing.T, mapDef string) *Map {
	r := strings.NewReader(mapDef)
	m, err := readMap(r)
	if err != nil {
		t.Fatalf("Parsing failed with: %v", err)
	}
	return m
}

func newEmpty2x2Map() *Map {
	mapDef := `map: |+1
 __
 __

symbols:
  _: neutral
`
	m, _ := readMap(strings.NewReader(mapDef))

	return m
}

func TestParseMapEndingStreets(t *testing.T) {
	mapDef := `map: |+1
 HST
 HSF
 TST

symbols:
  T: tower
  H: house
  F: farm
  S: street
`

	parseMapString(t, mapDef)
}

func TestParseMap(t *testing.T) {
	s := `map: |+1
 T  H   HT
  FSSSSS2H
  SHSH HS 
  S SST S 
 H  HFH  H
  S TSS S 
  SH HSHS 
 H1SSSSSF 
 TH   H  T

symbols:
  T: tower
  H: house
  F: farm
  S: street
  1: spawn player 1
  2: spawn player 2

kings:
  - [1,9]
  - [9,1]`

	m := parseMapString(t, s)

	if m.Tiles[0][0].Type != TileTypes.Tower {
		t.Fatalf("Unexpected tile at 0,0: %v (expected %v)", m.Tiles[0][0], TileTypes.Tower)
	}

	for y := 0; y < len(m.Tiles); y++ {
		for x := 0; x < len(m.Tiles[y]); x++ {
			if m.TileAt(Position{x, y}) != &m.Tiles[y][x] {
				t.Fatalf("TileAt and Tiles differ")
			}
		}
	}

	if m.ResourceGain != DEFAULT_RESOURCE_GAIN {
		t.Fatalf("resource gain is not the default one")
	}

	if reflect.ValueOf(m.WinCondition).Pointer() != reflect.ValueOf(KingGame).Pointer() {
		t.Fatalf("win conditions is not KingGame")
	}
}

func TestLoadingAllMaps(t *testing.T) {
	maps := []string{"the-tyrant", "2P-ring-street", "2P-river-king", "3P-ring-street", "4P-islands", "the-kraken"}

	for _, m := range maps {
		_, err := LoadMap("../../maps/" + m + ".yml")
		if err != nil {
			t.Fatalf("Loading map %s failed with %s", m, err)
		}
	}
}

func TestTileAt(t *testing.T) {
	mapDef := `map: |+1
 HS
 HS

symbols:
  H: house
  S: street
`

	m := parseMapString(t, mapDef)
	if m.TileAt(INVALID_POSITION()) != nil {
		t.Fatal("INVALID_POSITION returned valid rile")
	}
	if m.TileAt(Position{3, 0}) != nil {
		t.Fatal("INVALID_POSITION returned valid rile")
	}
	if m.TileAt(Position{0, 3}) != nil {
		t.Fatal("INVALID_POSITION returned valid rile")
	}
	if m.TileAt(Position{0, 0}).Type != TileTypes.House {
		t.Fatal("Tile at (0,0) is not a house")
	}
}

func TestMovementRangeTiles(t *testing.T) {
	mapDef := `map: |+1
 T  H   HT
  FSSSSS2H
  SHSH HS 
  S SST S 
 H  HFH  H
  S TSS S 
  SH HSHS 
 H1SSSSSF 
 TH   H  T

symbols:
  T: tower
  H: house
  F: farm
  S: street
  1: spawn player 1
  2: spawn player 2
`

	s := NewLocalState()
	m := parseMapString(t, mapDef)
	s.SetMap(m)
	p := s.AddNewPlayer("p", NewDeck())
	o := Position{2, 2}
	a := s.addNewUnit(NewCard("base/archer"), o, p)

	tiles := a.MoveRangeTiles()
	exp := TilesInRange(m, a, a.Movement.Range)

	if len(tiles) != len(exp) {
		t.Fatal("expected", len(exp), "tiles not", len(tiles))
	}

	for _, tile := range exp {
		if !slices.Contains(tiles, tile) {
			t.Fatal("missing", tile, "in tiles")
		}
	}
}