package main

import (
	"fmt"
	"sort"
	"time"

	"github.com/spf13/viper"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/mongox"
	"mongo.games.com/goserver/core/mysqlx"
	"mongo.games.com/goserver/core/viperx"

	"mongo.games.com/game/statistics/task/gamefree"
	"mongo.games.com/game/statistics/task/task"
)

const (
	ExcelTypeNewPlayerBankrupt = iota // 新用户游戏破产率
	ExcelTypeGameTimeAvg              // 新用户平均游戏时长
	ExcelTypeGameCountAvg             // 新用户平均局数
	ExcelTypeGameRate                 // 平均倍数
	ExcelTypeActiveRate               // 活跃破产率
	ExcelTypeCtrlWinRate              // 控输赢胜率
	ExcelTypeRobotWinRate             // 机器人胜率
	ExcelTypeCoinAvg                  // 人均获得金币
	ExcelTypeBankruptOffline          // 破产后离线
	ExcelTypeOfflineCoin              // 充值当天最后金币
)

var VP *viper.Viper

func main() {
	defer func() {
		logger.Logger.Flush()
		logger.Logger.Close()
	}()
	VP = viperx.GetViper("config", "yaml")
	// mongo
	vp := viperx.GetViper("mongo", "yaml")
	// mongo初始化
	conf := &mongox.Config{}
	err := vp.Unmarshal(conf)
	if err != nil {
		panic(fmt.Errorf("mongo config error: %v", err))
	}
	mongox.Init(conf)
	defer mongox.Close()

	// mysql
	vp = viperx.GetViper("mysql", "yaml")
	myConf := &mysqlx.Config{}
	err = vp.Unmarshal(myConf)
	if err != nil {
		panic(fmt.Errorf("mysql config error: %v", err))
	}
	mysqlx.Init(myConf)
	defer mysqlx.Close()

	startTime, err := time.Parse(time.RFC3339, VP.GetString("StartTime"))
	if err != nil {
		panic(fmt.Sprintf("time.Parse err: %v", err))
		return
	}
	endTime, err := time.Parse(time.RFC3339, VP.GetString("EndTime"))
	if err != nil {
		panic(fmt.Sprintf("time.Parse err: %v", err))
		return
	}

	mgr := NewExcelMgr()
	mgr.Register(ExcelTypeNewPlayerBankrupt, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
	mgr.Register(ExcelTypeGameTimeAvg, []string{"日期", "场次id", "参与人数", "平均游戏时长"})
	mgr.Register(ExcelTypeGameCountAvg, []string{"日期", "场次id", "参与人数", "平均局数"})
	mgr.Register(ExcelTypeGameRate, []string{"日期", "场次id", "总局数", "平均倍数", "有炸弹分局数", "炸弹分平均倍数", "2留在手里的局数"})
	mgr.Register(ExcelTypeActiveRate, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
	mgr.Register(ExcelTypeCtrlWinRate, []string{"日期", "场次id", "总局数", "平均倍数", "有炸弹分局数", "炸弹分平均倍数", "2留在手里的局数"})
	mgr.Register(ExcelTypeCtrlWinRate*10, []string{"日期", "场次id", "总局数", "平均倍数", "有炸弹分局数", "炸弹分平均倍数", "2留在手里的局数"})
	mgr.Register(ExcelTypeRobotWinRate, []string{"日期", "场次id", "总局数", "平均倍数", "有炸弹分局数", "炸弹分平均倍数", "2留在手里的局数"})
	mgr.Register(ExcelTypeCoinAvg, []string{"日期", "场次id", "参与人数", "人均获得金币"})
	mgr.Register(ExcelTypeBankruptOffline, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
	mgr.Register(ExcelTypeOfflineCoin, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
	switchArr := VP.GetIntSlice("Switch")

	for {
		if startTime.Unix() >= endTime.Unix() {
			break
		}
		startTimeStr := startTime.Format(time.RFC3339)
		et := startTime.AddDate(0, 0, 1)
		endTimeStr := et.Format(time.RFC3339)
		logger.Logger.Infof("startTime: %v endTime: %v", startTimeStr, endTimeStr)

		if switchArr[ExcelTypeNewPlayerBankrupt] == 1 {
			// 新用户游戏破产率
			mgr.GenNewPlayerBankruptRateExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeGameTimeAvg] == 1 {
			// 新用户平均游戏时长
			mgr.GenNewPlayerGameTimeAvgExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeGameCountAvg] == 1 {
			// 新用户平均局数
			mgr.GenGameCountExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeGameRate] == 1 {
			// 平均倍数
			mgr.GenGameRateExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeActiveRate] == 1 {
			// 活跃破产率
			mgr.GenActiveBankruptRateExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeCtrlWinRate] == 1 {
			// 控赢胜率
			mgr.GenCtrlWinRateExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeRobotWinRate] == 1 {
			// 机器人胜率
			mgr.GenRobotWinRateExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeCoinAvg] == 1 {
			// 人均获得金币
			mgr.GenCoinAvgExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeBankruptOffline] == 1 {
			// 破产后离线
			mgr.GenBankruptOfflineExcel("1", startTimeStr, endTimeStr)
		}
		if switchArr[ExcelTypeOfflineCoin] == 1 {
			// 离线金币
			mgr.GenOfflineCoinExcel("1", startTimeStr, endTimeStr)
		}

		startTime = et
	}

	mgr.SaveAll(VP.GetString("StartTime")[:10], endTime.AddDate(0, 0, -1).Format(time.DateOnly))
}

func (e *ExcelMgr) SaveAll(startTime, endTime string) {
	switchArr := VP.GetIntSlice("Switch")
	if switchArr[ExcelTypeNewPlayerBankrupt] == 1 {
		e.Save(ExcelTypeNewPlayerBankrupt, fmt.Sprintf("新用户破产率_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeGameTimeAvg] == 1 {
		e.Save(ExcelTypeGameTimeAvg, fmt.Sprintf("新用户平局游戏时长_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeGameCountAvg] == 1 {
		e.Save(ExcelTypeGameCountAvg, fmt.Sprintf("新用户平均局数_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeGameRate] == 1 {
		e.Save(ExcelTypeGameRate, fmt.Sprintf("平均倍数_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeActiveRate] == 1 {
		e.Save(ExcelTypeActiveRate, fmt.Sprintf("活跃破产率_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeCtrlWinRate] == 1 {
		e.Save(ExcelTypeCtrlWinRate, fmt.Sprintf("控赢胜率_%s_%s.xlsx", startTime, endTime))
		e.Save(ExcelTypeCtrlWinRate*10, fmt.Sprintf("控输胜率_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeRobotWinRate] == 1 {
		e.Save(ExcelTypeRobotWinRate, fmt.Sprintf("机器人输率_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeCoinAvg] == 1 {
		e.Save(ExcelTypeCoinAvg, fmt.Sprintf("人均获得金币_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeBankruptOffline] == 1 {
		e.Save(ExcelTypeBankruptOffline, fmt.Sprintf("破产后离线_%s_%s.xlsx", startTime, endTime))
	}
	if switchArr[ExcelTypeOfflineCoin] == 1 {
		e.Save(ExcelTypeOfflineCoin, fmt.Sprintf("离线金币_%s_%s.xlsx", startTime, endTime))
	}
}

func GetGameFreeName(id int) string {
	d := gamefree.PBDB_GameFreeMgr.GetData(int32(id))
	return fmt.Sprintf("%s_%s", d.Name, d.Title)
}

func (e *ExcelMgr) GenNewPlayerBankruptRateExcel(plt string, startTime, endTime string) {
	for _, v := range VP.GetIntSlice("Gamefreeids") {
		_, a, b, err := task.NewPlayerBankruptRate(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("NewPlayerBankruptRate get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}
		ex := e.Get(ExcelTypeNewPlayerBankrupt)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(a)
		ex.SetCell(b)
		if b > 0 {
			ex.SetCell(float64(a) / float64(b))
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("NewPlayerBankruptRate GameFreeId: %v rate: %v", v, float64(a)/float64(b))
	}
}

func (e *ExcelMgr) GenNewPlayerGameTimeAvgExcel(plt string, startTime, endTime string) {
	for _, v := range VP.GetIntSlice("Gamefreeids") {
		a, b, err := task.NewPlayerGameTimeAvg(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("NewPlayerGameTimeAvg get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}
		ex := e.Get(ExcelTypeGameTimeAvg)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(a)
		if a > 0 {
			avg := float64(b) / float64(a)
			show := fmt.Sprintf("%v", time.Second*time.Duration(avg))
			ex.SetCell(show)
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("NewPlayerGameTimeAvg GameFreeId: %v avg: %v", v, float64(b)/float64(a))
	}
}

func (e *ExcelMgr) GenGameCountExcel(plt string, startTime, endTime string) {
	for _, v := range VP.GetIntSlice("Gamefreeids") {
		a, b, err := task.NewPlayerGameCountAvg(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("NewPlayerGameCountAvg get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}
		ex := e.Get(ExcelTypeGameCountAvg)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(a)
		if a > 0 {
			ex.SetCell(float64(b) / float64(a))
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("NewPlayerGameCountAvg GameFreeId: %v avg: %v", v, float64(b)/float64(a))
	}
}

func (e *ExcelMgr) GenGameRateExcel(plt string, startTime, endTime string) {
	for _, v := range VP.GetIntSlice("Gamefreeids") {
		total, bombTotal, remain2Total, rateAvg, bombRateAvg, err := task.PlayerGameRate(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("PlayerGameRate get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}
		ex := e.Get(ExcelTypeGameRate)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(total)
		ex.SetCell(rateAvg)
		ex.SetCell(bombTotal)
		ex.SetCell(bombRateAvg)
		ex.SetCell(remain2Total)
		logger.Logger.Tracef("PlayerGameRate GameFreeId: %v total: %v rateAvg: %v bombTotal: %v bombRateAvg: %v remain2Total: %v",
			v, total, rateAvg, bombTotal, bombRateAvg, remain2Total)
	}
}

func (e *ExcelMgr) GenActiveBankruptRateExcel(plt string, startTime, endTime string) {
	for _, v := range VP.GetIntSlice("Gamefreeids") {
		b, t, err := task.ActivePlayerBankruptRate(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("ActivePlayerBankruptRate get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}

		ex := e.Get(ExcelTypeActiveRate)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(b)
		ex.SetCell(t)
		if t > 0 {
			if b > t {
				b = t
			}
			ex.SetCell(float64(b) / float64(t))
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("ActivePlayerBankruptRate GameFreeId: %v rate: %v", v, float64(b)/float64(t))
	}
}

func (e *ExcelMgr) GenCtrlWinRateExcel(plt string, startTime, endTime string) {
	for _, v := range append(VP.GetIntSlice("Tienlen")) {
		ret, err := task.GameDetailWinRate(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("GameDetailWinRate get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}
		if len(ret) > 0 {
			ex := e.Get(ExcelTypeCtrlWinRate)
			ex.NewLine()
			ex.SetCell(startTime[:10])
			ex.SetCell(GetGameFreeName(v))
			ex.SetCell(ret[0].First)
			ex.SetCell(ret[0].Second)
			ex.SetCell(ret[0].Third)
			ex.SetCell(ret[0].Total)
			if ret[0].Total > 0 {
				ex.SetCell(float64(ret[0].First+ret[0].Second) / float64(ret[0].Total))
			} else {
				ex.SetCell(0)
			}
			logger.Logger.Tracef("GameDetailWinRate GameFreeId:%v %+v", v, ret[0])
		}
		if len(ret) > 1 {
			ex := e.Get(ExcelTypeCtrlWinRate * 10)
			ex.NewLine()
			ex.SetCell(startTime[:10])
			ex.SetCell(GetGameFreeName(v))
			ex.SetCell(ret[1].First)
			ex.SetCell(ret[1].Second)
			ex.SetCell(ret[1].Third)
			ex.SetCell(ret[1].Total)
			if ret[1].Total > 0 {
				ex.SetCell(float64(ret[1].First+ret[1].Second) / float64(ret[1].Total))
			} else {
				ex.SetCell(0)
			}
			logger.Logger.Tracef("GameDetailWinRate GameFreeId:%v %+v", v, ret[1])
		}
	}
}

func (e *ExcelMgr) GenRobotWinRateExcel(plt string, startTime, endTime string) {
	for _, v := range append(VP.GetIntSlice("Tienlen"), VP.GetIntSlice("Thirteen")...) {
		a, b, err := task.RobotWinRate(plt, startTime, endTime, v)
		if err != nil {
			logger.Logger.Errorf("RobotWinRate get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
			continue
		}

		ex := e.Get(ExcelTypeRobotWinRate)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(GetGameFreeName(v))
		ex.SetCell(a)
		ex.SetCell(b)
		if b > 0 {
			ex.SetCell(float64(b-a) / float64(b))
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("RobotWinRate GameFreeId: %v rate: %v", v, float64(a)/float64(b))
	}
}

func (e *ExcelMgr) GenCoinAvgExcel(plt string, startTime, endTime string) {
	type KV struct {
		K int
		V string
	}

	var list []KV
	for k, v := range task.CoinName {
		list = append(list, KV{K: k, V: v})
	}

	sort.Slice(list, func(i, j int) bool {
		return list[i].K < list[j].K
	})

	for _, item := range list {
		k, v := item.K, item.V
		a, b, err := task.CoinAvg(plt, startTime, endTime, k)
		if err != nil {
			logger.Logger.Errorf("CoinAvg get StartTime:%v EndTime:%v tp:%v err: %v", startTime, endTime, k, err)
			continue
		}
		ex := e.Get(ExcelTypeCoinAvg)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(v)
		ex.SetCell(a)
		ex.SetCell(b)
		if a > 0 {
			ex.SetCell(float64(b) / float64(a))
		} else {
			ex.SetCell(0)
		}
		logger.Logger.Tracef("CoinAvg tp: %v rate: %v", k, float64(b)/float64(a))
	}
}

func (e *ExcelMgr) GenBankruptOfflineExcel(plt string, startTime, endTime string) {
	res, err := task.BankruptOffline(plt, startTime, endTime)
	if err != nil {
		logger.Logger.Errorf("BankruptOffline get StartTime:%v EndTime:%v err: %v", startTime, endTime, err)
		return
	}
	ex := e.Get(ExcelTypeBankruptOffline)
	ex.NewLine()
	ex.SetCell(startTime[:10])
	ex.SetCell(res.One)
	ex.SetCell(res.Two)
	ex.SetCell(res.Three)
	ex.SetCell(res.Recharge)
	ex.SetCell(fmt.Sprintf("%v", res.D))
	logger.Logger.Tracef("BankruptOffline %+v", res)
}

func (e *ExcelMgr) GenOfflineCoinExcel(plt string, startTime, endTime string) {
	res, err := task.OfflineCoin(plt, startTime, endTime)
	if err != nil {
		logger.Logger.Errorf("OfflineCoin get StartTime:%v EndTime:%v err: %v", startTime, endTime, err)
		return
	}
	for _, v := range res {
		ex := e.Get(ExcelTypeOfflineCoin)
		ex.NewLine()
		ex.SetCell(startTime[:10])
		ex.SetCell(v.Snid)
		ex.SetCell(v.Coin)
	}
	logger.Logger.Tracef("OfflineCoin %+v", res)
}