package handler

import (
	"fmt"
	"math/rand"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/providers/all"
	"server/modules/web/providers/base"
	"server/modules/web/values"
	"server/util"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"github.com/olivere/elastic/v7"
)

func GameList(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameListReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameListResp{Provider: req.Provider}
	a.Data = resp
	var list, tmp []*common.ConfigGameList
	var randFlag bool

	if req.Provider == -1 {
		req.Provider = 0
	}
	if req.Mark == -1 {
		req.Mark = 0
	} else {
		req.Mark = 0
		randFlag = true
	}
	if req.Type == -1 || req.Type == 1 {
		req.Type = 0
	}

	// if req.Provider == -1 {
	// 	req.Provider = 0
	// 	randFlag = true
	// }
	tmp = call.GetConfigGameList(0, req.Provider, req.Mark, req.Type)
	if randFlag {
		rand.Shuffle(len(tmp), func(i, j int) {
			tmp[i], tmp[j] = tmp[j], tmp[i]
		})
	}
	if len(req.Name) > 0 {
		reqName := strings.ToLower(req.Name)
		for _, v := range tmp {
			if strings.Contains(strings.ToLower(v.Name), reqName) {
				list = append(list, v)
			}
		}
	} else {
		list = tmp
	}

	start := req.Page * req.Num
	end := (req.Page + 1) * req.Num

	if start > len(list)-1 {
		return
	}
	if end > len(list) {
		end = len(list)
	}
	resp.List = list[start:end]
	call.GetGameInfo(resp.List)
	for _, v := range resp.List {
		v.Jackpot = call.GetJackpot(common.JackpotTypeGame, v.GameID)
	}
}

func GameTag(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameTagReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameTagResp{}
	a.Data = resp
	showGameTags := call.GetConfigShowGameTag(req.TagId)
	if len(showGameTags) == 0 {
		return
	}
	showGameTag := showGameTags[0]
	configGameTags := call.GetConfigGameTagByIds(showGameTag.ShowTagIdsInt)
	tags := make([]values.TagWithGameList, 0, len(configGameTags))
	for _, v := range configGameTags {
		showCount := v.ShowCount
		if showCount == 0 {
			showCount = 8
		}
		tagTmp := values.TagWithGameList{
			ID:     v.TagId,
			Name:   v.TagName,
			Action: v.TagType,
			Icon:   v.Icon,
		}
		gameList := call.GetGameListByTags([]int{v.TagId})
		if showCount > len(gameList) {
			showCount = len(gameList)
		}
		tagTmp.List = make([]values.GameData, 0, showCount)
		for _, gameTmp := range gameList {
			if len(tagTmp.List) >= showCount {
				break
			}
			tagTmp.List = append(tagTmp.List, values.GameData{
				Id:           gameTmp.ID,
				GameId:       gameTmp.GameID,
				GameProvider: gameTmp.GameProvider,
				GameTag:      gameTmp.Mark,
				GameStatus:   gameTmp.GameStatus,
				GameIcon:     gameTmp.Icon,
			})
		}
		tagTmp.Total = len(gameList)
		tags = append(tags, tagTmp)
	}

	configBanners := call.GetConfigBanner(a.UID, req.TagId)
	banners := make([]values.Banner, 0, len(configBanners))
	for _, v := range configBanners {
		banners = append(banners, values.Banner{
			Id:     v.ActivityID,
			Action: v.Type,
			Url:    v.JumpUrl,
			Icon:   v.Pic,
		})
	}
	resp.Banners = banners
	resp.Tags = tags
}

func GameListNew(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameListNewReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameListNewResp{}
	a.Data = resp
	gameList := call.GetGameListByTags([]int{req.SubTagId})
	resp.Total = len(gameList)

	if resp.Total == 0 {
		return
	}
	start := (req.Page - 1) * req.PageSize
	end := start + req.PageSize
	if end > len(gameList) {
		end = len(gameList)
	}
	list := make([]values.GameData, 0, req.PageSize)
	for _, gameTmp := range gameList {
		list = append(list, values.GameData{
			Id:           gameTmp.ID,
			GameId:       gameTmp.GameID,
			GameProvider: gameTmp.GameProvider,
			GameTag:      gameTmp.Mark,
			GameStatus:   gameTmp.GameStatus,
			GameIcon:     gameTmp.Icon,
		})
	}
	resp.List = list[start:end]
}

func EnterGame(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.EnterGameReq)
	if !a.S(req) {
		return
	}
	provider := call.GetConfigGameProvider(req.Provider)
	resp := new(values.EnterGameResp)
	if provider != nil {
		resp.Method = provider.Method
	}
	a.Data = resp
	// step:特殊逻辑处理
	if req.Provider == common.ProviderPGSoft {
		provider = call.GetConfigGameProvider(common.ProviderPG3)
		game := call.GetConfigGameListByID(common.ProviderPG3, req.GameID)
		if game != nil && game.Open == 1 {
			req.Provider = common.ProviderPG3
			resp.Method = provider.Method
		} else {
			provider = call.GetConfigGameProvider(common.ProviderPG2)
			game = call.GetConfigGameListByID(common.ProviderPG2, req.GameID)
			if game != nil && game.Open == 1 {
				req.Provider = common.ProviderPG2
				resp.Method = provider.Method
			}
		}
	}

	if req.IsDemo {
		log.Debug("player enter demo game %+v", *req)
		enter := &base.EnterGameReq{
			ProviderID:   req.Provider,
			GameID:       req.GameID,
			Lang:         a.Lang,
			CurrencyType: req.Currency,
			IsDemo:       true,
			SubID:        req.SubID,
			IP:           a.GetRemoteIP(),
			DeviceType:   a.DeviceType,
			ChannelID:    a.Channel,
		}
		resp.URL = all.EnterGame(enter)
		return
	}
	if !req.Currency.IsValid() {
		a.Code = values.CodeParam
		return
	}
	token := c.GetHeader("token")
	uid, _ := db.Redis().GetInt(common.GetRedisKeyToken(token))
	if uid == 0 {
		a.Code = values.CodeToken
		return
	}
	c.Set("uid", uid)
	c.Set("token", token)
	util.Go(func() {
		db.Redis().AddUserExpire(uid, token)
	})
	log.Debug("player %d enter game %+v", uid, *req)
	enter := &base.EnterGameReq{
		ProviderID:   req.Provider,
		GameID:       req.GameID,
		UID:          uid,
		Token:        token,
		Lang:         a.Lang,
		CurrencyType: req.Currency,
		IsDemo:       false,
		SubID:        req.SubID,
		IP:           a.GetRemoteIP(),
		DeviceType:   a.DeviceType,
		ChannelID:    a.Channel,
	}
	resp.URL = all.EnterGame(enter)
	if resp.URL == "" {
		a.Code = values.CodeParam
		a.Msg = "Under Maintenance,please try later."
		return
	}
	util.Go(func() {
		// 记录玩家的记录
		err := call.AddGameRecord(uid, req.Provider, req.GameID)
		if err != nil {
			log.Error("AddGameRecord uid:%v, err:%v", uid, err)
			return
		}
	})
}

func EnterGameNew(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.EnterGameNewReq)
	if !a.S(req) {
		return
	}
	provider := call.GetConfigGameProvider(req.Provider)
	resp := new(values.EnterGameResp)
	if provider != nil {
		resp.Method = provider.Method
	}
	resp.GameId = req.GameID
	a.Data = resp
	// step:特殊逻辑处理
	if req.Provider == common.ProviderPGSoft {
		provider = call.GetConfigGameProvider(common.ProviderPG3)
		game := call.GetConfigGameListByID(common.ProviderPG3, req.GameID)
		if game != nil && game.Open == 1 {
			req.Provider = common.ProviderPG3
			resp.Method = provider.Method
		} else {
			provider = call.GetConfigGameProvider(common.ProviderPG2)
			game = call.GetConfigGameListByID(common.ProviderPG2, req.GameID)
			if game != nil && game.Open == 1 {
				req.Provider = common.ProviderPG2
				resp.Method = provider.Method
			}
		}
	}

	//if req.IsDemo {
	//	log.Debug("player enter demo game %+v", *req)
	//	enter := &base.EnterGameReq{
	//		ProviderID:   req.Provider,
	//		GameID:       req.GameID,
	//		Lang:         a.Lang,
	//		CurrencyType: req.Currency,
	//		IsDemo:       true,
	//		SubID:        req.SubID,
	//		IP:           a.GetRemoteIP(),
	//		DeviceType:   a.DeviceType,
	//		ChannelID:    a.Channel,
	//	}
	//	resp.URL = all.EnterGame(enter)
	//	return
	//}
	//if !req.Currency.IsValid() {
	//	a.Code = values.CodeParam
	//	return
	//}
	token := c.GetHeader("token")
	uid, _ := db.Redis().GetInt(common.GetRedisKeyToken(token))
	if uid == 0 {
		a.Code = values.CodeToken
		return
	}
	c.Set("uid", uid)
	c.Set("token", token)
	util.Go(func() {
		db.Redis().AddUserExpire(uid, token)
	})
	log.Debug("player %d enter game %+v", uid, *req)
	enter := &base.EnterGameReq{
		ProviderID:   req.Provider,
		GameID:       req.GameID,
		UID:          uid,
		Token:        token,
		Lang:         a.Lang,
		CurrencyType: common.CurrencyINR,
		IsDemo:       false,
		//SubID:        req.SubID,
		IP:         a.GetRemoteIP(),
		DeviceType: a.DeviceType,
		ChannelID:  a.Channel,
	}
	resp.URL = all.EnterGame(enter)
	if resp.URL == "" {
		a.Code = values.CodeParam
		a.Msg = "Under Maintenance,please try later."
		return
	}
	util.Go(func() {
		// 记录玩家的记录
		err := call.AddGameRecord(uid, req.Provider, req.GameID)
		if err != nil {
			log.Error("AddGameRecord uid:%v, err:%v", uid, err)
			return
		}
	})
}

func GameHistory(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameHistoryReq)
	if !a.S(req) {
		return
	}
	if req.UID > 0 && req.UID != a.UID {
		a.Code = values.CodeParam
		return
	}
	log.Debug("player %d GameHistory %+v", a.UID, *req)
	if req.Num > 100 {
		return
	}
	resp := new(values.GameHistoryResp)
	a.Data = resp
	q := elastic.NewBoolQuery()
	if req.UID > 0 {
		q.Filter(elastic.NewTermQuery("UID", req.UID))
	}
	list := []common.ESGameData{}
	db.ES().QueryList(common.ESIndexGameData, req.Page, req.Num, q, &list, "Time", false)
	for _, v := range list {
		one := values.BetRecord{
			UID:          v.UID,
			Vip:          call.GetVIP(v.UID).Level,
			Provider:     v.Provider,
			GameID:       v.GameID,
			Time:         v.Time,
			BetAmount:    v.BetAmount,
			SettleAmount: v.SettleAmount,
			Multiplier:   util.FormatFloat(float64(v.SettleAmount)/float64(v.BetAmount), 4),
			CurrencyType: v.Type,
		}
		ga := call.GetConfigGameListByID(v.Provider, v.GameID)
		if ga != nil {
			one.GameName = ga.Name
		}
		player, _ := call.GetUserXInfo(v.UID, "nick", "avatar")
		one.Avatar = player.Avatar
		one.Nick = player.Nick
		resp.List = append(resp.List, one)
	}
}

func GameProfile(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := new(values.GameProfileResp)
	a.Data = resp

	p, _ := call.GetUserXInfo(a.UID, "birth")
	resp.Birth = p.Birth
	// 拉取profile
	for i := common.CurrencyTypeZero + 1; i < common.CurrencyAll; i++ {
		profile := common.PlayerProfile{}
		db.Mysql().C().Table(fmt.Sprintf("player_profile_%s", i.GetCurrencyName())).Where("uid = ?", a.UID).Scan(&profile)
		resp.Statistics = append(resp.Statistics, profile)
	}

	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewTermQuery("UID", a.UID))
	q.Filter(elastic.NewRangeQuery("SettleAmount").Gt(0))
	list := []common.ESGameData{}
	db.ES().QueryList(common.ESIndexGameData, 0, 10, q, &list, "SettleAmount", false)
	for _, v := range list {
		one := values.TopWins{
			Provider:     v.Provider,
			GameID:       v.GameID,
			Time:         v.Time,
			BetAmount:    v.BetAmount,
			SettleAmount: v.SettleAmount,
			CurrencyType: v.Type,
		}
		ga := call.GetConfigGameListByID(v.Provider, v.GameID)
		if ga != nil {
			one.GameName = ga.Name
		}
		resp.TopWins = append(resp.TopWins, one)
	}
}

func GameSearch(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.GameSearchReq)
	if !a.S(req) {
		return
	}
	resp := &values.GameSearchResp{}
	a.Data = resp
	list := call.GetConfigGameListByName(req.Name)
	start := req.Page * req.Num
	end := (req.Page + 1) * req.Num
	if start > len(list)-1 {
		return
	}
	if end > len(list) {
		end = len(list)
	}
	resp.List = list[start:end]
}