/**
 * IntegrationKeyMapper
 *
 * Maps between IntegrationKey domain entities and DTOs.
 *
 * @layer Application
 */

import { IntegrationKey, IntegrationKeyStatus } from '../../domain/entities/IntegrationKey';
import { IMapper } from './IMapper';

/**
 * IntegrationKey DTO (Data Transfer Object)
 *
 * Represents the persisted format in localStorage.
 */
export interface IntegrationKeyDTO {
  id: string;
  tenantId: string;
  key: string;
  keyPrefix: string;
  status: IntegrationKeyStatus;
  expiresAt?: string;
  lastUsedAt?: string;
  createdAt: string;
  updatedAt: string;
  deletedAt?: string;
}

/**
 * IntegrationKeyMapper
 *
 * Handles transformations between IntegrationKey domain entities and DTOs.
 */
export class IntegrationKeyMapper implements IMapper<IntegrationKey, IntegrationKeyDTO> {
  toDomain(dto: IntegrationKeyDTO): IntegrationKey {
    return IntegrationKey.fromPersistence({
      id: dto.id,
      tenantId: dto.tenantId,
      key: dto.key,
      keyPrefix: dto.keyPrefix,
      status: dto.status,
      expiresAt: dto.expiresAt,
      lastUsedAt: dto.lastUsedAt,
      createdAt: dto.createdAt,
      updatedAt: dto.updatedAt,
      deletedAt: dto.deletedAt,
    });
  }

  toDTO(entity: IntegrationKey): IntegrationKeyDTO {
    const persistence = entity.toPersistence();

    return {
      id: persistence.id,
      tenantId: persistence.tenantId,
      key: persistence.key,
      keyPrefix: persistence.keyPrefix,
      status: persistence.status,
      expiresAt: persistence.expiresAt,
      lastUsedAt: persistence.lastUsedAt,
      createdAt: persistence.createdAt,
      updatedAt: persistence.updatedAt,
      deletedAt: persistence.deletedAt,
    };
  }

  toDomainArray(dtos: IntegrationKeyDTO[]): IntegrationKey[] {
    return dtos.map((dto) => this.toDomain(dto));
  }

  toDTOArray(entities: IntegrationKey[]): IntegrationKeyDTO[] {
    return entities.map((entity) => this.toDTO(entity));
  }

  calculateStats(keys: IntegrationKey[]): {
    total: number;
    active: number;
    revoked: number;
    expired: number;
    expiringSoon: number;
  } {
    return {
      total: keys.length,
      active: keys.filter((k) => k.isActive() && !k.isExpired()).length,
      revoked: keys.filter((k) => k.isRevoked()).length,
      expired: keys.filter((k) => k.isExpired()).length,
      expiringSoon: keys.filter((k) => k.isExpiringSoon()).length,
    };
  }
}