package roleservicelogic

import (
	"ark-permission/gen_result/pb/permission"
	"ark-permission/internal/domain"
	"ark-permission/internal/entity"
	"ark-permission/internal/model"
	"ark-permission/internal/svc"
	ers "code.30cm.net/wanderland/library-go/errors"
	"context"
	"errors"
	"github.com/zeromicro/go-zero/core/logx"
)

type GetRoleLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
}

func NewGetRoleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRoleLogic {
	return &GetRoleLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

// GetRole 取得搜尋的角色
func (l *GetRoleLogic) GetRole(in *permission.GetRoleReq) (*permission.GetRoleResp, error) {
	// 檢查是否為全表搜尋
	if in.GetAll() {
		return l.getAllRoles()
	}

	// 處理分頁參數
	size := int64(20)
	if in.GetPageSize() != 0 {
		size = in.GetPageSize()
	}
	index := int64(1)
	if in.GetPageIndex() != 0 {
		index = in.GetPageIndex()
	}

	// 執行角色搜尋和計算總數
	roles, count, err := l.searchRolesWithCount(in, size, index)
	if err != nil {
		return nil, err
	}

	// 組裝結果
	return l.buildRoleResp(roles, in.PageSize, in.PageIndex, count, in.GetPermissions()), nil
}

// getAllRoles 獲取全表角色
func (l *GetRoleLogic) getAllRoles() (*permission.GetRoleResp, error) {
	// 查詢所有角色
	roles, err := l.svcCtx.RoleRepo.Find(l.ctx)
	if err != nil {
		return nil, l.handleDBError(err, "failed to get role")
	}

	// 計算總數
	count, err := l.svcCtx.RoleRepo.Count(l.ctx, &model.Role{})
	if err != nil {
		return nil, l.handleDBError(err, "failed to get role")
	}

	// 組裝結果
	return l.buildRoleResp(roles, -1, -1, count, nil), nil
}

// searchRolesWithCount 搜尋角色並計算總數
func (l *GetRoleLogic) searchRolesWithCount(in *permission.GetRoleReq, size, index int64) ([]*model.Role, int64, error) {
	// 搜尋角色
	roles, err := l.svcCtx.RoleRepo.SearchRoles(l.ctx, &model.Role{
		RoleId:      in.GetRoleIds(),
		DisplayName: in.GetDisplayName(),
		Status:      int64(in.GetStatus().Number()),
	}, size, index)
	if err != nil {
		return nil, 0, err
	}

	// 計算總數
	count, err := l.svcCtx.RoleRepo.Count(l.ctx, &model.Role{
		RoleId:      in.GetRoleIds(),
		DisplayName: in.GetDisplayName(),
		Status:      int64(in.GetStatus().Number()),
	})
	if err != nil {
		return nil, 0, l.handleDBError(err, "failed to get role")
	}

	list := make([]*model.Role, 0, count)
	for _, item := range roles {
		list = append(list, &item)
	}

	return list, count, nil
}

// handleDBError 處理資料庫錯誤
func (l *GetRoleLogic) handleDBError(err error, msg string) error {
	if errors.Is(model.ErrNotFound, err) {
		return ers.ResourceNotFound(msg)
	}
	return ers.DBError(err.Error())
}

// buildRoleResp 組裝角色回應
func (l *GetRoleLogic) buildRoleResp(roles []*model.Role, pageSize, pageIndex, totalCount int64, filter []string) *permission.GetRoleResp {
	list := make([]*permission.RoleResp, 0, len(roles))
	for _, item := range roles {
		permissions := make(map[string]string)
		// Admin 角色
		if item.RoleId == domain.AdminRoleID {
			data, err := l.svcCtx.Permission.FindAllOpenPermission(l.ctx)
			if err != nil {
				// log
				continue
			}

			for _, v := range data {
				permissions[v.Name] = string(domain.PermissionStatusOpenCode)
			}
		} else {
			rolePermission, err := l.svcCtx.RolePermissionRepo.FindOneByRoleID(l.ctx, item.RoleId)
			if err != nil {
				// log
				continue
			}

			var rp = make([]entity.RolePermission, 0, len(rolePermission))
			for _, item := range rolePermission {
				rp = append(rp, entity.RolePermission{
					ID:           item.Id,
					RoleID:       item.RoleId.Int64,
					PermissionID: item.PermissionId.Int64,
					CreateTime:   item.CreateTime,
					UpdateTime:   item.UpdateTime,
				})

			}

			userRolePermission, err := l.svcCtx.PermissionTree.GetRolePermissionTree(rp)
			if err != nil {
				return nil
			}

			if filter == nil {
				list = append(list, &permission.RoleResp{
					Id:          item.Id,
					DisplayName: item.DisplayName,
					RoleId:      item.RoleId,
					Status:      permission.PermissionStatus(item.Status),
					Permissions: permissions,
					CreateTime:  item.CreateTime,
					UpdateTime:  item.UpdateTime,
				})
			} else {
				for _, p := range filter {
					if userRolePermission[p] == domain.PermissionStatusOpenCode {
						list = append(list, &permission.RoleResp{
							Id:          item.Id,
							DisplayName: item.DisplayName,
							RoleId:      item.RoleId,
							Status:      permission.PermissionStatus(item.Status),
							Permissions: permissions,
							CreateTime:  item.CreateTime,
							UpdateTime:  item.UpdateTime,
						})

						break
					}
				}
			}
		}

	}

	return &permission.GetRoleResp{
		List: list,
		Page: &permission.PageResponse{
			PageSize:   pageSize,
			PageIndex:  pageIndex,
			TotalCount: totalCount,
		},
	}
}