import { UserId, RegionCode, ValidationResult } from '@/domain/value-objects'
import { RoleType, AuthorizationStatus } from '@/domain/enums'
import { IAuthorizationRoleRepository } from '@/domain/repositories'

export interface IReferralRepository {
  findByUserId(userId: UserId): Promise<{ parentId: string | null } | null>
  getAllAncestors(userId: UserId): Promise<UserId[]>
  getAllDescendants(userId: UserId): Promise<UserId[]>
}

export class AuthorizationValidatorService {
  /**
   * 验证授权申请（团队内唯一性）
   *
   * 规则：
   * 1. 一个账号只能申请一个省代或市代授权（不能同时拥有）
   * 2. 一条推荐线上，同一类型的授权只能有一个人（不管地区是什么）
   *    - 例如：用户A申请了北京市团队，用户A的下线不能再申请任何城市的市团队
   *    - 例如：用户A申请了广东省团队，用户A的下线不能再申请任何省份的省团队
   */
  async validateAuthorizationRequest(
    userId: UserId,
    roleType: RoleType,
    regionCode: RegionCode,
    referralRepository: IReferralRepository,
    authorizationRepository: IAuthorizationRoleRepository,
  ): Promise<ValidationResult> {
    // 1. 检查用户是否已有同类型授权（省或市只能选一个）
    if (
      roleType === RoleType.AUTH_PROVINCE_COMPANY ||
      roleType === RoleType.AUTH_CITY_COMPANY
    ) {
      // 检查是否已有省代授权
      const existingProvince = await authorizationRepository.findByUserIdAndRoleType(
        userId,
        RoleType.AUTH_PROVINCE_COMPANY,
      )
      if (existingProvince && existingProvince.status !== AuthorizationStatus.REVOKED) {
        return ValidationResult.failure('一个账号只能申请一个省代或市代授权')
      }

      // 检查是否已有市代授权
      const existingCity = await authorizationRepository.findByUserIdAndRoleType(
        userId,
        RoleType.AUTH_CITY_COMPANY,
      )
      if (existingCity && existingCity.status !== AuthorizationStatus.REVOKED) {
        return ValidationResult.failure('一个账号只能申请一个省代或市代授权')
      }
    }

    // 2. 检查团队内唯一性（上下级不能重复同类型授权，不管地区）
    const relationship = await referralRepository.findByUserId(userId)
    if (!relationship) {
      return ValidationResult.success()
    }

    // 检查所有上级 - 不检查地区，只检查授权类型
    const ancestors = await referralRepository.getAllAncestors(userId)
    for (const ancestorId of ancestors) {
      // 使用 findByUserIdAndRoleType 而不是 findByUserIdRoleTypeAndRegion
      // 因为一条线下同类型授权只能有一个，不管地区是什么
      const ancestorAuth = await authorizationRepository.findByUserIdAndRoleType(
        ancestorId,
        roleType,
      )

      if (ancestorAuth && ancestorAuth.status !== AuthorizationStatus.REVOKED) {
        return ValidationResult.failure(
          `本团队上级已有人申请该${this.getRoleTypeName(roleType)}授权（${ancestorAuth.regionName || '未知地区'}）`,
        )
      }
    }

    // 检查所有下级 - 不检查地区，只检查授权类型
    const descendants = await referralRepository.getAllDescendants(userId)
    for (const descendantId of descendants) {
      // 使用 findByUserIdAndRoleType 而不是 findByUserIdRoleTypeAndRegion
      const descendantAuth = await authorizationRepository.findByUserIdAndRoleType(
        descendantId,
        roleType,
      )

      if (descendantAuth && descendantAuth.status !== AuthorizationStatus.REVOKED) {
        return ValidationResult.failure(
          `本团队下级已有人申请该${this.getRoleTypeName(roleType)}授权（${descendantAuth.regionName || '未知地区'}）`,
        )
      }
    }

    return ValidationResult.success()
  }

  private getRoleTypeName(roleType: RoleType): string {
    switch (roleType) {
      case RoleType.AUTH_PROVINCE_COMPANY:
        return '省'
      case RoleType.AUTH_CITY_COMPANY:
        return '市'
      case RoleType.COMMUNITY:
        return '社区'
      default:
        return ''
    }
  }
}
