package service

import (
	"time"
	"yintai-api/app/admin/request"
	"yintai-api/app/common/cache"
	"yintai-api/app/common/dao"
	err2 "yintai-api/app/common/err"
	"yintai-api/app/common/model"
	"yintai-api/app/common/utils"
	"yintai-api/base/global"

	"github.com/spf13/cast"
	"gorm.io/gorm"
)

type Role struct{}

func (r *Role) Create(req request.RoleCreate) int64 {
	if req.Name == "" {
		err2.ParamErr("name is empty.")
	}

	m := new(model.Role)
	m.Name = req.Name
	m.Desc = req.Desc
	m.CreateTime = time.Now().Unix()

	err := global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err := dao.NewRole(tx).Create(m); err != nil {
			return err
		}

		if len(req.Resource) == 0 {
			return nil
		}

		resource := make([]int64, 0, len(req.Resource))
		for _, s := range req.Resource {
			if v := cast.ToInt64(s); v > 0 {
				resource = append(resource, v)
			}
		}

		mr, err := dao.NewResource(tx).GetByIds(resource)
		if err != nil {
			return err
		}

		rs := make([]*model.RoleResource, 0, len(resource))
		for _, v := range mr {
			rs = append(rs, &model.RoleResource{
				RoleID:     m.ID,
				ResourceID: v.ID,
			})
		}

		if err = dao.NewRoleResource(tx).Create(rs); err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	try := 3
	for try > 0 {
		if err = utils.LazyLoadPermission(m.ID); err == nil {
			break
		}
		try--
	}

	return m.ID
}

func (r *Role) Update(req request.RoleUpdate) {
	m, err := dao.NewRole().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	if req.Name != "" {
		m.Name = req.Name
	}

	if req.Desc != "" {
		m.Desc = req.Desc
	}

	m.UpdateTime = time.Now().Unix()

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = dao.NewRole(tx).Update(m); err != nil {
			return err
		}

		if len(req.Resource) == 0 {
			return nil
		}

		resource := make([]int64, 0, len(req.Resource))
		for _, s := range req.Resource {
			if v := cast.ToInt64(s); v > 0 {
				resource = append(resource, v)
			}
		}
		mr, err := dao.NewResource(tx).GetByIds(resource)
		if err != nil {
			return err
		}

		rs := make([]*model.RoleResource, 0, len(resource))
		for _, v := range mr {
			rs = append(rs, &model.RoleResource{
				RoleID:     m.ID,
				ResourceID: v.ID,
			})
		}

		if err = dao.NewRoleResource(tx).Delete(m.ID); err != nil {
			return err
		}

		if err = dao.NewRoleResource(tx).Create(rs); err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	try := 3
	for try > 0 {
		if err = utils.LazyLoadPermission(m.ID); err == nil {
			break
		}
		try--
	}

	return
}

func (r *Role) Delete(req request.RoleDelete) {
	m, err := dao.NewRole().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = dao.NewRole(tx).Delete(m.ID); err != nil {
			return err
		}

		if err = dao.NewRoleResource(tx).Delete(m.ID); err != nil {
			return err
		}

		if cast.ToBool(req.DelAccount) == true {
			users, err := dao.NewUserRole(tx).GetAccount(m.ID)
			if err != nil {
				return err
			}

			if users == nil {
				return nil
			}

			userIds := make([]int64, 0, len(users))
			for _, user := range users {
				userIds = append(userIds, user.ID)
			}

			if err = dao.NewUser().BatchDelete(userIds); err != nil {
				return err
			}

			if err = dao.NewUserRole(tx).RoleDelete(m.ID); err != nil {
				return err
			}
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	cache.GetRedis().Expire(cache.NewKeys().Api(m.ID), 1)

	return
}

func (r *Role) List(req request.RoleList) (any, int64) {
	req.Pagination()
	lists, count, err := dao.NewRole().List(req.Name, req.Desc, req.Page, req.Size, req.Sort)
	if err != nil {
		err2.DbErr(err)
	}

	res := make([]map[string]any, 0)
	for _, list := range lists {
		res = append(res, list.Format())
	}

	return res, count
}

func (r *Role) Get(req request.RoleGet) any {
	resources, err := dao.NewResource().RoleGet(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}
	res := make([]map[string]any, 0, len(resources))
	for _, resource := range resources {
		res = append(res, resource.Format())
	}

	return res
}

func (r *Role) Accounts(req request.RoleGet) any {
	users, err := dao.NewUserRole().GetAccount(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}
	res := make([]map[string]any, 0, len(users))
	for _, user := range users {
		res = append(res, user.Format())
	}

	return res
}