package internal

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	mqtt "github.com/eclipse/paho.mqtt.golang"
	"github.com/gogf/gf/v2/encoding/gcharset"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"go.mongodb.org/mongo-driver/bson"
	"net/url"
	"strings"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/consts"
	"tyj_admin/internal/model/entity"
)

func GetMails(ctx context.Context, req *game.MailsSearchReq) (res *game.MailsSearchRes, err error) {
	res = new(game.MailsSearchRes)
	filter := bson.M{}
	if len(req.Uid) > 0 {
		filter["to"] = req.Uid
	}
	if len(req.ServerId) > 0 {
		filter["serverId"] = bson.M{"$elemMatch": bson.M{"$eq": req.ServerId}}
	}
	if req.LowTime >= 0 && req.UpperTime > req.LowTime {
		filter["c_date"] = bson.M{"$lte": req.UpperTime}
	}
	res.Total, err = MongoDatabaseList["0"].Collection("MailLog").Find(ctx, filter).Count()
	if req.PageSize == 0 {
		req.PageSize = 10
	}
	if req.PageNum == 0 {
		req.PageNum = 1
	}
	//g.Log().Info(ctx, " mailLog filter", filter)
	err = MongoDatabaseList["0"].Collection("MailLog").Find(ctx, filter).Sort("-c_date").Skip((req.PageNum - 1) * req.PageSize).Limit(req.PageSize).All(&res.Mails)
	return
}

func GetCornMails(ctx context.Context, send int32) (mailList []entity.Mail, err error) {
	filter := bson.M{}
	filter["send"] = send
	mailList = []entity.Mail{}
	err = MongoDatabaseList["0"].Collection("MailLog").Find(ctx, filter).All(&mailList)
	return
}

func AddMail(ctx context.Context, mail entity.Mail) (err error) {
	ss, err := MongoDatabaseList["0"].Collection("MailLog").InsertOne(ctx, mail)
	fmt.Println("ss %v", ss)
	return
}

func UpdateMail(ctx context.Context, mail entity.Mail, errData string) (err error) {
	err = MongoDatabaseList["0"].Collection("MailLog").UpdateOne(ctx, bson.M{"_id": mail.Id}, bson.M{"$set": bson.M{"send": mail.Send, "errData": errData}})
	return
}

func DelMail(ctx context.Context, mail entity.Mail) (err error) {
	err = MongoDatabaseList["0"].Collection("MailLog").UpdateOne(ctx, bson.M{"_id": mail.Id}, bson.M{"$set": bson.M{"send": consts.Mail_Send_Delete}})
	return
}

type MailBody struct {
	entity.Mail
	ModuleType string `json:"moduleType"`
}

type MqttMail struct {
	ReqId    int64    `json:"reqId"`
	ModuleId string   `json:"moduleId"`
	Body     MailBody `json:"body"`
}

type HttpMail struct {
	Items    string `json:"items"`
	ValidDay string `json:"validDay"`
	//Greetings string `json:"Greetings"`
	From    string `json:"from"`
	Title   string `json:"title"`
	NewGet  string `json:"newGet"`
	Context string `json:"context"`
	To      string `json:"to"`
	IsAll   string `json:"isAll"`
	OwnerId string `json:"ownerId"`
}

func SendMqtt(msg interface{}, c chan bool, server string) {
	closeC := false
	registerFunc := func(client mqtt.Client, qtmsg mqtt.Message) {
		ss := string(qtmsg.Payload())
		fmt.Println(ss)
		err := ClientSend("client", 0, false, msg)
		if err != nil {
			c <- false
		}
		//ClientSend("client", 0, false, `{"reqId":3,"moduleId":"webadmin","body":{"uids":"lq0001","gm":1,"moduleType":"changeGM"}}`)
	}

	callback := func(client mqtt.Client, qtmsg mqtt.Message) {
		if closeC {
			return
		}
		res := &MqttResult{}
		client.Disconnect(1)
		ss := string(qtmsg.Payload())
		ss = ss[1 : len(ss)-1]
		ss = strings.Replace(ss, "\\", "", -1)
		err := json.Unmarshal([]byte(ss), res)
		closeC = true
		if err == nil && res.RespId == 1 {
			c <- true
			return
		}
		fmt.Println("error" + err.Error())
		c <- false
	}
	if NewMqttClient(registerFunc, callback, server) != nil {
		c <- false
	}

}

type MqttResult struct {
	RespId int         `json:"respId"`
	Error  interface{} `json:"error"`
}

//func Mailcallback(c mqtt.Client, msg mqtt.Message) {
//	res := &MqttResult{}
//	c.Disconnect(1)
//	fmt.Println(string(msg.Payload()))
//	ss := string(msg.Payload())
//	ss = ss[1 : len(ss)-1]
//	ss = strings.Replace(ss, "\\", "", -1)
//	fmt.Println(ss)
//	err := json.Unmarshal([]byte(ss), res)
//	if err == nil && res.RespId == 1 {
//		ch <- true
//		return
//	}
//	fmt.Println("error" + err.Error())
//	ch <- false
//
//}
//
//func RegisterCallback(c mqtt.Client, msg mqtt.Message) {
//	ss := string(Payload.([]byte))
//	fmt.Println(ss)
//	err := ClientSend("client", 0, false, ss)
//	if err != nil {
//		ch <- false
//	}
//	//ClientSend("client", 0, false, `{"reqId":3,"moduleId":"webadmin","body":{"uids":"lq0001","gm":1,"moduleType":"changeGM"}}`)
//
//}

func SendMailToC(ctx context.Context, req *game.MailSendReq) (res *game.MailSendRes, err error) {
	res = new(game.MailSendRes)
	items := ""
	for _, v := range req.Drops {
		if items != "" {
			items += "|"
		}
		items += fmt.Sprint(v.Id) + "|" + fmt.Sprint(v.Num)
	}
	if req.Expired == 1 {
		if req.ValidDay == 0 {
			req.ValidDay = 30
		}
	} else {
		req.ValidDay = 0
		req.IsLongTerm = 1
	}
	srcCharset := "UTF-8"
	g.Client().SetHeader("Content-Type", "application/json;charset=UTF-8")
	errdata := ""
	owners := strings.Split(req.OwnerId, ";")
	owner := ""
	if req.OwnerId != "" {
		for _, v := range owners {
			uid, _ := GetStringIdToUid(ctx, v)
			if uid == "" {
				errdata += "uid:" + v + "不存在！"
				continue
			}
			if len(owner) > 0 {
				owner += ";"
			}
			owner += uid
		}
		if len(owner) == 0 {
			errdata += "uid不存在,发送失败！"
			return nil, errors.New(errdata)
		}
	}

	g.Log().Info(ctx, "sendMail - ServerConfig: ", gjson.MustEncodeString(ServerConfig))
	for _, v := range req.ServerId {
		ip := ServerConfig[v]
		//g.Log().Info(ctx, "sendMail - ServerConfig: ", v, gjson.MustEncodeString(ServerConfig))
		url := "http://" + ip + "/sendMail?items=" + items + "&validDay=" + fmt.Sprint(req.ValidDay) +
			"&from=" + url.QueryEscape(req.From) + "&title=" + url.QueryEscape(req.Title) + "&context=" + url.QueryEscape(req.Content) +
			"&newGet=" + fmt.Sprint(req.NewGet) + "&ownerId=" + owner + "&isLongTerm=" + fmt.Sprint(req.IsLongTerm)

		g.Log().Info(ctx, "sendMail - req: ", url, gjson.MustEncodeString(req))
		bytes := g.Client().GetBytes(ctx, url)
		src := string(bytes)
		if g.IsEmpty(src) {
			errdata += v + "-空回调，发送失败/n"
			continue
		}

		tmp, _ := gcharset.ToUTF8(srcCharset, src)
		json, err1 := gjson.DecodeToJson(tmp)
		if err1 != nil {
			errdata += v + "-" + err1.Error() + "/n"
			continue
		}
		if json.Get("Error").Int() != 200 {
			errdata += v + "-邮件发送失败/n"
			continue
		}
		errdata += v + "-邮件发送成功/n"
		g.Log().Info(ctx, "sendMail - req1: ", url, gjson.MustEncodeString(req))
	}

	g.Log().Info(ctx, "sendMail - errdata2: ", errdata)
	return nil, errors.New(errdata)
}

func GetMailModel(ctx context.Context, req *game.GetMailDropModelReq) (res *game.GetMailDropModelRes, err error) {
	name := ""
	switch req.MType {
	case 1:
		name = "mailDropModel"
		break
	case 2:
		name = "mailContentModel"
		break
	default:
		return
	}
	rdbTop := RedisDbList[0]
	rdbTop.Do(ctx, "select", 0)
	result := rdbTop.Get(ctx, name)
	res = new(game.GetMailDropModelRes)
	res.Model = result.Val()
	//json.Unmarshal()
	return
}

func UpdateMailModel(ctx context.Context, req *game.UpdateMailDropModelReq) (res *game.UpdateMailDropModelRes, err error) {
	name := ""
	switch req.MType {
	case 1:
		name = "mailDropModel"
		break
	case 2:
		name = "mailContentModel"
		break
	default:
		return
	}
	rdbTop := RedisDbList[0]
	rdbTop.Do(ctx, "select", 0)
	err = rdbTop.Set(ctx, name, req.Model, 0).Err()
	if err != nil {
		panic(err)
	}
	return
}