package statrecordmod

import (
	"fmt"
	"time"

	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/models"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var mdb *db.MongoDB

const table = models.StatRecord

func coll(t *db.MongoTool) *db.MongoTool {
	if t == nil {
		return mdb.Coll(table)
	}
	return t.Coll(table)
}

// initIndex 初始化索引
func initIndex() {
	many := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: "name", Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys:    bson.D{{Key: "job", Value: 1}, {Key: "item", Value: 1}},
			Options: options.Index().SetSparse(true).SetUnique(true),
		},
		{
			Keys: bson.D{{Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "updatedAt", Value: -1}},
		},
	}
	if _, err := coll(nil).CreateIndex(many); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

// ChangeStatTrans ChangeStatTrans
func UpsertOneTrans(trans *db.MongoTool, name string, recordTime time.Time) error {
	filter := bson.M{
		"name": name,
	}
	update := bson.M{
		"$set": bson.M{
			"recordTime": recordTime,
			"updatedAt":  time.Now(),
		},
		"$setOnInsert": bson.M{
			"name":            name,
			"fristRecordTime": recordTime,
			"createdAt":       time.Now(),
		},
	}
	if _, err := coll(trans).UpsertOne(filter, update); err != nil {
		log.Error("statrecordmod UpsertOneTrans error:%v\n", log.E(err))
		return err
	}
	return nil
}

type ItemRecordAt struct {
	Job        string
	Item       string
	RecordTime time.Time
}

func MergeName(job string, item string) string {
	return fmt.Sprintf("%s.%s", job, item)
}

func UpsertOneItemTrans(trans *db.MongoTool, job string, item string, recordTime time.Time) error {
	filter := bson.M{
		"job":  job,
		"item": item,
	}
	update := bson.M{
		"$set": bson.M{
			"recordTime": recordTime,
			"updatedAt":  time.Now(),
		},
		"$setOnInsert": bson.M{
			"name":            MergeName(job, item),
			"job":             job,
			"item":            item,
			"fristRecordTime": recordTime,
			"createdAt":       time.Now(),
		},
	}
	if _, err := coll(trans).UpsertOne(filter, update); err != nil {
		log.Error("statrecordmod UpsertOneItemTrans error:%v\n", log.E(err))
		return err
	}
	return nil
}

// FindOne FindOne
func findOneByName(Name string) (Record, error) {
	filter := bson.M{
		"name": Name,
	}
	doc := Record{}
	return doc, coll(nil).FindOne(&doc, filter)
}

// LastRecordTime 最后的记录时间，服务器的时区
func LastRecordTime(name string, defaultTime time.Time) (time.Time, error) {
	//获取上次记录时间
	doc, err := findOneByName(name)
	if err != nil {
		return time.Time{}, fmt.Errorf("LastRecordTime err:%+v\n", err)
	}
	//设定为服务器的时区
	var tim = defaultTime
	if !doc.RecordTime.IsZero() {
		tim = doc.RecordTime
	}
	//不依赖数据库 保证时间是服务器时间
	localTime := tim.In(time.Local)
	log.Debug("LastRecordTime local Info", log.Any("Local", time.Local), log.Any("time", tim), log.Any("returnTime", localTime))
	return localTime, nil
}

func FristRecordTimeByName(name string) (time.Time, error) {
	doc, err := findOneByName(name)
	if err != nil {
		return time.Time{}, fmt.Errorf("FristRecordTimeByName err:%+v\n", err)
	}
	return doc.FristRecordTime, nil
}

func findOneByJob(job string, item string) (Record, error) {
	filter := bson.M{
		"job":  job,
		"item": item,
	}
	doc := Record{}
	return doc, coll(nil).FindOne(&doc, filter)
}

func FristRecordTimeByJob(job string, item string) (time.Time, error) {
	doc, err := findOneByJob(job, item)
	if err != nil {
		return time.Time{}, fmt.Errorf("FristRecordTimeByName err:%+v\n", err)
	}
	return doc.FristRecordTime, nil
}

func findManyByJob(job string) ([]Record, error) {
	filter := bson.M{
		"job": job,
	}
	list := []Record{}
	return list, coll(nil).Find(&list, filter)
}

func LastRecordTimeMap(job string, defaultTimeMap map[string]time.Time) (map[string]time.Time, error) {
	list, err := findManyByJob(job)
	if err != nil {
		return nil, err
	}
	for _, v := range list {
		defaultTimeMap[v.Item] = v.RecordTime
	}
	return defaultTimeMap, nil
}

func DeleteStatRecordByName(name string) error {
	_, err := coll(nil).DeleteOne(bson.M{"name": name})
	return err
}