package srv_mwacc

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

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

// 删除角色
func RoleDel(ctx context.Context, roleId int64) (bool, *srvdef.SrvErr) {

	res, err := mwacc.FindOneRoleByFilter(ctx, bson.M{mwacc.FN.MwRole.Id: roleId})

	if err != nil || res.Id == 0 {
		log.ZapLog.Error(fmt.Sprintf("search error %v", err))
		return false, err
	}

	// 查询记录是否有账户
	roles, err1 := mwacc.RoleAggregate(ctx,
		[]bson.M{
			{"$match": bson.M{mwacc.FN.MwRole.Id: roleId}},
			{"$limit": 1},
			{"$lookup": bson.M{
				"localField":   mwacc.FN.MwRole.Id,
				"from":         mwacc.TN.MwAcc,
				"foreignField": mwacc.FN.MwAcc.RoleId,
				"as":           "onlyRole",
			}},
			{"$unwind": "$onlyRole"},
			{"$project": bson.M{
				mwacc.FN.MwRole.Id: 1,
				"onlyRole.roleId":  1,
			}},
		})

	if err1 != nil {
		log.Error("角色删除失败", log.Any("roleId", roleId))
		return false, srvdef.New(srvdef.ErrDbDeleteError, "", "")
	}

	if len(roles) > 0 {
		log.Error("角色删除失败", log.Any("roleId", roleId))
		return false, srvdef.New(srvdef.ErrDbDeleteError, "删除失败,此角色有帐户", "")
	}

	serr := mwacc.DelRoleByFilter(ctx, bson.M{mwacc.FN.MwRole.Id: roleId})
	if serr != nil {
		return false, serr
	}
	return true, nil
}

// 获取信息
func RoleGetInfo(ctx context.Context, roleId int64) (*mwacc.MwRole, error) {

	rest, err := mwacc.FindOneRoleByFilter(ctx, bson.M{
		mwacc.FN.MwRole.Id: roleId,
	})

	if err != nil {
		return nil, err
	}

	return rest, nil
}

//  角色id

// 角色更新
func RoleUp(ctx context.Context, id int64, name string, desc string, isEnb bool) (ok bool, err error) {

	roleCount, err := mwacc.RoleCountByFilter(ctx, bson.M{
		mwacc.FN.MwRole.Name: name,
		mwacc.FN.MwRole.Id: bson.M{
			"$ne": id,
		},
	})

	if roleCount > 0 {
		err = errors.MakeWithMsg(errors.DBInsert, "角色名称已存在")
		return false, err
	}

	err = mwacc.UpOneRoleByFilter(ctx, bson.M{
		mwacc.FN.MwRole.Id: id,
	}, bson.M{
		"$set": bson.M{
			mwacc.FN.MwRole.Name:      name,
			mwacc.FN.MwRole.Desc:      desc,
			mwacc.FN.MwRole.IsEnb:     isEnb,
			mwacc.FN.MwRole.UpdatedAt: time.Now(),
		},
	})

	if err != nil {
		log.ZapLog.Error(fmt.Sprintf("RoleUp error %v", err))
		err = errors.MakeWithErr(errors.DBUpdate, err)
		return
	}

	return true, nil
}

// 设置角色状态
func RoleEnable(ctx context.Context, roleId int64, IsEnb bool) (bool, *srvdef.SrvErr) {

	rest, err := mwacc.FindOneRoleByFilter(ctx, bson.M{
		mwacc.FN.MwRole.Id: roleId,
	})

	if err != nil || rest.Id == 0 {
		return false, err
	}
	// count, err := mwacc.RoleAggregate(ctx, []bson.M{
	// 	{"$match": bson.M{
	// 		mwacc.FN.MwRole.Id: roleId,
	// 	}},
	// 	{"$limit": 1},
	// 	{"$lookup": bson.M{
	// 		"localField":   mwacc.FN.MwRole.Id,
	// 		"from":         mwacc.TN.MwAcc,
	// 		"foreignField": mwacc.FN.MwAcc.RoleId,
	// 		"as":           "onlyRole",
	// 	}},
	// 	{"$unwind": "$onlyRole"},
	// 	{"$project": bson.M{
	// 		"roleId":          1,
	// 		"onlyRole.roleId": 1,
	// 	}},
	// })
	data, err1 := mwacc.FindManyAccByFilter(ctx, bson.M{mwacc.FN.MwAcc.RoleId: roleId})
	if err1 != nil {
		return false, err1
	}

	if len(data) > 0 && IsEnb == false {
		return false, srvdef.New(srvdef.ErrDbUpdateError, "更新失败,此角色下拥有管理员", "")
	}

	StatusErr := mwacc.UpOneRoleByFilter(ctx, bson.M{
		mwacc.FN.MwRole.Id: roleId,
	}, bson.M{
		"$set": bson.M{
			mwacc.FN.MwRole.IsEnb: IsEnb,
		},
	})

	if StatusErr != nil {
		return false, StatusErr
	}

	return true, nil
}

// ////////////////////////////////////////////////////////////////////////////
// 数据库Router转网站Router

// // 角色权限列表
// func RoleAuthList(ctx context.Context, roleId int64) (*mwacc.MwRole, error) {
// 	opt := &options.FindOneOptions{}
// 	opt.SetProjection(bson.M{
// 		mwacc.FN.MwRole.Id:     1,
// 		mwacc.FN.MwRole.Router: 1,
// 	})

// 	res, err := mwacc.FindOneRoleByFilter(ctx, bson.M{mwacc.FN.MwRole.Id: roleId})
// 	if err != nil {
// 		return &mwacc.MwRole{}, err
// 	}
// 	if res.Id != 0 {
// 		return res, nil
// 	}
// 	return nil, nil
// }

func handleMenu(ctx context.Context, reqRouter []*mwacc.Router, apiMap map[string]int64) map[string]int64 {

	if apiMap == nil {
		apiMap = make(map[string]int64)
	}

	for _, v := range reqRouter {
		if v.Children != nil && len(v.Children) != 0 {
			childs := make([]*mwacc.Router, 0)
			for _, v := range v.Children {
				childs = append(childs, &v)
			}
			apiMap = handleMenu(ctx, childs, apiMap)
		}
		if v.ApiUrl != nil && len(v.ApiUrl) != 0 {
			for _, v := range v.ApiUrl {
				if v.Status == true {
					for _, value := range v.Url {
						apiMap[value] = 1
					}
				}
			}
		}
	}
	return apiMap
}

// 更新权限
func UpAuth(ctx context.Context, id int64, dataRouter []*mwacc.Router) (ok bool, err error) {

	apiMap := handleMenu(ctx, dataRouter, nil)

	keys := make([]string, 0)
	for k := range apiMap {
		keys = append(keys, k)
	}

	return mwacc.UpRoleAuth(ctx, id, keys, dataRouter)
}