package mwacc

import (
	"context"
	"fmt"
	"hkdj-web-server/pub/common/errors"
	sErr "hkdj-web-server/pub/common/errors"
	"hkdj-web-server/pub/common/log"
	"hkdj-web-server/pub/common/srvdef"
	"hkdj-web-server/pub/mongos"
	"time"

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

// 过滤查询数量
func AccCountByFilter(ctx context.Context, filters primitive.M, opts ...*options.CountOptions) (c int64, err error) {
	c, err = mwAccColl.Count(ctx, filters)
	return
}

// 过滤查询账号
func FindOneAccByFilter(ctx context.Context, filters primitive.M, opts ...*options.FindOneOptions) (*MwAcc, error) {
	var res MwAcc
	err := mwAccColl.FindOne(ctx, &res, filters, opts...)
	if err != nil {
		log.Error("mwacc FindOneAccByFilter err", log.Any("filters", filters), log.E(err))
	}
	return &res, err
}

// 过滤更新
func UpOneAccByFilter(ctx context.Context, query primitive.M, update primitive.M) (err error) {
	_, err = mwAccColl.UpdateOne(ctx, query, primitive.M{"$set": update})
	return
}

// 过滤删除角色
func DelAccByFilter(ctx context.Context, filters primitive.M) (err error) {
	_, err = mwAccColl.DeleteOne(ctx, filters)
	if err != nil {
		log.Error("mwacc DelAccByFilter err", log.Any("filters", filters), log.E(err))
	}
	return
}

// // 更新最后登录时间
// func UpAccLastTimeById(ctx context.Context, id int64) (*mongo.UpdateResult, error) {
// 	ret, err := mwAccColl.UpdateOne(ctx, primitive.M{FN.MwAcc.Id: id}, primitive.M{"$set": primitive.M{FN.MwAcc.LastTime: time.Now()}})
// 	if err != nil {
// 		log.Error("mvacc UpLastTimeById err", log.Any(FN.MwAcc.Id, id), log.E(err))
// 	}
// 	return ret, err
// }

// 绑定二维码
func BindAccQurl(ctx context.Context, acc string) (ok bool, err error) {

	res, dataErr := FindOneAccByFilter(ctx, primitive.M{
		FN.MwAcc.Acc: acc,
	})

	if dataErr != nil || res.Id == 0 {
		err = sErr.MakeWithMsg(sErr.Logo, "用户不存在！")
		return false, err
	}

	if res.IsEnb == false {
		err = sErr.MakeWithMsg(sErr.UserPermission, "用户被禁用！")
		return false, err
	}
	err = UpOneAccByFilter(ctx, primitive.M{
		FN.MwAcc.Acc: acc,
	}, primitive.M{
		FN.MwAcc.IsBase32: true,
	})

	if err != nil {
		return false, err
	}
	return true, err
}

// 插入角色
func AccAdd(ctx context.Context, insertReq *AccInsertDoc) (id int64, ok bool, err error) {

	insertReq.Id = int64(mongos.Lid.MwAcc.Get())
	insertReq.CreatedAt = time.Now()

	_, err = mwAccColl.InsertOne(ctx, insertReq)
	if err != nil {
		log.ZapLog.Error(fmt.Sprintf("InsertRole mongo error %v", err))
		err = errors.MakeWithErr(errors.DBInsert, err)
		return 0, false, err
	}
	return insertReq.Id, true, nil
}

// 获取角色列表
func GetAccList(ctx context.Context, search primitive.M, sort []primitive.M) (
	total int64, data []*AccGetListRec, err error) {

	var countPipe []primitive.M
	countPipe = append(countPipe, search, bson.M{"$count": "total"})
	var aggCount AggStatCount
	err = mwAccColl.ObjectAggregate(ctx, &aggCount, countPipe)
	if err != nil {
		return 0, nil, err
	}
	total = aggCount.Total

	var pip []primitive.M
	pip = append(pip, search)
	pip = append(pip, sort...)
	pip = append(pip,
		primitive.M{
			"$lookup": primitive.M{
				"localField":   FN.MwAcc.RoleId,
				"from":         TN.MwRole,
				"foreignField": FN.MwRole.Id,
				"as":           "roles",
			},
		},
		primitive.M{"$unwind": primitive.M{
			"path":                       "$roles",
			"preserveNullAndEmptyArrays": true,
		},
		},
		primitive.M{
			"$project": primitive.M{
				FN.MwAcc.Id:       1,
				FN.MwAcc.UserName: 1,
				FN.MwAcc.Acc:      1,
				FN.MwAcc.Pwd:      1,
				FN.MwAcc.Email:    1,
				FN.MwAcc.RoleId:   1,
				FN.MwAcc.RoleName: "$roles.name",
				FN.MwAcc.Base32:   1,
				FN.MwAcc.IsBase32: 1,
				// mwacc.FN.MwAcc.LastTime:  1,
				FN.MwAcc.IsEnb:     1,
				FN.MwAcc.Feedback:  1,
				FN.MwAcc.CreatedAt: 1,
				FN.MwAcc.UpdatedAt: 1,
				FN.MwAcc.LimitIP:   1,
			},
		})

	err = mwAccColl.Aggregate(ctx, &data, pip)
	if err != nil {
		err = errors.MakeWithErr(errors.DBQuery, err)
		return
	}
	return
}

// 过滤查询账号
func FindManyAccByFilter(ctx context.Context, filters primitive.M, opts ...*options.FindOptions) ([]*MwAcc, *srvdef.SrvErr) {
	var res []*MwAcc
	err := mwAccColl.Find(ctx, &res, filters, opts...)
	if err != nil {
		log.Error("mwacc FindOneAccByFilter err", log.Any("filters", filters), log.E(err))
		return res, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	log.Info("success")

	return res, nil
}