package entity

import (
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/errors"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/shared"
	"mongo.games.com/game/gamesrv/slotspkg/slots/formation"
)

// IsFinished returns if node progress is finished
func (e *Entity) IsFinished(node *shared.Node) bool {
	return node.ProgressMax == node.ProgressValue
}

// Progress add 1 progress to `Cursor` Node and updates features' lifetime
func (e *Entity) Progress() {
	node := e.CursorNode()
	if node.NeedPrepare && !node.Prepared {
		node.Prepared = true
	} else if node.ProgressValue < node.ProgressMax {
		node.ProgressValue++
		e.FeaturesPassTime(e.CursorNode(), 1)
	}
}

func (e *Entity) SkipBaseSpin(nodeID int64) {
	skipNode := e.GetNode(nodeID)
	if skipNode.GetType() != key.BaseSpin {
		return
	}

	e.RootNode().ChildrenTotalWin = 0
	e.RootNode().ChildrenWin = 0

	node := e.CursorNode()
	for node.GetType() != key.BaseSpin {
		node = e.GetNode(node.GetParent())
	}

	skipNode.SingleBet = node.SingleBet
	skipNode.Bet = node.Bet
	skipNode.BaseBet = node.BaseBet
	skipNode.ProgressValue = node.ProgressValue
	skipNode.ProgressMax = node.ProgressMax
}

func (e *Entity) SkipBaseSpinWithBet(nodeID int64) {
	skipNode := e.GetNode(nodeID)
	if skipNode.GetType() != key.BaseSpin {
		return
	}

	e.RootNode().ChildrenTotalWin = 0
	e.RootNode().ChildrenWin = 0

	node := e.CursorNode()

	bet := e.ActBet()

	if node.GetType() == key.Root {
		var lineCount int64
		for _, desc := range e.NextNodeDesc.FormationSeqsDesc {
			formation, err := formation.NewFormation(e.NextNodeDesc, desc.SeqID)
			if err != nil {
				panic(err)
			}
			lineCount += formation.FormationDesc.MatrixDesc.LineCount
		}

		skipNode.SingleBet = bet / lineCount
		skipNode.Bet = bet
		skipNode.BaseBet = bet
		skipNode.ProgressValue = 1
		skipNode.ProgressMax = 1

		return
	}

	for node.GetType() != key.BaseSpin {
		node = e.GetNode(node.GetParent())
	}

	lineCount := node.Bet / node.SingleBet

	skipNode.SingleBet = bet / lineCount
	skipNode.Bet = bet
	skipNode.BaseBet = bet
	skipNode.ProgressValue = node.ProgressValue
	skipNode.ProgressMax = node.ProgressMax
}

// Accomplish instantly finishes a node and updates features' lifetime
func (e *Entity) Accomplish() {
	node := e.CursorNode()
	node.ProgressValue = node.ProgressMax

	e.FeaturesPassTime(e.CursorNode(), node.ProgressMax)
}

// AccomplishNext instantly finishes next node and updates features' lifetime
func (e *Entity) AccomplishNext() {
	node := e.NextNode()
	node.ProgressValue = node.ProgressMax

	e.FeaturesPassTime(e.NextNode(), node.ProgressMax)
}

// AccomplishParent instantly finishes parent node and updates features' lifetime
func (e *Entity) AccomplishParent() {
	node := e.ParentNode()
	node.ProgressValue = node.ProgressMax

	e.FeaturesPassTime(e.ParentNode(), node.ProgressMax)
}

// AddProgress adds progress max to a node
func (e *Entity) AddProgress(n int64) {
	node := e.CursorNode()
	node.ProgressMax += n
}

// AddNextProgress adds progress max to next node
func (e *Entity) AddNextProgress(n int64) {
	node := e.NextNode()
	node.ProgressMax += n
}

// AddParentProgress adds progress max to parent node
func (e *Entity) AddParentProgress(n int64) {
	node := e.ParentNode()
	node.ProgressMax += n
}

// ProgressLeft gets left progress
func (e *Entity) ProgressLeft() int64 {
	node := e.CursorNode()
	return node.ProgressMax - node.ProgressValue
}

// NextProgressLeft gets left progress of next node
func (e *Entity) NextProgressLeft() int64 {
	node := e.NextNode()
	return node.ProgressMax - node.ProgressValue
}

// ParentProgressLeft gets left progress of parent node
func (e *Entity) ParentProgressLeft() int64 {
	node := e.ParentNode()
	return node.ProgressMax - node.ProgressValue
}

// SetProgressLeft set left progress as specific value
func (e *Entity) SetProgressLeft(left int64) {
	node := e.CursorNode()
	if left > node.ProgressMax {
		panic(errors.With(left, node.ProgressMax).Errorf(
			"left progress can't be more than progress max"))
	}
	node.ProgressValue = node.ProgressMax - left
}

// SetNextProgressLeft set left progress of next node as specific value
func (e *Entity) SetNextProgressLeft(left int64) {
	node := e.NextNode()
	if left > node.ProgressMax {
		panic(errors.With(left, node.ProgressMax).Errorf(
			"left progress can't be more than progress max"))
	}
	node.ProgressValue = node.ProgressMax - left
}

// SetParentProgressLeft set left progress of parent node as specific value
func (e *Entity) SetParentProgressLeft(left int64) {
	node := e.ParentNode()
	if left > node.ProgressMax {
		panic(errors.With(left, node.ProgressMax).Errorf(
			"left progress can't be more than progress max"))
	}
	node.ProgressValue = node.ProgressMax - left
}

// GetProgressValue gets progress value for cursor node
func (e *Entity) GetProgressValue() int64 {
	return e.CursorNode().ProgressValue
}

// GetNextProgressValue gets progress value for next node
func (e *Entity) GetNextProgressValue() int64 {
	return e.NextNode().ProgressValue
}

// GetParentProgressValue gets progress value for parent node
func (e *Entity) GetParentProgressValue() int64 {
	return e.ParentNode().ProgressValue
}