package internal

import (
	"context"
	"errors"
	"fmt"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"log"
	"strconv"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/consts"
)

func GetRankAward(ctx context.Context, id int32, aType int32) (all []map[string]interface{}, err error) {
	filter := bson.M{"_t": "RankAward"}
	if id != 0 {
		filter["_id"] = id
	}
	if aType != 0 {
		filter["Type"] = aType
	}
	err = MongoDatabaseList["0"].Collection("RankAward").Find(ctx, filter).All(&all)
	for _, v := range all {
		v["StringId"] = fmt.Sprint(v["_id"])
	}
	if err != nil {
		return
	}
	return all, err
}

func UpdateRankAward(ctx context.Context, data map[string]interface{}) (err error) {
	if g.IsEmpty(data["StringId"]) {
		delete(data, "StringId")
		log.Print("InsertAward", data)
		data["_id"] = gtime.TimestampNano()
		data["_t"] = "RankAward"
		//var ss *qmgo.InsertOneResult
		ss, err := MongoDatabaseList["0"].Collection("RankAward").InsertOne(ctx, data)
		log.Print("InsertAward %v", ss, err)
		return err
	}
	filter := bson.M{"_t": "RankAward"}
	filter["_id"], _ = strconv.ParseInt(fmt.Sprint(data["StringId"]), 10, 64)
	delete(data, "StringId")
	delete(data, "_id")
	//filter["Type"] = data["Type"]
	log.Print("UpdateAward", filter, data)
	err = MongoDatabaseList["0"].Collection("RankAward").UpdateOne(ctx, filter, bson.M{"$set": data})
	log.Print("RankAward", filter, data, err)

	return
}

func InsertRankAward(ctx context.Context, data map[string]interface{}) (err error) {
	data["_id"] = gtime.TimestampNano()
	data["_t"] = "RankAward"
	log.Print("InsertAward", data)
	ss, err := MongoDatabaseList["0"].Collection("RankAward").InsertOne(ctx, data)
	log.Print("InsertAward %v", ss)
	return
}

func GetRank(ctx context.Context, req *game.GetRankReq) (res *game.GetRankRes, err error) {
	filter := bson.M{}
	if req.Type != 0 {
		filter["Type"] = req.Type
	}
	if req.Style != 0 {
		filter["Style"] = req.Style
	}
	if req.Year != 0 {
		setStart := fmt.Sprintf("%d-01-01 00:00:00", req.Year)
		setStop := fmt.Sprintf("%d-01-01 00:00:00", req.Year+1)
		//dateFormat := "2006-01-02 15:04:05"
		//loc, _ := time.LoadLocation("Local") //重要：获取时区
		//starTimeObj, _ := time.ParseInLocation(dateFormat, setStart, loc)
		//stopTimeObj, _ := time.ParseInLocation(dateFormat, setStop, loc)

		filter["BeginTime"] = bson.M{"$gte": setStart, "$lt": setStop}
		fmt.Println("GetRank ", setStart, setStop, filter)
	}
	fmt.Println("GetRank ", filter)
	res = new(game.GetRankRes)
	err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).Sort("BeginTime").All(&res.Rank)
	for _, v := range res.Rank {
		v["StringId"] = fmt.Sprint(v["_id"])
	}
	fmt.Println("GetRank ", res)
	return
}

func UpdateRank(ctx context.Context, data map[string]interface{}) (err error) {
	if g.IsEmpty(data["StringId"]) {
		data["_id"] = gtime.TimestampNano()
		data["_t"] = "RankDaily"
		if data["Type"] == 0 {
			data["Type"] = consts.AWARD_DAILY
		}
		int64Num, _ := strconv.ParseInt(fmt.Sprint(data["Type"]), 10, 64)
		if int64Num == consts.AWARD_STAGE {
			data["_t"] = "RankStage"
		}
		log.Print("UpdateRank InsertRank", int64Num == consts.AWARD_STAGE, data)
		delete(data, "StringId")
		ss, err := MongoDatabaseList["0"].Collection("Rank").InsertOne(ctx, data)
		log.Print("UpdateRank InsertOne %v", ss)
		return err
	}
	filter := bson.M{"_t": "RankDaily"}
	if data["Type"] == 0 {
		data["Type"] = consts.AWARD_DAILY
		data["_t"] = "RankDaily"
	}
	int64Num, _ := strconv.ParseInt(fmt.Sprint(data["Type"]), 10, 64)
	if int64Num == consts.AWARD_STAGE {
		data["_t"] = "RankStage"
		filter["_t"] = "RankStage"
	}
	filter["_id"], _ = strconv.ParseInt(fmt.Sprint(data["StringId"]), 10, 64)
	//filter["Type"] = data["Type"]
	delete(data, "StringId")
	delete(data, "_id")
	log.Print("UpdateRank", filter, data)
	err = MongoDatabaseList["0"].Collection("Rank").UpdateOne(ctx, filter, bson.M{"$set": data})
	log.Print("UpdateRank", filter, data, err)

	return
}

func InsertRank(ctx context.Context, data map[string]interface{}) (err error) {
	data["_id"] = gtime.TimestampNano()
	if data["Type"] == 0 {
		data["Type"] = consts.AWARD_DAILY
	}
	if data["Type"] == consts.AWARD_STAGE {
		data["_t"] = "RankStage"
	} else {
		data["_t"] = "RankDaily"
	}
	log.Print("InsertRank", data["Type"] == consts.AWARD_STAGE, data)
	delete(data, "StringId")
	ss, err := MongoDatabaseList["0"].Collection("Rank").InsertOne(ctx, data)
	log.Print("InsertRank %v", ss)
	return
}

func DelRank(ctx context.Context, id string) (err error) {
	log.Print("DelRank", id)
	idInt, _ := strconv.ParseInt(id, 10, 64)
	err = MongoDatabaseList["0"].Collection("Rank").RemoveId(ctx, idInt)
	return
}

func CheckRank(ctx context.Context, data map[string]interface{}) (total int64, res string, err error) {
	log.Print("DelRank", data)
	filter := bson.M{"$and": bson.A{bson.M{"$or": bson.A{
		bson.M{"$and": bson.A{
			bson.M{"BeginTime": bson.M{"$lte": fmt.Sprint(data["BeginTime"])}},
			bson.M{"EndTime": bson.M{"$gt": fmt.Sprint(data["BeginTime"])}}}},
		bson.M{"$and": bson.A{
			bson.M{"BeginTime": bson.M{"$lt": fmt.Sprint(data["EndTime"])}},
			bson.M{"EndTime": bson.M{"$gte": fmt.Sprint(data["EndTime"])}}}},
		bson.M{"$and": bson.A{
			bson.M{"BeginTime": bson.M{"$gte": fmt.Sprint(data["BeginTime"])}},
			bson.M{"BeginTime": bson.M{"$lt": fmt.Sprint(data["EndTime"])}}}}}},
		bson.M{"_t": "RankStage"}}}

	log.Print("CheckPropExchange filter %v", filter)
	all := make([]map[string]interface{}, 1)
	total, err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).Count()
	err = MongoDatabaseList["0"].Collection("Rank").Find(ctx, filter).All(&all)
	log.Print("CheckPropExchange filter %v", res)
	for _, v := range all {
		res = fmt.Sprint(v["_id"])
	}
	return total, res, err
}

func AddRankGroup(ctx context.Context, req *game.AddRankGroupReq) (res *game.AddRankGroupRes, err error) {
	log.Print("AddRankGroup", req)
	filter := bson.M{"Name": req.Name, "StageGroupId": req.StageGroupId}

	res = new(game.AddRankGroupRes)
	log.Print("AddRankGroup filter %v", filter)
	err = MongoDatabaseList["0"].Collection("RankGroupName").Find(ctx, filter).All(&res)
	err = MongoDatabaseList["0"].Collection("RankGroupName").UpdateOne(ctx, filter, bson.M{"$set": filter})

	return res, err
}

func GetRankGroup(ctx context.Context, req *game.AddRankGroupReq) (res *game.AddRankGroupRes, err error) {
	log.Print("AddRankGroup", req)
	filter := bson.M{"Name": req.Name, "StageGroupId": req.StageGroupId}

	log.Print("AddRankGroup filter %v", filter)
	err = MongoDatabaseList["0"].Collection("RankGroupName").UpdateOne(ctx, filter, bson.M{"$set": filter})

	res = new(game.AddRankGroupRes)
	return res, err
}

func GetGameRank(ctx context.Context, req *game.GetGameRankReq) (res *game.GetGameRankRes, err error) {
	log.Printf("GetGameRank： %s", gjson.MustEncodeString(req))
	res = new(game.GetGameRankRes)
	mongo, ok := MongoDatabaseList[fmt.Sprint(req.ServerId)]
	if !ok {
		return res, errors.New("数据库为空！")
	}
	err = mongo.Collection(req.Name).Find(ctx, bson.M{}).All(&res.Groups)
	chillren := res.Groups[0]["Children"].(primitive.A)
	for _, v := range chillren {
		v1 := v.(map[string]interface{})
		if v1["UnitId"] != nil {
			v1["StringId"] = fmt.Sprint(v1["UnitId"])
			v1["uid"], _ = GetStringIdToUid(ctx, fmt.Sprint(v1["UnitId"]))
		}
	}

	return res, err
}