package controller

import (
	"context"
	"fmt"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/model/entity"
	"tyj_admin/internal/service"
	"tyj_admin/internal/serviceGame"
	"tyj_admin/library/libUtils"
	"tyj_admin/library/liberr"
)

var GamePub = pubController{}

type pubController struct {
	BaseController
}

func (c *pubController) Get(ctx context.Context, req *game.GetGameNoticeReq) (res *game.GetGameNoticeRes, err error) {
	res, err = serviceGame.GameNotice().GetGameNotice(ctx, req)
	return
}

func (c *pubController) GetList(ctx context.Context, req *game.GetGameNoticeListReq) (res *game.GetGameNoticeListRes, err error) {
	res, err = serviceGame.GameNotice().GetGameNoticeList(ctx, req)
	return
}

func (c *pubController) GetUpdateUrl(ctx context.Context, req *game.GetGameUpdateUrlReq) (res *game.GetGameUpdateUrlRes, err error) {
	config := new(entity.SysConfig)
	res = new(game.GetGameUpdateUrlRes)
	config, err = service.Config().GetByKey(ctx, req.Channel+"_url")
	if err == nil && config != nil {
		res.Url = config.ConfigValue
	}
	return
}

func (c *pubController) GetLoginUrl(ctx context.Context, req *game.GetGameLoginUrlReq) (res *game.GetGameLoginUrlRes, err error) {
	res, err = serviceGame.GameLoginUrl().GetGameLoginUrl(ctx, req)
	return
}

func (c *pubController) GetCCD(ctx context.Context, req *game.GetGameCCDReq) (res *game.GetGameCCDRes, err error) {
	var set map[string]struct{}
	set = make(map[string]struct{})
	set["Android"] = struct{}{}
	set["Ios"] = struct{}{}
	set["Editor"] = struct{}{}

	err = g.Try(ctx, func(ctx context.Context) {
		if _, ok := set[req.Platform]; !ok {
			fmt.Println("err ", err)
			liberr.ErrIsNil(ctx, err, "平台输入错误")
		}

		res, err = serviceGame.GameCCD().GetGameCCD(ctx, req)
		g.Log().Debugf(ctx, "GetGameCCD -> "+res.Url, "Version: "+res.Version)
		return
	})
	return
}

func (c *pubController) GetCCD1(ctx context.Context, req *game.GetGameCCD1Req) (res *game.GetGameCCD1Res, err error) {
	var set map[string]struct{}
	set = make(map[string]struct{})
	set["Android"] = struct{}{}
	set["Ios"] = struct{}{}
	set["Editor"] = struct{}{}

	err = g.Try(ctx, func(ctx context.Context) {
		if _, ok := set[req.Platform]; !ok {
			liberr.ErrIsNil(ctx, err, "平台输入错误")
			fmt.Println("err ", err)
			return
		}

		res, err = serviceGame.GameCCD().GetGameCCD1(ctx, req)
		g.Log().Debugf(ctx, "GetGameCCD -> ", "Version: "+res.Version)
		return
	})
	return
}

func (c *pubController) GetWhiteState(ctx context.Context, req *game.GetWhiteListReq) (res *game.GetWhiteListRes, err error) {
	err = g.Try(ctx, func(ctx context.Context) {
		ip := libUtils.GetClientIp(ctx)
		//fmt.Println("ip: ", ip)
		res = new(game.GetWhiteListRes)
		res.Count = serviceGame.GameWhiteList().GetWhiteState(ctx, ip)
	})
	return
}

func (c *pubController) GetWhiteList(ctx context.Context, req *game.WhiteListReq) (res *game.WhiteListRes, err error) {
	err = g.Try(ctx, func(ctx context.Context) {
		res = serviceGame.GameWhiteList().GetWhiteList(ctx)
		log.Printf("res.WhiteList: %v", res)
	})
	return
}

func (c *pubController) RechargeControl(ctx context.Context, req *game.RechargeControlReq) (res *game.RechargeControlRes, err error) {
	res, err = serviceGame.GameOrder().GameRechargeControl(ctx, req)
	return res, err
}

func (c *pubController) Advertise(ctx context.Context, req *game.ADReq) (res *game.ADRes, err error) {
	res, err = serviceGame.Advertisement().Advertise(ctx, req)
	return
}

func (c *pubController) DeepAdvertise(ctx context.Context, req *game.DeepADReq) (res *game.DeepADRes, err error) {
	res, err = serviceGame.Advertisement().DeepAdvertise(ctx, req)
	return
}

func (c *pubController) GetOpenId(ctx context.Context, req *game.GetOpenIdReq) (res *game.GetOpenIdRes, err error) {
	res, err = serviceGame.GamePub().GetOpenId(ctx, req)
	return
}

func (c *pubController) SetGmToClient(ctx context.Context, req *game.SetGmToClientReq) (res *game.SetGmToClientRes, err error) {
	res, err = serviceGame.GameManage().SetGmToClient(ctx, req)
	return
}

func (c *pubController) AttributionHugeAmount(ctx context.Context, req *game.ATHAReq) (res *game.ATHARes, err error) {
	res, err = serviceGame.Advertisement().AttributionHugeAmount(ctx, req)
	return
}

func (c *pubController) ConversionHugeAmount(ctx context.Context, req *game.CSHAReq) (res *game.CSHARes, err error) {
	res, err = serviceGame.Advertisement().ConversionHugeAmount(ctx, req)
	return
}

func (c *pubController) AdvertiseHugeAmount(ctx context.Context, req *game.AdvertiseHAReq) (res *game.AdvertiseHARes, err error) {
	log.Print("AdvertiseHugeAmount", gjson.MustEncodeString(req))
	res, err = serviceGame.Advertisement().AdvertiseHugeAmount(ctx, req)
	return
}

func (c *pubController) AdvertiseHugeAmount1(ctx context.Context, req *game.AdvertiseHA1Req) (res *game.AdvertiseHA1Res, err error) {
	log.Print("AdvertiseHugeAmount1", gjson.MustEncodeString(req))
	res = new(game.AdvertiseHA1Res)
	err = serviceGame.Advertisement().AdvertiseHugeAmount1(ctx, req.Androidid, req.Idfa, req.Os, req.Callback, req.TIMESTAMP)
	return
}

func (c *pubController) AdvertiseHugeAmount2(ctx context.Context, req *game.AdvertiseHA2Req) (res *game.AdvertiseHA2Res, err error) {
	log.Print("AdvertiseHugeAmount2", gjson.MustEncodeString(req))
	res = new(game.AdvertiseHA2Res)
	err = serviceGame.Advertisement().AdvertiseHugeAmount1(ctx, req.Androidid, req.Idfa, req.Os, req.Callback, req.TIMESTAMP)
	return
}

func (c *pubController) AdvertiseHugeAmount3(ctx context.Context, req *game.AdvertiseHA3Req) (res *game.AdvertiseHA3Res, err error) {
	log.Print("AdvertiseHugeAmount3", gjson.MustEncodeString(req))
	res = new(game.AdvertiseHA3Res)
	err = serviceGame.Advertisement().AdvertiseHugeAmount1(ctx, req.Androidid, req.Idfa, req.Os, req.Callback, req.TIMESTAMP)
	return
}

func (c *pubController) AdvertiseHugeAmount4(ctx context.Context, req *game.AdvertiseHA4Req) (res *game.AdvertiseHA4Res, err error) {
	log.Print("AdvertiseHugeAmount4", gjson.MustEncodeString(req))
	res = new(game.AdvertiseHA4Res)
	err = serviceGame.Advertisement().AdvertiseHugeAmount1(ctx, req.Androidid, req.Idfa, req.Os, req.Callback, req.TIMESTAMP)
	return
}

func (c *pubController) AdvertiseHugeAmount5(ctx context.Context, req *game.AdvertiseHA5Req) (res *game.AdvertiseHA5Res, err error) {
	log.Print("AdvertiseHugeAmount5", gjson.MustEncodeString(req))
	res = new(game.AdvertiseHA5Res)
	err = serviceGame.Advertisement().AdvertiseHugeAmount1(ctx, req.Androidid, req.Idfa, req.Os, req.Callback, req.TIMESTAMP)
	return
}