package scripts

import (
	"fmt"
	"mygo/api"
	"mygo/conf"
	"mygo/dbhelper"
	"mygo/libs"
	"mygo/model"
	"mygo/response"
	"mygo/say"
	"mygo/validator"
	"strconv"
	"strings"
	"time"

	"github.com/fatih/color"
	"github.com/labstack/echo/v4"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

func GetHome(c echo.Context) error {
	data := response.AdminHomeResponse{}

	collection := dbhelper.GetMongoCollection("user")

	today_count, err := model.GetTodayCreateCount(collection)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	data.TodayUserTotal = today_count

	total_count, err1 := model.GetTotalCreateCount(collection)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	data.UserTotal = total_count

	col := dbhelper.GetMongoCollection("recharge_order")

	today_recharge_total, err2 := model.GetTodayRechargeToTal(col)

	if err2 != nil {
		return say.Success(c, 10000, data)
	}
	data.TodayRechargeTotal = int64(today_recharge_total)

	recharge_total, err3 := model.GetRechargeToTal(col)
	if err3 != nil {
		return say.Success(c, 10000, data)
	}
	data.RechargeTotal = int64(recharge_total)

	thisWeek, lastWeek, err4 := model.CalculateThisWeekAndLastWeekPaymentTotal(col)

	if err4 != nil {
		return say.Success(c, 10000, data)
	}

	data.ThisWeek = thisWeek
	data.LastWeek = lastWeek

	thisMonth, lastMonth, err5 := model.CalculateThisMonthAndLastMonthPaymentTotal(col)

	if err5 != nil {
		return say.Success(c, 10000, data)
	}

	data.ThisMonth = thisMonth
	data.LastMonth = lastMonth

	return say.Success(c, 0, data)
}

func AgentLogin(c echo.Context) error {
	body := &validator.LoginBody{}
	err := c.Bind(body)
	data := response.AgentLoginResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.Username == "" || body.PassWord == "" || body.T == "" || body.Code == "" {
		return say.Success(c, 10001, data)
	}

	username := body.Username
	password := body.PassWord
	t := body.T
	code := body.Code

	red := dbhelper.GetRedisDb()

	if !conf.ISTEST {
		key := libs.AdminLoginCode(t)
		savecdoe, err := red.Get(key).Result()
		if err != nil {
			return say.Success(c, 10000, data)
		}
		if !strings.EqualFold(strings.ToLower(savecdoe), strings.ToLower(code)) {
			return say.Success(c, 10002, data)
		}
		red.Del(key)
	}

	col := dbhelper.GetMongoCollection("agent")

	user, e := model.GetGameAgentByUserName(col, username)

	if e != nil {
		return say.Success(c, 10004, data)
	}

	if user.Disable != 0 {
		return say.Success(c, 10034, data)
	}

	if user.DelFlag != 0 {
		return say.Success(c, 10035, data)
	}

	salt := user.Salt
	pwd := user.PassWord
	uname, err := libs.DecryptWithFixedSalt(password, conf.ObtenationIterations, pwd, salt)
	if err != nil {
		return say.Success(c, 10005, data)
	}
	if uname != username {
		return say.Success(c, 10005, data)
	}

	//TODO:登录成功修改 登录时间
	ip := echo.ExtractIPFromXFFHeader()(c.Request())
	model.UpdateGameAgent(col, user.ID, ip, time.Now().Format("2006-01-02 15:04:05"))

	data.User = user
	//TODO:设置jwt
	token := libs.GenString(32)
	k := libs.AdminTokenKey(user.ID)
	red.Set(k, token, 0)
	mykey := fmt.Sprintf("%s-%s", conf.APPNAME, conf.APPVERSION)
	myjwt := libs.JWTEncrypt(user.ID, token, mykey)

	data.Jwt = myjwt
	return say.Success(c, 0, data)
}

func GetAgentHome(c echo.Context) error {
	body := &validator.AgentHomeBody{}
	err := c.Bind(body)
	data := response.AgentHomeResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	agent_id := body.AgentID

	if agent_id == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("user")

	count, err1 := model.GetAgentChildCount(collection, agent_id)

	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	data.UserTotal = count

	col1 := dbhelper.GetMongoCollection("recharge_order")

	recharge_total, err2 := model.GetAgentChildRechargeToTal(col1, agent_id)
	if err2 != nil {
		return say.Success(c, 10000, data)
	}
	data.RechargeTotal = int64(recharge_total)

	col2 := dbhelper.GetMongoCollection("withdraw")

	withdrawn_total, err3 := model.GetWithdrawToTalByUid(col2, agent_id)
	if err3 != nil {
		return say.Success(c, 10000, data)
	}
	data.WithdrawTotal = withdrawn_total

	col4 := dbhelper.GetMongoCollection("agent")

	agent, err4 := model.GetAgent(col4, agent_id)

	if err4 != nil {
		return say.Success(c, 10000, data)
	}

	data.NotWithdrawTotal = agent.Money

	this_month_withdraw, last_month_withdraw, err4 := model.CalculateThisMonthAndLastMonthAgentWithdrawPaymentTotal(col2, agent_id)
	if err4 != nil {
		return say.Success(c, 10000, data)
	}
	data.ThisMonthWithdraw = this_month_withdraw
	data.LastMonthWithdraw = last_month_withdraw

	col3 := dbhelper.GetMongoCollection("order_rebate_log")

	this_month_recharge, last_month_recharge, err4 := model.CalculateThisMonthAndLastMonthAgentChildPaymentTotal(col3, agent_id)
	if err4 != nil {
		return say.Success(c, 10000, data)
	}
	data.ThisMonthRecharge = this_month_recharge
	data.LastMonthRecharge = last_month_recharge

	return say.Success(c, 0, data)
}

func GetAgentShareUrl(c echo.Context) error {
	body := &validator.AgentHomeBody{}
	err := c.Bind(body)
	data := response.AgentUrlResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	agent_id := body.AgentID
	if agent_id == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("agent_url")

	res, err1 := model.GetAgentUrlByAgengId(collection, agent_id)
	color.Yellow("res = %+v", res)
	// color.Yellow("err1 = ", err1)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	id := res.ID
	if res.ID != "" {
		ex := res.ExpireTime
		timestamp := time.Now().Unix()
		if ex > int(timestamp) {
			url := res.Url
			data.Url = url
		}
	}

	red := dbhelper.GetRedisDb()

	k := libs.GetAccessTokenKey()

	token, _ := red.Get(k).Result()
	// color.Yellow("red token  = %s", token)
	if token == "" {
		access_token, err1 := api.GetAccessToken("wx1b9547fef3f6f477", "a4f794bf4177b6abc573ed692dc249b7")
		// color.Yellow("access_token  = %s", access_token)

		if err1 != nil {
			return say.Success(c, 10000, data)
		}

		err2 := red.Set(k, access_token, 3600*time.Second).Err()
		// color.Yellow("GetAccessToken err2 = ", err2)
		if err2 != nil {
			return say.Success(c, 10000, data)
		}
		token = access_token
	}
	reqBody := api.Req{
		Path:           "",
		Query:          fmt.Sprintf("parent_id=%s", agent_id),
		ExpireType:     1,
		ExpireInterval: 30,
		EnvVersion:     "release",
	}

	// color.Yellow("GetAccessToken reqBody = %+v", reqBody)
	// color.Yellow("token  = %s", token)
	// color.Yellow("reqBody  = %+v", reqBody)
	result, err3 := api.GetShareUrl(token, reqBody)
	// color.Yellow("GetAccessToken err3 = ", err3)
	if err3 != nil {
		return say.Success(c, 10000, data)
	}

	color.Blue("result = %+v", result)

	if result.Errcode != 0 {
		return say.Success(c, 10000, data)
	}

	url := result.URLLink

	if id == "" {
		id = libs.GenId()
	}

	timestamp := time.Now().Unix()
	ex := timestamp + 30*86400
	err4 := model.UpdateAgentUrl(collection, id, agent_id, url, int(ex))
	if err4 != nil {
		return say.Success(c, 10000, data)
	}

	data.Url = url

	return say.Success(c, 0, data)
}

func List(c echo.Context) error {
	body := &validator.MemberListBody{}
	err := c.Bind(body)
	data := response.GameUserListResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	collection := dbhelper.GetMongoCollection("user")

	offset := (page - 1) * limit

	members, count, err := model.GetGameUserList(collection, body.UID, offset, limit)

	if err != nil {
		return say.Success(c, 10001, data)
	}

	red := dbhelper.GetRedisDb()

	mymap := make(map[int]int)

	for _, v := range members {
		k := fmt.Sprintf("%s:invite:num:%d", conf.APPNAME, v.UID)
		num, _ := red.Get(k).Result()
		c, _ := strconv.Atoi(num)
		mymap[v.UID] = c
	}

	data.Page = page
	data.Limit = limit
	data.List = members
	data.Referrer = mymap
	data.Total = count
	return say.Success(c, 0, data)
}

func GetAgentList(c echo.Context) error {
	body := &validator.ReqAgentListBody{}
	err := c.Bind(body)
	data := response.GameAgentListResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	collection := dbhelper.GetMongoCollection("agent")

	offset := (page - 1) * limit

	members, count, err := model.GetGameAgentList(collection, body.ID, body.UserName, offset, limit)
	color.Red(" GetGameAgentList err = %v ", err)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.Page = page
	data.Limit = limit
	data.List = members
	data.Total = count
	return say.Success(c, 0, data)
}

func CheckAgentUserName(c echo.Context) error {
	data := response.NoneResponse{}
	body := &validator.CheckUserNameBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	id := c.QueryParam("id")
	if id == "" || body.UserName == "" {
		return say.Success(c, 10001, data)
	}
	username := body.UserName
	collection := dbhelper.GetMongoCollection("agent")
	user, err := model.GetGameAgentByUserName(collection, username)
	if err != nil || user.ID != "" {
		return say.Success(c, 10013, data)
	}
	return say.Success(c, 0, data)
}

func AddAgent(c echo.Context) error {
	body := &validator.SetAgentBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.UserName == "" || body.PassWord == "" || body.SecondPassWord == "" {
		return say.Success(c, 10001, data)
	}
	username := body.UserName

	password := body.PassWord

	collection := dbhelper.GetMongoCollection("agent")
	agent, err1 := model.GetGameAgentByUserName(collection, username)

	if err1 != nil {
		return say.Success(c, 10001, data)
	}

	if agent.ID != "" {
		return say.Success(c, 10013, data)
	}

	salt := libs.GenString(8)

	pwd, err := libs.EncryptWithFixedSalt(password, conf.ObtenationIterations, username, salt)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	a_doc := model.GameAgent{
		ID:         libs.GenId(),
		UserName:   username,
		Money:      0,
		PassWord:   pwd,
		Salt:       salt,
		RealName:   body.RealName,
		LoginTime:  "",
		LoginIp:    "",
		Disable:    0,
		DelFlag:    0,
		Created_at: time.Now().Format("2006-01-02 15:04:05"),
		Updated_at: "",
		Deleted_at: "",
	}
	err2 := model.AddGameAgent(collection, a_doc)
	if err2 != nil {
		return say.Success(c, 10027, data)
	}
	return say.Success(c, 0, data)
}

func UpdateAgent(c echo.Context) error {
	body := &validator.UpdateAgentBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.AgentID == "" || body.UserName == "" || body.PassWord == "" || body.SecondPassWord == "" {
		return say.Success(c, 10001, data)
	}

	agent_id := body.AgentID

	username := body.UserName

	password := body.PassWord

	collection := dbhelper.GetMongoCollection("agent")
	agent, err1 := model.GetAgent(collection, agent_id)

	if err1 != nil {
		return say.Success(c, 10001, data)
	}

	if agent.ID == "" {
		return say.Success(c, 10030, data)
	}

	salt := libs.GenString(8)

	pwd, err := libs.EncryptWithFixedSalt(password, conf.ObtenationIterations, username, salt)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	err2 := model.UpdatePwdGameAgent(collection, agent_id, pwd, salt, time.Now().Format("2006-01-02 15:04:05"))
	if err2 != nil {
		return say.Success(c, 10023, data)
	}
	return say.Success(c, 0, data)
}

//删除代理
func DelAgent(c echo.Context) error {
	body := &validator.DelAgentBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.AgentID == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("agent")

	agent, err := model.GetAgent(collection, body.AgentID)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if agent.ID == "" {
		return say.Success(c, 10028, data)
	}

	err1 := model.DelGameAgent(collection, agent.ID, time.Now().Format("2006-01-02 15:04:05"))

	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func GetAgentInfo(c echo.Context) error {
	body := &validator.GetAgentByAdminIDBody{}
	err := c.Bind(body)
	data := response.AdminAgentResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	db := dbhelper.GetMySqlDB()
	agent, err := model.GetAgentByAdminId(db, body.AdminId)
	if err != nil {
		return say.Success(c, 10030, data)
	}
	data.Agent = agent
	return say.Success(c, 0, data)
}

func Freeze(c echo.Context) error {
	body := &validator.ReqFreezeBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}

	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.UID <= 0 || body.FreezeReason == "" || body.FreezeDate == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("user")

	err1 := model.SetAccountStatus(collection, body.UID, 1, body.FreezeReason, body.FreezeDate)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func UnFreeze(c echo.Context) error {
	body := &validator.UidBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.UID <= 0 {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("user")

	err1 := model.SetAccountStatus(collection, body.UID, 0, "", "")
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func FreezeAgent(c echo.Context) error {
	body := &validator.ReqFreezeAgentBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}

	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.AgentID == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("agent")

	err1 := model.SetAgentFreezeStatus(collection, body.AgentID, 1)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func UnFreezeAgent(c echo.Context) error {
	body := &validator.ReqFreezeAgentBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.AgentID == "" {
		return say.Success(c, 10001, data)
	}

	collection := dbhelper.GetMongoCollection("agent")

	err1 := model.SetAgentFreezeStatus(collection, body.AgentID, 0)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func GetCodeList(c echo.Context) error {
	id := c.QueryParam("id")

	data := response.GameCodeListResponse{}
	if id == "" {
		return say.Success(c, 10001, data)
	}
	body := &validator.PageLimitBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	page := body.Page
	if page <= 0 {
		page = 1
	}
	limit := body.Limit

	if limit <= 0 {
		limit = 10
	}
	collection := dbhelper.GetMongoCollection("game_code")

	offset := (page - 1) * limit

	codes, total, err := model.GetGameCodeList(collection, offset, limit)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	data.Total = total
	data.List = codes
	return say.Success(c, 0, data)
}

func AddCode(c echo.Context) error {

	data := response.NoneResponse{}
	body := &validator.GameCodeBody{}
	err := c.Bind(body)
	color.Red("bind err = %v", err)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.Code == "" || len(body.Items) <= 0 {
		return say.Success(c, 10001, data)
	}

	if body.ExpireType == "2" {
		if body.StartExpire == "" || body.EndExpire == "" {
			return say.Success(c, 10001, data)
		}
	}
	expire_type, _ := strconv.Atoi(body.ExpireType)
	doc := model.GameCode{
		Code:        body.Code,
		Total:       body.Total,
		Num:         0,
		Vip:         body.Vip,
		Items:       body.Items,
		ExpireType:  expire_type,
		StartExpire: body.StartExpire,
		EndExpire:   body.EndExpire,
		Status:      body.Status,
	}

	collection := dbhelper.GetMongoCollection("game_code")

	err1 := model.AddGameCode(collection, doc)
	color.Red("bind err1 = %v", err1)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func UpdateCode(c echo.Context) error {
	data := response.NoneResponse{}
	body := &validator.GameCodeBody{}
	err := c.Bind(body)
	color.Red("bind err = %v", err)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.Code == "" || len(body.Items) <= 0 {
		return say.Success(c, 10001, data)
	}

	if body.ExpireType == "2" {
		if body.StartExpire == "" || body.EndExpire == "" {
			return say.Success(c, 10001, data)
		}
	}
	expire_type, _ := strconv.Atoi(body.ExpireType)
	doc := model.GameCode{
		Code:        body.Code,
		Total:       body.Total,
		Num:         0,
		Vip:         body.Vip,
		Items:       body.Items,
		ExpireType:  expire_type,
		StartExpire: body.StartExpire,
		EndExpire:   body.EndExpire,
		Status:      body.Status,
	}

	collection := dbhelper.GetMongoCollection("game_code")

	err1 := model.UpdateGameCode(collection, doc)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func ChangeStatus(c echo.Context) error {
	data := response.NoneResponse{}
	body := &validator.ChangeStatusBody{}
	err := c.Bind(body)
	color.Red("bind err = %v", err)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.Code == "" {
		return say.Success(c, 10001, data)
	}
	collection := dbhelper.GetMongoCollection("game_code")

	err1 := model.UpdateGameCodeStatus(collection, body.Code, body.Status)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func DelCode(c echo.Context) error {
	data := response.NoneResponse{}
	body := &validator.ChangeStatusBody{}
	err := c.Bind(body)

	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.Code == "" {
		return say.Success(c, 10001, data)
	}
	collection := dbhelper.GetMongoCollection("game_code")

	err1 := model.DelGameCode(collection, body.Code)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func GetServerList(c echo.Context) error {

	data := response.GameServerListResponse{}
	body := &validator.GetServerListBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	page := body.Page
	if page <= 0 {
		page = 1
	}
	limit := body.Limit

	if limit <= 0 {
		limit = 10
	}

	col := dbhelper.GetMongoCollection("game_server")

	offset := (page - 1) * limit

	servers, total, err := model.GetGameServerList(col, offset, limit)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	ids := []int{}
	for _, v := range servers {
		ids = append(ids, int(v.ID))
	}

	col1 := dbhelper.GetMongoCollection("user")

	result, err1 := model.CountGameUsersByRegionIDsAndTimeRange(col1, ids, body.StartTime, body.EndTime)

	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	result2, err2 := model.CountGameOnlineUsersByRegionIDs(col1, ids)

	if err2 != nil {
		return say.Success(c, 10000, data)
	}

	resp := []model.RespGameServer{}

	for _, v := range servers {
		res := model.RespGameServer{
			ID:          v.ID,
			ServerName:  v.ServerName,
			Status:      v.Status,
			UserCount:   int64(result[int(v.ID)]),
			OnlineCount: int64(result2[int(v.ID)]),
		}
		resp = append(resp, res)
	}

	data.List = resp
	data.Total = total
	data.Page = page
	data.Limit = limit
	return say.Success(c, 0, data)
}

func AddServer(c echo.Context) error {

	data := response.NoneResponse{}
	body := &validator.AddServerBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.ServerName == "" {
		return say.Success(c, 10001, data)
	}
	col1 := dbhelper.GetMongoCollection("inc_id")
	id, err := model.GetId(col1, "server", 1)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	doc := model.GameServer{
		ID:         id,
		ServerName: body.ServerName,
		Status:     0,
	}

	col2 := dbhelper.GetMongoCollection("game_server")

	err1 := model.AddGameServer(col2, doc)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func GetServerItemList(c echo.Context) error {

	data := response.ServerItemListResponse{}
	body := &validator.ServerItemPageLimitBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.ServerId == 0 {
		return say.Success(c, 10001, data)
	}

	page := body.Page
	if page <= 0 {
		page = 1
	}
	limit := body.Limit

	if limit <= 0 {
		limit = 10
	}

	col := dbhelper.GetMongoCollection("server_item")

	offset := (page - 1) * limit

	servers, total, err := model.GetServerItemList(col, body.ServerId, offset, limit)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	col1 := dbhelper.GetMongoCollection("user")

	ids := []int{}
	for _, v := range servers {
		ids = append(ids, int(v.ID))
	}

	result1, err1 := model.CountGameUsersByServerIDsAndTimeRange(col1, ids, body.StartTime, body.EndTime)

	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	result2, err2 := model.CountGameOnlineUsersByServerIDs(col1, ids)

	if err2 != nil {
		return say.Success(c, 10000, data)
	}

	resp := []model.RespServerItem{}

	for _, v := range servers {
		res := model.RespServerItem{
			ID:              v.ID,
			ServerId:        v.ServerId,
			Status:          v.Status,
			UserCount:       int64(result1[int(v.ID)]),
			OnlineCount:     int64(result2[int(v.ID)]),
			ActivityId:      v.ActivityId,
			ActivityEndTime: v.ActivityEndTime,
			CreatedAt:       v.CreatedAt,
		}
		resp = append(resp, res)
	}

	data.List = resp
	data.Total = total
	data.Page = page
	data.Limit = limit
	return say.Success(c, 0, data)
}

func OpenServer(c echo.Context) error {
	data := response.NoneResponse{}
	body := &validator.OpenServerBody{}
	err := c.Bind(body)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	if body.ServerId == 0 || body.ServerNum == 0 {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("server_item")

	total, err := model.GetServerItemCount(col, int64(body.ServerId))
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if total+int64(body.ServerNum) > 100 {

		return say.Success(c, 10001, data)

	}

	err1 := model.UpdateServer(col)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	now := time.Now()
	created_at := now.Format("2006-01-02 15:04:05")

	col1 := dbhelper.GetMongoCollection("inc_id")
	var docs []interface{}
	for i := 0; i < body.ServerNum; i++ {
		id, err := model.GetId(col1, "server_id", 1)
		if err != nil {
			return say.Success(c, 10000, data)
		}
		docs = append(docs, model.ServerItem{ID: id, ServerId: int64(body.ServerId), Status: 1, ActivityId: int64(body.ActivityId), ActivityEndTime: body.ActivityEndTime, CreatedAt: created_at})
	}

	err2 := model.AddServer(col, docs)
	if err2 != nil {
		return say.Success(c, 10000, data)
	}
	return say.Success(c, 0, data)
}

func OnlineUser(c echo.Context) error {
	data := response.OnlineUsersResponse{}

	collection := dbhelper.GetMongoCollection("user")

	count, err := model.GetOnlineUserCount(collection)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.Count = count
	return say.Success(c, 0, data)
}

func GetAgentChild(c echo.Context) error {
	body := &validator.AgentChildListBody{}
	err := c.Bind(body)
	data := response.GameUserListResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.AgentID == "" {
		return say.Success(c, 10001, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	collection := dbhelper.GetMongoCollection("user")

	offset := (page - 1) * limit
	members, count, err := model.GetAgentChildList(collection, body.AgentID, offset, limit)
	color.Yellow("member %v=", members)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.Page = page
	data.Limit = limit
	data.List = members
	data.Total = count
	return say.Success(c, 0, data)
}

func GetRebateLog(c echo.Context) error {
	body := &validator.GetRebateBody{}
	err := c.Bind(body)
	data := response.AgentRebateLogResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.AgentID == "" {
		return say.Success(c, 10001, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	collection := dbhelper.GetMongoCollection("order_rebate_log")

	offset := (page - 1) * limit
	logs, count, err := model.GetRebateLogList(collection, body.AgentID, body.UID, body.OrderNo, body.CreatedAtStart, body.CreatedAtEnd, offset, limit)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.Page = page
	data.Limit = limit
	data.List = logs
	data.Total = count
	return say.Success(c, 0, data)
}

func GetWithdrawLog(c echo.Context) error {
	body := &validator.AgentChildListBody{}
	err := c.Bind(body)
	data := response.AgentWithdrawLogResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	collection := dbhelper.GetMongoCollection("withdraw")

	offset := (page - 1) * limit
	logs, count, err := model.GetWithdrawLogList(collection, body.AgentID, offset, limit)
	color.Red("GetWithdrawLogList err = %v", err)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.Page = page
	data.Limit = limit
	data.List = logs
	data.Total = count
	return say.Success(c, 0, data)
}

//提现
func DoWithdraw(c echo.Context) error {
	body := &validator.AgentWithdrawBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.AgentID == "" || body.Money <= 0 || body.Content == "" {
		return say.Success(c, 10001, data)
	}
	col := dbhelper.GetMongoCollection("agent")

	user, err := model.GetAgent(col, body.AgentID)

	if err != nil {
		return say.Success(c, 10000, data)
	}

	if user.Type == 0 || user.Account == "" {
		return say.Success(c, 10037, data)
	}

	if user.Money < body.Money {

		return say.Success(c, 10031, data)
	}

	collection := dbhelper.GetMongoCollection("withdraw")

	doc := model.Withdraw{
		ID:        primitive.NewObjectID(),
		Money:     body.Money,
		Uid:       body.AgentID,
		Status:    0,
		Content:   body.Content,
		Type:      user.Type,
		Account:   user.Account,
		CreatedAt: time.Now().Format("2006-01-02 15:04:05"),
	}

	err1 := model.DoWithdraw(collection, doc)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	err2 := model.DecrMoney(col, body.AgentID, -body.Money)

	// color.Red("err2 = %v", err2)
	if err2 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func DoWithdrawStatus(c echo.Context) error {
	body := &validator.WithdrawStatusBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10000, data)
	}

	if body.ID == "" || body.Status <= 0 || body.Taxes == "" {
		return say.Success(c, 10001, data)
	}

	id, err := primitive.ObjectIDFromHex(body.ID)
	if err != nil {
		return say.Success(c, 10000, data)
	}

	collection := dbhelper.GetMongoCollection("withdraw")

	result, e1 := model.GetWithdrawById(collection, id)

	if e1 != nil {
		return say.Success(c, 10000, data)
	}

	if result.ID.String() == "" {
		return say.Success(c, 10032, data)
	}

	if result.Status > 0 {
		return say.Success(c, 10033, data)
	}

	if body.Status == 1 {

	} else {
		col := dbhelper.GetMongoCollection("agent")
		err1 := model.DecrMoney(col, result.Uid, result.Money)
		if err1 != nil {
			return say.Success(c, 10000, data)
		}
	}
	err1 := model.DoWithdrawStatus(collection, id, body.Status, body.Taxes)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func GetRechargeList(c echo.Context) error {
	body := &validator.RechargeListBody{}
	err := c.Bind(body)
	data := response.RechargeListResponse{}

	if err != nil {
		return say.Success(c, 10000, data)
	}

	page := body.Page
	if page == 0 {
		page = 1
	}
	limit := body.Limit

	if limit == 0 {
		limit = 20
	}

	offset := (page - 1) * limit

	col := dbhelper.GetMongoCollection("recharge_order")
	lists, count, err := model.GetRechargeList(col, limit, offset, body.OrderNo, body.UID, body.RegionId, body.ServerId, body.PayStatus, body.PayAtStart, body.PayAtEnd, body.CreatedAtStart, body.CreatedAtEnd)

	if err != nil {
		return say.Success(c, 10000, data)
	}
	data.Page = page
	data.Limit = limit
	data.List = lists
	data.Total = count
	return say.Success(c, 0, data)
}

func GetActivityList(c echo.Context) error {
	data := response.ActivityListResponse{}
	col := dbhelper.GetMongoCollection("activity_config")
	lists, err := model.GetActivityList(col)

	if err != nil {
		return say.Success(c, 10000, data)
	}
	data.List = lists
	return say.Success(c, 0, data)
}

func UpdateActivity(c echo.Context) error {
	body := &validator.ActivityReqBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	color.Red("err = %v", err)
	if err != nil {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("activity_config")
	err1 := model.UpdateActivity(col, body.ID, body.Status, body.StartTime, body.EndTime)
	color.Red("err1 = %v", err1)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func GetMailList(c echo.Context) error {
	body := &validator.PageLimitBody{}
	err := c.Bind(body)
	data := response.MailListResponse{}
	color.Red("err = %v", err)
	if err != nil {
		return say.Success(c, 10001, data)
	}

	page := body.Page
	if page <= 0 {
		page = 1
	}
	limit := body.Limit

	if limit <= 0 {
		limit = 10
	}

	offset := (page - 1) * limit
	col := dbhelper.GetMongoCollection("mail")
	result, count, err1 := model.GetMailList(col, offset, limit)

	if err1 != nil {
		return say.Success(c, 10000, data)
	}
	data.Limit = limit
	data.Page = page
	data.List = result
	data.Total = count
	return say.Success(c, 0, data)
}

func SendMail(c echo.Context) error {
	body := &validator.SendMailReqBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	libs.PutQueue(map[string]interface{}{"type": "admin", "data": body})
	return say.Success(c, 0, data)
}

func SaveBili(c echo.Context) error {
	body := &validator.ReqSaveBiliBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	red := dbhelper.GetRedisDb()
	k := libs.GetAgentBiliKey()
	red.Set(k, body.Bili, 0)
	return say.Success(c, 0, data)
}

func GetBili(c echo.Context) error {
	data := response.GetBiliResponse{}

	red := dbhelper.GetRedisDb()
	k := libs.GetAgentBiliKey()
	bili, err := red.Get(k).Result()
	if err != nil {
		return say.Success(c, 10000, data)
	}
	bl, err := strconv.ParseFloat(bili, 64)
	if err != nil {
		return say.Success(c, 10000, data)
	}
	data.Bili = bl
	return say.Success(c, 0, data)
}

func GetMyTiXianList(c echo.Context) error {
	body := &validator.GetTiXianListBody{}
	err := c.Bind(body)
	data := response.GameTixianListResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	// if body.AgentID == "" {
	// 	return say.Success(c, 10001, data)
	// }
	col := dbhelper.GetMongoCollection("game_tixian")
	result, count, err := model.GetGameTiXianList(col, body.AgentID)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.List = result
	data.Total = count
	return say.Success(c, 0, data)
}

func GetAllTiXianList(c echo.Context) error {
	body := &validator.GetTiXianListBody{}
	err := c.Bind(body)
	data := response.GameTixianListResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("game_tixian")
	result, count, err := model.GetGameTiXianList(col, body.AgentID)
	if err != nil {
		return say.Success(c, 10001, data)
	}
	data.List = result
	data.Total = count
	return say.Success(c, 0, data)
}

func ApplyTixian(c echo.Context) error {
	body := &validator.ApplyTiXianListBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	if body.AgentID == "" || body.Type <= 0 || body.Account == "" {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("game_tixian")

	doc := model.GameTiXian{
		ID:         libs.GenId(),
		AgentID:    body.AgentID,
		Type:       body.Type,
		Account:    body.Account,
		Status:     0,
		Created_at: time.Now().Format("2006-01-02 15:04:05"),
	}

	err1 := model.AddGameTixian(col, doc)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func UpdateApplyTixian(c echo.Context) error {
	body := &validator.UpdateApplyTiXianListBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	if body.ID == "" || body.AgentID == "" || body.Type <= 0 || body.Account == "" {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("game_tixian")

	doc := model.GameTiXian{
		Type:       body.Type,
		Account:    body.Account,
		Status:     0,
		Updated_at: time.Now().Format("2006-01-02 15:04:05"),
	}

	err1 := model.UpdateGameTixian(col, body.ID, doc)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	return say.Success(c, 0, data)
}

func AgreeTixian(c echo.Context) error {
	body := &validator.AgreeTiXianListBody{}
	err := c.Bind(body)
	data := response.NoneResponse{}
	if err != nil {
		return say.Success(c, 10001, data)
	}

	if body.ID == "" {
		return say.Success(c, 10001, data)
	}

	col := dbhelper.GetMongoCollection("game_tixian")

	result, err1 := model.GetGameTixianByID(col, body.ID)
	if err1 != nil {
		return say.Success(c, 10000, data)
	}

	// color.Blue("result  = %+v", result)
	if result.ID == "" {
		return say.Success(c, 10001, data)
	}

	if result.Status > 0 {
		return say.Success(c, 10036, data)
	}

	err2 := model.AgreeGameTixian(col, result.ID, body.Status, time.Now().Format("2006-01-02 15:04:05"))
	if err2 != nil {
		return say.Success(c, 10000, data)
	}

	if body.Status == 1 {
		col1 := dbhelper.GetMongoCollection("agent")

		err3 := model.UpdateAccount(col1, result.AgentID, int(result.Type), result.Account)
		if err3 != nil {
			return say.Success(c, 10000, data)
		}
	}

	return say.Success(c, 0, data)
}