package game

import (
	"strings"
	"testing"
)

func TestGenerateGraph(t *testing.T) {
	mapDef := `map: |1-
 HST
 HSF
 TST
symbols:
  T: tower
  H: house
  F: farm
  S: street
`
	r := strings.NewReader(mapDef)
	m, _ := readMap(r)
	a := NewUnit(NewCard("base/archer"), m.TileAt(Position{0, 0}), nil)
	f := NewUnit(NewCard("misc/farmer"), m.TileAt(Position{2, 2}), nil)

	graph := m.generateMapGraphFor(a)
	p, err := findPathTo(graph, a, Position{1, 1})
	if err != nil {
		t.Fatal(err)
	}

	if p.Distance != 3 {
		t.Fatalf("Wrong distance %d", p.Distance)
	}

	paths := findPathsToUnits(graph, m, a, []*Unit{f})
	if len(paths) == 0 || paths[0] == nil {
		t.Fatal("No path found")
	}

	if paths[0].Distance != 3 {
		t.Fatalf("Wrong distance %d", p.Distance)
	}
}

func TestAngrySquidDiagonal(t *testing.T) {
	mapDef := `map: |1-
 WWWWWWW
 W     W
 WW   WW
 WWWWWWW
 WWWWWWW
 W     W
symbols:
  W: deep water
`
	r := strings.NewReader(mapDef)
	m, err := readMap(r)
	if m == nil || err != nil {
		t.Fatal("failed to parse map", m, err)
	}
	s := NewUnit(NewCard("kraken/angry_squid"), m.TileAt(Position{5, 0}), nil)
	f := NewUnit(NewCard("misc/farmer"), m.TileAt(Position{6, 5}), nil)

	graph := m.generateMapGraphFor(s)

	paths := findPathsToUnits(graph, m, s, []*Unit{f})
	if len(paths) == 0 || paths[0] == nil {
		t.Fatal("No path found")
	}
}

func TestClowFish(t *testing.T) {
	mapDef := `map: |1-
 WWWWW
 WWWWW
 WWWWW
 WWWWW
 WWWWW
symbols:
  W: deep water
`
	r := strings.NewReader(mapDef)
	m, _ := readMap(r)
	s := NewLocalState()
	s.SetMap(m)
	p1 := s.AddNewPlayer("kraken", NewDeck(), nil)
	p2 := s.AddNewPlayer("player", NewDeck(), nil)
	c := s.addNewUnit(NewCard("kraken/clownfish"), Position{2, 2}, p1)
	s.addNewUnit(NewCard("kraken/sailfish"), Position{1, 1}, p2)
	s.addNewUnit(NewCard("kraken/sailfish"), Position{3, 2}, p2)

	ai := NewUnitAI(s, c)
	if ai == nil {
		t.Fatal("No AI available for Bauernfeind")
	}

	ai.promptAction()
	a := <-ai.actions
	if a == nil {
		t.Fatal("No action reported")
	}

	var ma *MoveAction
	var ok bool
	if ma, ok = a.(*MoveAction); !ok {
		t.Fatal("AI did not move flee from enemies")
	}

	if tile, ok := ma.targets.Cur().sel[0].(*Tile); ok {
		if tile != m.TileAt(Position{1, 4}) {
			t.Fatalf("Unexpected clownfish move: expected tile(1,4), got: %s", tile)
		}
	} else {
		t.Fatal("Target is not a Tile")
	}
	ma.resolve(s)

	ai = NewUnitAI(s, c)
	ai.promptAction()
	a = <-ai.actions
	if a == nil {
		t.Fatal("No action reported")
	}
	if _, ok := a.(*FullAction); !ok {
		t.Fatal("Unthreatend AI did not use a full action")
	}
}

func TestBauernFeind(t *testing.T) {
	mapDef := `map: |1-
 WWW 
 W   
 WWW 
    
symbols:
  W: wall
`
	r := strings.NewReader(mapDef)
	m, _ := readMap(r)
	s := NewLocalState()
	s.SetMap(m)
	p1 := s.AddNewPlayer("tyrant", NewDeck(), nil)
	p2 := s.AddNewPlayer("player", NewDeck(), nil)
	b := s.addNewUnit(NewCard("tyrant/bauernfeind"), Position{1, 1}, p1)
	s.addNewUnit(NewCard("misc/farmer"), Position{1, 3}, p2)

	bAi := NewUnitAI(s, b)
	if bAi == nil {
		t.Fatal("No AI available for Bauernfeind")
	}

	bAi.promptAction()
	a := <-bAi.actions
	if a == nil {
		t.Fatal("No action reported")
	}

	var ma *MoveAction
	var ok bool
	if ma, ok = a.(*MoveAction); !ok {
		t.Fatal("AI not moving towards target")
	}

	if tile, ok := ma.targets.Cur().sel[0].(*Tile); ok {
		if tile != m.TileAt(Position{3, 2}) {
			t.Fatalf("Unexpected Bauernfeind move: expected tile(3,2), got: %s", tile)
		}
	} else {
		t.Fatal("Target is not a Tile")
	}
}