adSegmentFixtureProvider.ts

/**
 * Fixture-Based Ad Segment Provider (POC)
 *
 * Loads ad segments and tagger profiles from local JSON fixture files.
 * This is the POC implementation - in production, this will be replaced
 * with NostrAdSegmentProvider that queries Nostr relays.
 *
 * FIXTURE LOCATIONS:
 * - Ad segments: /lib/fixtures/adSegments/{episodeKey}.json
 * - Tagger profiles: /lib/fixtures/profiles/taggers.json
 *
 * DESIGN NOTES:
 * - Uses dynamic imports to load JSON files
 * - Implements AdSegmentProvider interface for swappability
 * - Includes in-memory cache for performance
 * - Gracefully handles missing fixtures (returns empty arrays/null)
 */

import {
  AdSegment,
  TaggerProfile,
  EpisodeAdData,
  AdSegmentProvider,
  ChapterData,
} from './adSegmentTypes'
import { isHashBasedKey } from './adSegmentIdentity'

/**
 * Fixture Ad Segment Provider
 *
 * POC implementation that reads from local JSON files.
 * Implements AdSegmentProvider interface.
 */
export class FixtureAdSegmentProvider implements AdSegmentProvider {
  private adSegmentCache: Map<string, AdSegment[]> = new Map()
  private taggerProfileCache: Map<string, TaggerProfile | null> = new Map()
  private episodeAdDataCache: Map<string, EpisodeAdData | null> = new Map()

  /**
   * Fetch Ad Segments for Episode
   *
   * Loads from: /lib/fixtures/adSegments/{episodeKey}.json
   *
   * @param episodeKey Episode identifier (GUID or hash)
   * @returns Promise resolving to ad segments array (empty if not found)
   */
  async fetchAdSegments(episodeKey: string): Promise<AdSegment[]> {
    // Check cache first
    if (this.adSegmentCache.has(episodeKey)) {
      return this.adSegmentCache.get(episodeKey)!
    }

    try {
      const data = await this.loadEpisodeAdData(episodeKey)
      const segments = data?.adSegments || []

      // Cache result
      this.adSegmentCache.set(episodeKey, segments)

      return segments
    } catch (error) {
      console.warn(`[FixtureProvider] Failed to load ad segments for episode "${episodeKey}":`, error)

      // Cache empty result to avoid repeated failed attempts
      this.adSegmentCache.set(episodeKey, [])

      return []
    }
  }

  /**
   * Fetch Tagger Profile
   *
   * Loads from: /lib/fixtures/profiles/taggers.json
   *
   * @param pubkey Nostr public key (npub or hex)
   * @returns Promise resolving to profile (null if not found)
   */
  async fetchTaggerProfile(pubkey: string): Promise<TaggerProfile | null> {
    // Check cache first
    if (this.taggerProfileCache.has(pubkey)) {
      return this.taggerProfileCache.get(pubkey)!
    }

    try {
      const profiles = await this.loadTaggerProfiles()
      const profile = profiles.find((p) => p.pubkey === pubkey) || null

      // Cache result
      this.taggerProfileCache.set(pubkey, profile)

      return profile
    } catch (error) {
      console.warn(`[FixtureProvider] Failed to load tagger profile for "${pubkey}":`, error)

      // Cache null result
      this.taggerProfileCache.set(pubkey, null)

      return null
    }
  }

  /**
   * Fetch Complete Episode Ad Data
   *
   * Loads both ad segments and metadata from fixture file.
   *
   * @param episodeKey Episode identifier
   * @returns Promise resolving to episode ad data (null if not found)
   */
  async fetchEpisodeAdData(episodeKey: string): Promise<EpisodeAdData | null> {
    // Check cache first
    if (this.episodeAdDataCache.has(episodeKey)) {
      return this.episodeAdDataCache.get(episodeKey)!
    }

    try {
      const data = await this.loadEpisodeAdData(episodeKey)

      // Cache result
      this.episodeAdDataCache.set(episodeKey, data)

      return data
    } catch (error) {
      console.warn(`[FixtureProvider] Failed to load episode ad data for "${episodeKey}":`, error)

      // Cache null result
      this.episodeAdDataCache.set(episodeKey, null)

      return null
    }
  }

  /**
   * Load Episode Ad Data from Fixture File
   *
   * Attempts to load from /lib/fixtures/adSegments/{episodeKey}.json
   *
   * For hash-based keys (format: "hash:abc123..."), only uses the hash portion
   * as the filename (without "hash:" prefix).
   *
   * @param episodeKey Episode identifier
   * @returns Episode ad data or null if not found
   */
  private async loadEpisodeAdData(episodeKey: string): Promise<EpisodeAdData | null> {
    // Sanitize episode key for use as filename
    const filename = this.sanitizeEpisodeKeyForFilename(episodeKey)

    try {
      // Attempt to dynamically import the fixture file
      // Note: In Next.js, this works for files in public/ or lib/
      const data = await import(`~/lib/fixtures/adSegments/${filename}.json`)

      // Validate basic structure
      if (!data || !Array.isArray(data.adSegments)) {
        console.warn(`[FixtureProvider] Invalid fixture format for "${filename}.json"`)
        return null
      }

      return data as EpisodeAdData
    } catch (error) {
      // File not found or import failed - this is expected for episodes without ad data
      return null
    }
  }

  /**
   * Load Tagger Profiles from Fixture File
   *
   * Loads from: /lib/fixtures/profiles/taggers.json
   *
   * @returns Array of tagger profiles
   */
  private async loadTaggerProfiles(): Promise<TaggerProfile[]> {
    try {
      const data = await import('~/lib/fixtures/profiles/taggers.json')

      if (!data || !Array.isArray(data.profiles)) {
        console.warn('[FixtureProvider] Invalid tagger profiles fixture format')
        return []
      }

      return data.profiles as TaggerProfile[]
    } catch (error) {
      console.error('[FixtureProvider] Failed to load tagger profiles:', error)
      return []
    }
  }

  /**
   * Sanitize Episode Key for Filename
   *
   * Converts episode key to a safe filename:
   * - Hash-based keys: strip "hash:" prefix, use hash only
   * - GUID-based keys: replace unsafe characters with underscores
   *
   * Examples:
   * - "hash:abc123def456" → "abc123def456"
   * - "https://example.com/episode/123" → "https___example_com_episode_123"
   * - "urn:uuid:12345" → "urn_uuid_12345"
   *
   * @param episodeKey Episode identifier
   * @returns Safe filename (without .json extension)
   */
  private sanitizeEpisodeKeyForFilename(episodeKey: string): string {
    // For hash-based keys, strip the "hash:" prefix
    if (isHashBasedKey(episodeKey)) {
      return episodeKey.substring(5) // Remove "hash:" prefix
    }

    // For GUID-based keys, replace unsafe filename characters
    // Replace: / \ : * ? " < > | with underscores
    return episodeKey.replace(/[/\\:*?"<>|]/g, '_')
  }

  /**
   * Clear Cache
   *
   * Useful for testing or forcing reload of fixtures.
   */
  clearCache(): void {
    this.adSegmentCache.clear()
    this.taggerProfileCache.clear()
    this.episodeAdDataCache.clear()
  }

  /**
   * Preload Fixtures
   *
   * Preloads fixtures for multiple episodes (useful for prefetching).
   *
   * @param episodeKeys Array of episode keys to preload
   */
  async preloadFixtures(episodeKeys: string[]): Promise<void> {
    await Promise.all(episodeKeys.map((key) => this.fetchAdSegments(key)))
  }
}

/**
 * Singleton Instance
 *
 * Export a singleton instance for convenience.
 * Can be replaced with dependency injection in the future.
 */
export const fixtureAdSegmentProvider = new FixtureAdSegmentProvider()

/**
 * Create Mock Provider (for Testing)
 *
 * Creates a provider with mock data for unit tests.
 *
 * @param mockData Mock ad segments and profiles
 * @returns Mock provider instance
 */
export function createMockAdSegmentProvider(mockData: {
  adSegments?: Record<string, AdSegment[]>
  profiles?: TaggerProfile[]
}): AdSegmentProvider {
  return {
    async fetchAdSegments(episodeKey: string): Promise<AdSegment[]> {
      return mockData.adSegments?.[episodeKey] || []
    },

    async fetchTaggerProfile(pubkey: string): Promise<TaggerProfile | null> {
      return mockData.profiles?.find((p) => p.pubkey === pubkey) || null
    },

    async fetchEpisodeAdData(episodeKey: string): Promise<EpisodeAdData | null> {
      const segments = mockData.adSegments?.[episodeKey]
      if (!segments) return null

      return {
        episodeKey,
        adSegments: segments,
      }
    },
  }
}

// TODO: Future Nostr Integration Points
// - Implement NostrAdSegmentProvider class
// - Query Nostr relays for ad segment events (define custom NIP or use NIP-XX)
// - Implement relay connection pooling and caching
// - Add support for real-time updates via WebSocket subscriptions
// - Integrate with Nostr profile fetching (NIP-01 kind 0 events)
// - Add support for zap-based validation (NIP-57)
// - Consider implementing provider registry pattern for easy swapping:
//   providerRegistry.register('nostr', new NostrAdSegmentProvider())
//   providerRegistry.setActive('nostr')