/**
 * InMemory implementation of ISponsorshipRequestRepository
 */

import type { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
import { 
  SponsorshipRequest, 
  type SponsorableEntityType, 
  type SponsorshipRequestStatus 
} from '../../domain/entities/SponsorshipRequest';

export class InMemorySponsorshipRequestRepository implements ISponsorshipRequestRepository {
  private requests: Map<string, SponsorshipRequest> = new Map();

  async findById(id: string): Promise<SponsorshipRequest | null> {
    return this.requests.get(id) ?? null;
  }

  async findByEntity(entityType: SponsorableEntityType, entityId: string): Promise<SponsorshipRequest[]> {
    return Array.from(this.requests.values()).filter(
      request => request.entityType === entityType && request.entityId === entityId
    );
  }

  async findPendingByEntity(entityType: SponsorableEntityType, entityId: string): Promise<SponsorshipRequest[]> {
    return Array.from(this.requests.values()).filter(
      request => 
        request.entityType === entityType && 
        request.entityId === entityId && 
        request.status === 'pending'
    );
  }

  async findBySponsorId(sponsorId: string): Promise<SponsorshipRequest[]> {
    return Array.from(this.requests.values()).filter(
      request => request.sponsorId === sponsorId
    );
  }

  async findByStatus(status: SponsorshipRequestStatus): Promise<SponsorshipRequest[]> {
    return Array.from(this.requests.values()).filter(
      request => request.status === status
    );
  }

  async findBySponsorIdAndStatus(sponsorId: string, status: SponsorshipRequestStatus): Promise<SponsorshipRequest[]> {
    return Array.from(this.requests.values()).filter(
      request => request.sponsorId === sponsorId && request.status === status
    );
  }

  async hasPendingRequest(sponsorId: string, entityType: SponsorableEntityType, entityId: string): Promise<boolean> {
    return Array.from(this.requests.values()).some(
      request => 
        request.sponsorId === sponsorId && 
        request.entityType === entityType && 
        request.entityId === entityId &&
        request.status === 'pending'
    );
  }

  async countPendingByEntity(entityType: SponsorableEntityType, entityId: string): Promise<number> {
    return Array.from(this.requests.values()).filter(
      request => 
        request.entityType === entityType && 
        request.entityId === entityId && 
        request.status === 'pending'
    ).length;
  }

  async create(request: SponsorshipRequest): Promise<SponsorshipRequest> {
    this.requests.set(request.id, request);
    return request;
  }

  async update(request: SponsorshipRequest): Promise<SponsorshipRequest> {
    if (!this.requests.has(request.id)) {
      throw new Error(`SponsorshipRequest ${request.id} not found`);
    }
    this.requests.set(request.id, request);
    return request;
  }

  async delete(id: string): Promise<void> {
    this.requests.delete(id);
  }

  async exists(id: string): Promise<boolean> {
    return this.requests.has(id);
  }

  /**
   * Seed initial data
   */
  seed(requests: SponsorshipRequest[]): void {
    for (const request of requests) {
      this.requests.set(request.id, request);
    }
  }

  /**
   * Clear all data (for testing)
   */
  clear(): void {
    this.requests.clear();
  }
}