package slots

import (
	"github.com/idealeak/goserver/core/logger"
	_struct "mongo.games.com/game/gamesrv/slotspkg/internal/dao/struct"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/errors"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/global"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/player"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/session"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/shared"
	"mongo.games.com/game/gamesrv/slotspkg/slots/machine"
	"mongo.games.com/game/gamesrv/slotspkg/slots/types/cli"
)

func (sm *SlotsMgr) Enter(s *session.Session, gameId int64) (*cli.SlotsEnterResponse, error) {
	theme := key.GameMap[uint(gameId)]

	m := machine.NewMachine(s, theme, DataSet(s).Shell, false)
	if m == nil {
		logger.Logger.Error("[slotsMgr.enter] module is nil")
		return nil, errors.New("module is nil")
	}
	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()
	Response := &cli.SlotsEnterResponse{
		Code:          errors.Nil.Code(),
		NodeTree:      m.PlayLiteClose(),
		Coin:          player.CoinCenter.Get(s).GetCoin(),
		BetSizeIndex:  m.BetSizeIndex(),
		BetLevelIndex: m.BetLevelIndex(),
		BetLineIndex:  m.BetLineIndex(),
		BetSizes:      m.BetSizes(),
		BetLevels:     m.BetLevels(),
		BetLines:      m.BetLines(),
		BetChangeList: m.BetChangeList(),
	}
	return Response, nil
}

func (sm *SlotsMgr) Play(uid uint64, req *_struct.SpinReq) (*cli.SlotsPlayResponse, error) {
	s := sm.GetSession(uid)
	if s == nil {
		logger.Logger.Error("[slotsMgr.play] session is nil")
		return nil, errors.New("session is nil")
	}

	if req.BetSizeIndex < 0 {
		logger.Logger.Error("[slotsMgr.play] msg.BetSizeIndex < 0")
		return nil, errors.New("msg.BetSizeIndex < 0")
	}

	if req.BetLevelIndex < 0 {
		logger.Logger.Error("[slotsMgr.play] msg.BetLevelIndex < 0")
		return nil, errors.New("msg.BetLevelIndex < 0")
	}
	theme := key.GameMap[uint(req.GameId)]
	m := machine.NewMachine(s, theme, DataSet(s).Shell, false)
	if m == nil {
		logger.Logger.Error("[slotsMgr.play] module is nil")
		return nil, errors.New("module is nil")
	}

	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()

	var recorderResult = &shared.RecorderResult{}
	if m.Next().GetType() == key.BaseSpin {
		recorderResult = NewPlayAsRecorder(s)
		m.Play(&shared.Act{
			BetSizeIndex:  req.BetSizeIndex,
			BetLevelIndex: req.BetLevelIndex,
			BetLineIndex:  req.BetLineIndex,
			Ratio:         1,
			Mode:          key.MachineModePlayer,
			Vector:        recorderResult.Vector,
			//ExpectedWinCoin: recorderResult.ExpectedWinCoin,
			Choice:   req.BetMode,
			PlayMode: recorderResult.PlayMode,
		})
	} else {
		m.Play(&shared.Act{
			BetSizeIndex:  req.BetSizeIndex,
			BetLevelIndex: req.BetLevelIndex,
			BetLineIndex:  req.BetLineIndex,
			Ratio:         1,
			Mode:          key.MachineModePlayer,
			Choice:        req.BetMode,
		})
	}
	res := &cli.SlotsPlayResponse{
		Code:      errors.Nil.Code(),
		NodeTree:  m.PlayLiteClose(),
		ActualBet: m.ActualBet(),
		ActualWin: m.ActualWin(),
		Coin:      player.CoinCenter.Get(s).GetCoin(),
		IsEnd:     m.Next().GetType() == key.BaseSpin,
	}
	//if !global.Mock {
	//	defer player.PushPlayer(s)
	//}
	return res, nil
}
func (*SlotsMgr) Leave(s *session.Session) (*cli.SlotsLeaveResponse, error) {

	m := machine.NewMachine(s, "s.Theme", DataSet(s).Shell, false)

	defer func() {
		if m.Next().GetType() == key.BaseSpin {
			DataSet(s).Update()
		}
	}()

	m.QuitLiteClose()
	Response := &cli.SlotsLeaveResponse{
		Code: errors.Nil.Code(),
		Coin: player.CoinCenter.Get(s).GetCoin(),
	}
	if !global.Mock {
		defer player.PushPlayer(s)
	}
	return Response, nil
}