package engine

import (
	"sakura/engine/pool"
)

type Turn struct {
	Player *Player
	ActionTaken bool
	Actions []Action
}

type Game struct {
	Shadow   *pool.Pool
	Distance *pool.Pool
	Yin      *Player
	Yang     *Player

	Stack []IsCard

	Actions []Action

	CurrentPlayer *Player

	History []Turn
}

func (g *Game) propagate() {
	g.Distance.OverflowsTo = g.Shadow
}

func NewGame() *Game {
	g := &Game{
		Shadow:   pool.New(0, pool.Infinite),
		Distance: pool.New(10, 10),
	}
	g.Yin = NewPlayer(g)
	g.Yang = NewPlayer(g)
	g.propagate()
	g.NextTurn()
	return g
}

var Tie = &Player{}

func (g *Game) Winner() *Player {
	if g.Yin.Life.Value <= 0 && g.Yang.Life.Value <= 0 {
		return Tie
	}
	if g.Yin.Life.Value <= 0 {
		return g.Yang
	}
	if g.Yang.Life.Value <= 0 {
		return g.Yin
	}
	return nil
}

func (g *Game) NextTurn() {
	current := g.CurrentPlayer.Opponent(g)
	g.CurrentPlayer = current
	g.History = append(g.History, Turn{
		Player: current,
		ActionTaken: false,
	})
	g.Actions = Interactions(ShuffleDeckAction(g),DrawCardAction(g)),
}

func (g *Game) CurrentTurn() Turn {
	return g.History[len(g.History) - 1]
}

func (g *Game) ActionToHistory(a Action) {
	thisTurn := g.History[len(g.History)-1]
	thisTurn.Actions = append(thisTurn.Actions, a)
}