package role

import (
	"busniess-user-center/config"
	roleModel "busniess-user-center/internal/models/role"
	userModel "busniess-user-center/internal/models/user"
	"busniess-user-center/internal/repo"
	"busniess-user-center/internal/service/user"
	contextUtil "busniess-user-center/pkg/utils/context"
	"busniess-user-center/pkg/utils/session"
	"context"
	"fmt"

	"github.com/jinzhu/copier"
	"github.com/samber/do"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

func init() {
	do.Provide(nil, NewRoleService)
}

const (
	superAdmin = "super_admin"
	admin      = "admin"
	develop    = "develop"
)

type roleService struct {
	logger      *zap.SugaredLogger
	roleRepo    repo.RoleRepo
	conf        *config.AppConfig
	userService user.UserService
	orgRepo     repo.OrganizationRepo
}

func NewRoleService(i *do.Injector) (RoleService, error) {
	return &roleService{
		logger:      do.MustInvoke[*zap.SugaredLogger](i),
		roleRepo:    do.MustInvoke[repo.RoleRepo](i),
		conf:        do.MustInvoke[*config.AppConfig](i),
		userService: do.MustInvoke[user.UserService](i),
		orgRepo:     do.MustInvoke[repo.OrganizationRepo](i),
	}, nil
}

func (o *roleService) Create(ctx context.Context, info *roleModel.CreateReq) error {
	dbRole := repo.Role{
		Code: info.Code,
		Name: info.Name,
	}

	exist, err := o.roleRepo.ExistCode(ctx, info.Code)
	if err != nil {
		return err
	}

	if exist {
		return fmt.Errorf("角色code:%s已经存在", info.Code)
	}

	return o.roleRepo.Create(ctx, dbRole)
}

func (o *roleService) Save(ctx context.Context, info *roleModel.SaveReq) error {
	dbRole, err := o.roleRepo.GetById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("角色:%s不存在", info.Code)
	}

	dbRole.Name = info.Name

	return o.roleRepo.Save(ctx, dbRole)
}

func (o *roleService) Delete(ctx context.Context, info *roleModel.DelReq) error {
	return o.roleRepo.DelById(ctx, info.Id)
}

func (o *roleService) Role(ctx context.Context, info *roleModel.GetReq) (role roleModel.Role, err error) {
	dbRole, err := o.roleRepo.GetById(ctx, info.Id)
	if err != nil {
		return
	}

	err = copier.Copy(&role, dbRole)
	return
}

func (o *roleService) Search(ctx context.Context, info *roleModel.Query) ([]roleModel.Role, error) {
	dbQuery := repo.Query{}
	copier.Copy(&dbQuery, info)

	dbRoles, err := o.roleRepo.Search(ctx, dbQuery)
	if err != nil {
		return nil, err
	}

	roles := make([]roleModel.Role, 0, len(dbRoles))
	for _, role := range dbRoles {
		roles = append(roles, convertDTM(role))
	}

	return roles, nil
}

func (o *roleService) AddUsers(ctx context.Context, info *roleModel.AddUsersReq) error {
	role, err := o.roleRepo.GetById(ctx, info.RoleId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("角色%d不存在", info.RoleId)
	}

	// 判断权限
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return err
	}

	perssion, err := o.hasPermission(ctx, session)
	if err != nil {
		return err
	}

	if !perssion {
		return fmt.Errorf("没有权限")
	}

	// 获取用户
	users, err := o.userService.BatchGetUserByIDs(ctx, info.Ids)
	if err != nil {
		return err
	}

	uRoles := make([]repo.UserRole, 0, len(users))
	for _, item := range users {
		uRoles = append(uRoles, repo.UserRole{
			UserAccount: item.Account,
			RoleCode:    role.Code,
			CreatedBy:   session.Account,
		})
	}

	if len(uRoles) > 0 {
		err = o.roleRepo.CreateUserRole(ctx, uRoles)
	}

	return err
}

func (o *roleService) RemoveUsers(ctx context.Context, info *roleModel.RemoveUsersReq) error {
	role, err := o.roleRepo.GetById(ctx, info.RoleId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("角色%d不存在", info.RoleId)
	}

	// 判断权限
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return err
	}

	perssion, err := o.hasPermission(ctx, session)
	if err != nil {
		return err
	}

	if !perssion {
		return fmt.Errorf("没有权限")
	}

	users, err := o.userService.BatchGetUserByIDs(ctx, info.Ids)
	if err != nil {
		return err
	}

	uRoles := make([]repo.UserRole, 0, len(users))
	for _, item := range users {
		uRoles = append(uRoles, repo.UserRole{
			UserAccount: item.Account,
			RoleCode:    role.Code,
			CreatedBy:   session.Account,
		})
	}

	if len(uRoles) > 0 {
		err = o.roleRepo.RemoveUserRole(ctx, uRoles)
	}

	return nil
}

func (o *roleService) AddOrgs(ctx context.Context, info *roleModel.AddOrgsReq) error {
	_, err := o.roleRepo.GetById(ctx, info.RoleId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("角色%d不存在", info.RoleId)
	}

	// 判断权限
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return err
	}

	perssion, err := o.hasPermission(ctx, session)
	if err != nil {
		return err
	}

	if !perssion {
		return fmt.Errorf("没有权限")
	}

	// 判断组织是否存在
	orgIds := make([]uint, 0)
	for _, item := range info.Orgs {
		orgIds = append(orgIds, item.Id)
	}

	dbAuthors, err := o.roleRepo.GetOrgAuthors(ctx, info.RoleId, orgIds)
	if err != nil {
		return err
	}

	dbOrgRoles, err := o.roleRepo.GetAllRoleOrgsByRoleId(ctx, info.RoleId)
	if err != nil {
		return err
	}

	allOrgs, err := o.orgRepo.GetOrgs(ctx)
	if err != nil {
		return err
	}

	orgAuthor, orgRole := getOrgAuthorAndRole(info.RoleId, info.Orgs, allOrgs)
	iOrgAuthor, iOrgRole := filterOrgAuthorRole(orgAuthor, dbAuthors, orgRole, dbOrgRoles)

	if err = o.roleRepo.CreateOrgRole(ctx, iOrgRole); err != nil {
		return err
	}

	if err = o.roleRepo.CreateOrgAuthor(ctx, iOrgAuthor); err != nil {
		return err
	}

	return nil
}

func (o *roleService) RemoveOrgs(ctx context.Context, info *roleModel.RemoveOrgsReq) error {
	_, err := o.roleRepo.GetById(ctx, info.RoleId)
	if err != nil && err != gorm.ErrRecordNotFound {
		return err
	}

	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("角色%d不存在", info.RoleId)
	}

	// 判断权限
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return err
	}

	perssion, err := o.hasPermission(ctx, session)
	if err != nil {
		return err
	}

	if !perssion {
		return fmt.Errorf("没有权限")
	}

	dbAuthors, err := o.roleRepo.GetRoleAllOrgAuthorsByRoleId(ctx, info.RoleId)
	if err != nil {
		return err
	}

	allOrgs, err := o.orgRepo.GetOrgs(ctx)
	if err != nil {
		return err
	}

	orgAuthor, orgRole := genRemoveOrgAuthorAndRole(info.RoleId, info.Ids, allOrgs, dbAuthors)
	roleOrgIds := make([]uint, 0)
	for _, item := range orgRole {
		roleOrgIds = append(roleOrgIds, item.OrgID)
	}

	err = o.roleRepo.DeleteOrgRole(ctx, info.RoleId, roleOrgIds)
	if err != nil {
		return err
	}

	orgAuthroIds := make([]uint, 0)
	for _, item := range orgAuthor {
		orgAuthroIds = append(orgAuthroIds, item.OrgID)
	}

	err = o.roleRepo.DeleteOrgAuthor(ctx, info.RoleId, orgAuthroIds)
	if err != nil {
		return err
	}

	return nil
}

func (o *roleService) RoleUsers(ctx context.Context, info *roleModel.RoleUsersReq) ([]userModel.UserInfo, error) {
	role, err := o.roleRepo.GetById(ctx, info.Id)
	if err != nil && err != gorm.ErrRecordNotFound {
		return nil, err
	}

	if err == gorm.ErrRecordNotFound {
		return nil, fmt.Errorf("角色%d不存在", info.Id)
	}

	info.Query.Default()
	dbQuery := repo.Query{}
	copier.Copy(&dbQuery, info.Query)
	users, err := o.roleRepo.SearchRoleUsers(ctx, role.Code, dbQuery)
	if err != nil {
		return nil, err
	}

	rUsers := make([]userModel.UserInfo, 0)
	copier.Copy(&rUsers, users)

	return rUsers, nil
}

func (u *roleService) RoleOrgs(ctx context.Context, info *roleModel.RoleOrgsReq) ([]roleModel.OrgRoleAuthor, error) {
	info.Query.Default()
	dbQuery := repo.Query{}
	copier.Copy(&dbQuery, info.Query)
	authors, err := u.roleRepo.SearchOrgAuthor(ctx, info.Id, dbQuery)
	if err != nil {
		return nil, err
	}

	rAuthors := make([]roleModel.OrgRoleAuthor, 0)
	copier.Copy(&rAuthors, authors)
	return rAuthors, nil
}

func (u *roleService) AuthorRoleMenu(ctx context.Context, info *roleModel.AuthorRoleMenuReq) error {
	return nil
}

func (u *roleService) RemoveRoleMenu(ctx context.Context, info *roleModel.RemoveReleMenuReq) error {
	return nil
}

func (u *roleService) RoleMenuAuthorList(ctx context.Context, info *roleModel.AddOrgsReq) ([]roleModel.RoleMenu, error) {
	return nil, nil
}

func (u *roleService) hasPermission(ctx context.Context, session *session.Session) (bool, error) {
	user, err := u.userService.GetUser(ctx, &userModel.GetUserReq{Account: session.Account, AppCode: session.AppCode})
	if err != nil {
		return false, err
	}

	if len(user.Roles) > 0 {
		for _, item := range user.Roles {
			if item.Code == superAdmin || item.Code == develop || item.Code == admin {
				return true, nil
			}
		}
	}

	return false, nil
}