package gamelogic

import (
	"encoding/json"
	"fmt"

	"bet24.com/log"
)

type GameScene struct {
	Banker              int          // 庄家
	Phase               int          // 场景阶段
	ActionPhase         int          // 动作阶段
	PhaseIndex          int          // 场景阶段索引
	WhoseTurn           int          // 当前轮到谁操作
	FirstActionPlayer   int          // 游戏开始第一个操作的人
	LastTurn            int          // 上个操作的玩家
	Players             []PlayerInfo // 玩家信息
	GameIndex           int          // 游戏局数
	Index               int          // 场景索引
	LeftSec             int          // 剩余时间
	JackPotAmount       int          // 奖池数据
	CurrentTradeAmount  int          // 当前交易金额
	RoundWinner         []int        // 回合赢家
	CurrentMinRobScore  int          // 当前最小抢庄
	CurrentActionPlayer int          // 当前动作闲家

	userActions []userAction // 玩家动作用作回放数据
	tableId     int          // 桌子ID
	isNeedCalc  bool
}

func newGameScene(tableId int) *GameScene {
	gs := new(GameScene)
	gs.ctor()
	gs.initData(tableId)
	return gs
}

func (gs *GameScene) ctor() {
	gs.Players = make([]PlayerInfo, CHAIR_COUNT)
	for i := 0; i < CHAIR_COUNT; i++ {
		gs.Players[i].isEndToStart = false
	}
}

func (gs *GameScene) initData(tableId int) {
	gs.tableId = tableId
	gs.userActions = []userAction{}
	gs.Index = 0
	gs.GameIndex = 0
	gs.JackPotAmount = 0
	for i := 0; i < CHAIR_COUNT; i++ {
		gs.Players[i].initData(0, 0)
	}
	gs.gameInit(-1)
}

func (gs *GameScene) gameInit(whoseTurn int) {
	gs.Banker = -1
	gs.Phase = Phase_Free
	gs.ActionPhase = ActionPhase_Banker_GiveMoney
	gs.PhaseIndex = 0
	gs.RoundWinner = []int{}
	gs.WhoseTurn = whoseTurn
	gs.FirstActionPlayer = whoseTurn
	gs.LastTurn = -1
	gs.LeftSec = 0
	gs.CurrentActionPlayer = -1
	gs.CurrentTradeAmount = 0
	gs.CurrentMinRobScore = 0
	gs.isNeedCalc = true
	for i := 0; i < CHAIR_COUNT; i++ {
		gs.Players[i].gameInit()
	}
}

func (gs *GameScene) addUserAction(chairId, action, param int) {
	gs.userActions = append(gs.userActions, userAction{
		action: action,
		data:   fmt.Sprintf("ChairId:%d, Param:%d", chairId, param)})
}

func (gs *GameScene) nextChair() {
	gs.LastTurn = gs.WhoseTurn
	for {
		gs.WhoseTurn = getPreviousChair(gs.LastTurn)
		if gs.Players[gs.WhoseTurn].Score > 0 {
			break
		}
	}

}

func (gs *GameScene) nextActionChair() {
	gs.LastTurn = gs.WhoseTurn
	for {
		if gs.CurrentActionPlayer == -1 {
			gs.CurrentActionPlayer = getPreviousChair(gs.Banker)
		} else {
			gs.CurrentActionPlayer = getPreviousChair(gs.CurrentActionPlayer)
		}

		if gs.Players[gs.CurrentActionPlayer].RobScore > 0 || gs.Banker == gs.CurrentActionPlayer {
			break
		}
	}

	gs.WhoseTurn = gs.CurrentActionPlayer
}

func (gs *GameScene) compareCard() {
	winner := 0
	for i := 0; i < CHAIR_COUNT; i++ {
		if gs.Players[i].RobScore > 0 {
			winner = i
			break
		}
	}
	if winner == (CHAIR_COUNT - 1) {
		gs.RoundWinner = append(gs.RoundWinner, winner)
		return
	}
	start := winner
	for i := start + 1; i < CHAIR_COUNT; i++ {
		if gs.Players[i].RobScore <= 0 {
			continue
		}

		if isBigger(gs.Players[i].HandCards, gs.Players[winner].HandCards) {
			winner = i
		}
	}
	gs.RoundWinner = append(gs.RoundWinner, winner)
	for i := start + 1; i < CHAIR_COUNT; i++ {
		if gs.Players[i].RobScore <= 0 {
			continue
		}

		if i == winner {
			continue
		}

		if isEqual(gs.Players[i].HandCards, gs.Players[winner].HandCards) {
			gs.RoundWinner = append(gs.RoundWinner, i)
		}
	}
}

func (gs *GameScene) roundEnd() {
	if len(gs.RoundWinner) == 0 && gs.Banker != -1 {
		gs.RoundWinner = append(gs.RoundWinner, gs.Banker)
	}

	winnAmount := 0
	for i := 0; i < CHAIR_COUNT; i++ {
		if gs.Players[i].RobScore > 0 {
			winnAmount += gs.Players[i].RobScore
			gs.Players[i].ChangeScore -= gs.Players[i].RobScore
			gs.Players[i].RobScore = 0
		}
	}
	if len(gs.RoundWinner) == 0 {
		return
	}
	win := winnAmount / len(gs.RoundWinner)
	for i := 0; i < len(gs.RoundWinner); i++ {
		gs.Players[gs.RoundWinner[i]].Score += win
		gs.Players[gs.RoundWinner[i]].ChangeScore = win
	}
}

func (gs *GameScene) isNoNeedCompare() bool {
	for i := 0; i < CHAIR_COUNT; i++ {
		if i == gs.Banker {
			continue
		}
		if gs.Players[i].RobScore > 0 {
			return false
		}
	}
	gs.Players[gs.Banker].RobScore *= 2
	return true
}

func (gs *GameScene) isAllDoRobBanker() bool {
	for i := 0; i < CHAIR_COUNT; i++ {
		if gs.Players[i].Status == Player_Status_Play && gs.Players[i].RobScore == 0 {
			return false
		}
	}
	return true
}

func (gs *GameScene) isActionOver() bool {
	if gs.CurrentActionPlayer == gs.Banker {
		return true
	}
	nextChair := gs.CurrentActionPlayer
	for {
		if nextChair == -1 {
			nextChair = getPreviousChair(gs.Banker)
		} else {
			nextChair = getPreviousChair(nextChair)
		}

		if gs.Players[nextChair].RobScore > 0 || gs.Banker == nextChair {
			break
		}
	}

	return nextChair == gs.Banker
}

func (gs *GameScene) isBelowOneRobBanker() bool {
	if gs.WhoseTurn != -1 {
		return false
	}
	robCount := 0
	robChair := -1
	for i := 0; i < CHAIR_COUNT; i++ {
		if gs.Players[i].Status == Player_Status_Play || gs.Players[i].Status == Player_Status_AllIn {
			robCount++
			robChair = i
		}
	}

	if robCount == 1 {
		gs.Players[robChair].RobScore *= 2
		gs.RoundWinner = append(gs.RoundWinner, robChair)
	}

	return robCount <= 1
}

func (gs *GameScene) confirmBanker() {
	bigScore := 0
	charId := -1

	for i := 0; i < CHAIR_COUNT; i++ {
		chair := (gs.FirstActionPlayer + CHAIR_COUNT - i) % CHAIR_COUNT
		if gs.Players[chair].RobScore > bigScore {
			charId = chair
			bigScore = gs.Players[chair].RobScore
		}
	}
	gs.Banker = charId
	gs.WhoseTurn = gs.Banker
}

func (gs *GameScene) nextGame(winScore int) bool {
	gs.GameIndex++
	end := true
	for i := 0; i < CHAIR_COUNT; i++ {
		if !gs.Players[i].IsValid || gs.Players[i].Score == 0 {
			continue
		}

		if gs.Players[i].Score >= winScore {
			end = false
		}
	}

	return end
}

func (gs *GameScene) getWinner() int {
	winner := -1
	winScore := 0
	for i := 0; i < CHAIR_COUNT; i++ {
		if !gs.Players[i].IsValid || gs.Players[i].Score <= 0 {
			continue
		}

		if gs.Players[i].Score >= winScore {
			winner = i
			winScore = gs.Players[i].Score
		}
	}

	return winner
}

func (gs *GameScene) getCopy() GameScene {
	var ret GameScene
	d, _ := json.Marshal(gs)
	json.Unmarshal(d, &ret)
	return ret
}

func (gs *GameScene) getScene(chairId int, isPlayer bool, isOwnerWatCh bool) string {
	tmp := gs.getCopy()
	if isOwnerWatCh {
		d, _ := json.Marshal(tmp)
		return string(d)
	}
	for i := 0; i < CHAIR_COUNT; i++ {
		if gs.Phase == Phase_End || gs.Phase == Phase_RoundEnd || gs.Phase == Phase_CompareCard {
			continue
		}

		if chairId == i {
			continue
		}
		tmp.Players[i].hideSecretData()
	}

	d, _ := json.Marshal(tmp)
	return string(d)
}

func (gs *GameScene) dump() {
	log.Release("====GameScene Table[%d] Index[%d] GameIndex[%d]====", gs.tableId, gs.Index, gs.GameIndex)
	log.Release("    Phase[%d],PhaseIndex[%d], WhoseTurn[%d],LastTurn[%d],Banker[%d],FirstActionPlayer[%d], ActionPhase[%d]",
		gs.Phase, gs.PhaseIndex, gs.WhoseTurn, gs.LastTurn, gs.Banker, gs.FirstActionPlayer, gs.ActionPhase)
	log.Release("    JackPotAmount[%d],CurrentTradeAmount[%d],RoundWinner[%v],CurrentActionPlayer[%d]",
		gs.JackPotAmount, gs.CurrentTradeAmount, gs.RoundWinner, gs.CurrentActionPlayer)
	log.Release("    CurrentMinRobScore[%d]", gs.CurrentMinRobScore)
	for i := 0; i < CHAIR_COUNT; i++ {
		gs.Players[i].dump(i)
	}
	if len(gs.userActions) > 0 {
		log.Release("    Actions:%d", len(gs.userActions))
		for _, v := range gs.userActions {
			v.dump()
		}
	}

	log.Debug("---------------------------")
}