package game

import (
	"log"
	"math/rand"
)

func NewRandomChallenge(name string) *LocalState {
	s := NewLocalState()
	maps := []string{"2P-ring-street", "2P-river-king"}
	if m, err := GetMap(maps[rand.Intn(len(maps))]); err != nil {
		log.Panic(err)
	} else {
		s.SetMap(m)
	}

	// Prepare the players
	s.AddNewPlayer(name, NewDeck())
	// Add Opponent
	ai := s.AddNewPlayer("opponent", NewDeck())
	ai.Ctrl = NewSimpleAiControl(ai)

	switch rand.Intn(2) {
	// Cavalry Archer Challenge
	case 0:
		return prepCavArcherChallenge(s)
	// Random Base Challenge
	default:
		return prepBaseChallenge(s)
	}
}

func prepCavArcherChallenge(s *LocalState) *LocalState {
	// Override old Prepare to prevent Kings from beeing spawned
	s._map.Prepare = func(*LocalState) {
		u := NewCard("base/cavalry_archer")
		tiles := s._map.AvailableTilesFor(u)
		tile := tiles[rand.Intn(len(tiles))]
		p := s.PlayerById(1)
		p.Deck = NewDeck()
		s.addNewUnit(u, tile.Position, p)

		// Prepare the opponent's units
		nUnits := rand.Intn(2) + 4
		units := make([]*Card, 0, nUnits)
		// Only use Melee Units
		candidates := NewDeckFromCardPaths(Sets.Base.CardPaths()).FilterCards(func(c *Card) bool {
			if c.Type != CardTypes.Unit {
				return false
			}

			// Disallow armor since the cavalry archer can not penetrate it.
			if _, err := c.getXEffect("armor"); err == nil {
				return false
			}

			var attack Attack
			if attackDesc, found := c.Values["attack"]; found {
				attack = parseAttack(attackDesc)
				return attack.MaxRange() == 1
			}
			return false
		})

		for range nUnits {
			units = append(units, NewCard(candidates[rand.Intn(len(candidates))].Path()))
		}

		for _, u := range units {
			tiles := s._map.AvailableTilesFor(u)
			tile := tiles[rand.Intn(len(tiles))]
			ai := s.PlayerById(2)
			s.addNewUnit(u, tile.Position, ai)
		}

		s._map.WinCondition = func(*LocalState) []*Player {
			winners := []*Player{}
			for _, p := range s.players {
				if len(s.EnemyUnits(p)) == 0 {
					winners = append(winners, p)
				}
			}
			return winners
		}
	}

	return s
}

func prepBaseChallenge(s *LocalState) *LocalState {
	p := s.PlayerById(1)
	nCards := rand.Intn(6)
	nCards = nCards + 3
	d := NewRandomDeck(nCards, []SetIdentifier{Sets.Base, Sets.Magic, Sets.Equipments})
	p.Store.AddCards(d.FilterCards(func(c *Card) bool { return c.IsBuyable() }))

	ai := s.PlayerById(2)
	ai.Deck = NewRandomDeck(nCards, []SetIdentifier{Sets.Base})

	return s
}