adSegmentMerge.ts

/**
 * Ad Segment Merge and Deduplication Logic
 *
 * Handles merging overlapping ad segments into non-overlapping intervals.
 * Validates and filters invalid segments.
 *
 * KEY RULES:
 * - Ad segments must have both startTime AND endTime
 * - Invalid ads (endTime <= startTime or missing endTime) are dropped
 * - Overlapping ads are merged into single intervals
 * - Final adSegments are non-overlapping and sorted by startTime
 * - Ads are NOT clamped to chapter boundaries
 * - Ads may freely occur inside chapters
 */

import {
  AdSegment,
  MergedAdSegment,
  AdSegmentValidationError,
  AdSegmentValidationResult,
} from './adSegmentTypes'

/**
 * Validate Ad Segment
 *
 * Checks if an ad segment is valid according to POC rules.
 *
 * Valid if:
 * - Has endTime defined
 * - endTime > startTime (must have positive duration)
 * - startTime >= 0 (no negative times)
 * - Has taggerPubkey defined
 *
 * @param segment Ad segment to validate
 * @returns Validation result with errors if invalid
 */
export function validateAdSegment(segment: AdSegment): AdSegmentValidationResult {
  const errors: AdSegmentValidationError[] = []

  // Check for missing endTime
  if (segment.endTime === undefined || segment.endTime === null) {
    errors.push(AdSegmentValidationError.MISSING_END_TIME)
  }

  // Check for negative times
  if (segment.startTime < 0 || (segment.endTime !== undefined && segment.endTime < 0)) {
    errors.push(AdSegmentValidationError.NEGATIVE_TIME)
  }

  // Check for invalid time range (endTime <= startTime)
  if (segment.endTime !== undefined && segment.endTime <= segment.startTime) {
    errors.push(AdSegmentValidationError.INVALID_TIME_RANGE)
  }

  // Check for missing tagger
  if (!segment.taggerPubkey || segment.taggerPubkey.trim().length === 0) {
    errors.push(AdSegmentValidationError.MISSING_TAGGER)
  }

  return {
    valid: errors.length === 0,
    errors,
    segment,
  }
}

/**
 * Filter Valid Ad Segments
 *
 * Removes invalid segments and logs warnings.
 *
 * @param segments Array of ad segments (may contain invalid entries)
 * @param logWarnings Whether to log validation errors to console (default: true)
 * @returns Array of valid ad segments only
 */
export function filterValidAdSegments(segments: AdSegment[], logWarnings = true): AdSegment[] {
  const validSegments: AdSegment[] = []

  for (const segment of segments) {
    const validation = validateAdSegment(segment)

    if (validation.valid) {
      validSegments.push(segment)
    } else if (logWarnings) {
      console.warn(
        `[AdSegments] Dropping invalid ad segment "${segment.id}":`,
        validation.errors.join(', '),
        segment
      )
    }
  }

  return validSegments
}

/**
 * Merge Overlapping Ad Segments
 *
 * Combines overlapping or adjacent ad segments into non-overlapping intervals.
 * Uses interval merging algorithm (sort + single pass).
 *
 * Algorithm:
 * 1. Filter out invalid segments
 * 2. Sort by startTime (ascending)
 * 3. Merge overlapping intervals using single-pass algorithm
 * 4. Track source segment IDs and taggers for attribution
 *
 * Time Complexity: O(n log n) due to sorting
 * Space Complexity: O(n)
 *
 * @param segments Array of ad segments (may be overlapping)
 * @returns Array of non-overlapping merged segments, sorted by startTime
 */
export function mergeAdSegments(segments: AdSegment[]): MergedAdSegment[] {
  // Step 1: Filter valid segments only
  const validSegments = filterValidAdSegments(segments)

  if (validSegments.length === 0) {
    return []
  }

  // Step 2: Sort by startTime (ascending)
  const sorted = [...validSegments].sort((a, b) => a.startTime - b.startTime)

  // Step 3: Merge overlapping intervals
  const merged: MergedAdSegment[] = []

  let current: MergedAdSegment = {
    startTime: sorted[0].startTime,
    endTime: sorted[0].endTime,
    sourceSegmentIds: [sorted[0].id],
    primaryTaggerPubkey: sorted[0].taggerPubkey,
    allTaggerPubkeys: [sorted[0].taggerPubkey],
  }

  for (let i = 1; i < sorted.length; i++) {
    const segment = sorted[i]

    // Check if current segment overlaps or is adjacent to the merged interval
    // Overlapping: segment.startTime <= current.endTime
    // Adjacent: segment.startTime === current.endTime (no gap)
    if (segment.startTime <= current.endTime) {
      // Merge: extend endTime if needed, track source IDs and taggers
      current.endTime = Math.max(current.endTime, segment.endTime)
      current.sourceSegmentIds.push(segment.id)

      // Add tagger if not already present
      if (!current.allTaggerPubkeys.includes(segment.taggerPubkey)) {
        current.allTaggerPubkeys.push(segment.taggerPubkey)
      }
    } else {
      // No overlap: push current merged segment and start a new one
      merged.push(current)

      current = {
        startTime: segment.startTime,
        endTime: segment.endTime,
        sourceSegmentIds: [segment.id],
        primaryTaggerPubkey: segment.taggerPubkey,
        allTaggerPubkeys: [segment.taggerPubkey],
      }
    }
  }

  // Push the last merged segment
  merged.push(current)

  return merged
}

/**
 * Find Ad Segment at Time
 *
 * Returns the merged ad segment (if any) that contains the given time.
 * Uses binary search for O(log n) lookup (assumes merged segments are sorted).
 *
 * @param mergedSegments Array of non-overlapping merged segments (sorted by startTime)
 * @param timeSeconds Current playback time in seconds
 * @returns Merged segment containing the time, or null if not in an ad
 */
export function findAdSegmentAtTime(
  mergedSegments: MergedAdSegment[],
  timeSeconds: number
): MergedAdSegment | null {
  if (mergedSegments.length === 0) {
    return null
  }

  // Binary search for efficiency (segments are sorted by startTime)
  let left = 0
  let right = mergedSegments.length - 1

  while (left <= right) {
    const mid = Math.floor((left + right) / 2)
    const segment = mergedSegments[mid]

    // Check if time is within this segment [startTime, endTime)
    if (timeSeconds >= segment.startTime && timeSeconds < segment.endTime) {
      return segment
    }

    // Time is before this segment
    if (timeSeconds < segment.startTime) {
      right = mid - 1
    }
    // Time is after this segment
    else {
      left = mid + 1
    }
  }

  return null
}

/**
 * Generate Ad Segment ID
 *
 * Creates a unique ID for a merged ad segment based on time range.
 * Format: "ad_{startTime}_{endTime}"
 *
 * @param startTime Start time in seconds
 * @param endTime End time in seconds
 * @returns Unique segment ID
 */
export function generateAdSegmentId(startTime: number, endTime: number): string {
  return `ad_${startTime.toFixed(3)}_${endTime.toFixed(3)}`
}

/**
 * Check if Ad Segments Overlap
 *
 * Returns true if two ad segments overlap (including touching at boundary).
 *
 * @param a First ad segment
 * @param b Second ad segment
 * @returns True if segments overlap or touch, false otherwise
 */
export function adSegmentsOverlap(a: AdSegment, b: AdSegment): boolean {
  return a.startTime < b.endTime && b.startTime < a.endTime
}

/**
 * Calculate Ad Segment Statistics
 *
 * Computes useful stats about ad segments for debugging/logging.
 *
 * @param segments Array of ad segments
 * @returns Statistics object
 */
export function calculateAdSegmentStats(segments: AdSegment[]) {
  if (segments.length === 0) {
    return {
      count: 0,
      totalDuration: 0,
      averageDuration: 0,
      minDuration: 0,
      maxDuration: 0,
    }
  }

  const durations = segments.map((s) => s.endTime - s.startTime)
  const totalDuration = durations.reduce((sum, d) => sum + d, 0)

  return {
    count: segments.length,
    totalDuration,
    averageDuration: totalDuration / segments.length,
    minDuration: Math.min(...durations),
    maxDuration: Math.max(...durations),
  }
}

/**
 * Calculate Merged Ad Segment Statistics
 *
 * Computes stats for merged segments (after deduplication).
 *
 * @param mergedSegments Array of merged ad segments
 * @returns Statistics object including reduction percentage
 */
export function calculateMergedAdSegmentStats(
  originalSegments: AdSegment[],
  mergedSegments: MergedAdSegment[]
) {
  const originalCount = originalSegments.length
  const mergedCount = mergedSegments.length
  const reduction = originalCount > 0 ? ((originalCount - mergedCount) / originalCount) * 100 : 0

  const mergedDurations = mergedSegments.map((s) => s.endTime - s.startTime)
  const totalDuration = mergedDurations.reduce((sum, d) => sum + d, 0)

  return {
    originalCount,
    mergedCount,
    reductionPercent: reduction.toFixed(1),
    totalDuration,
    averageDuration: mergedCount > 0 ? totalDuration / mergedCount : 0,
    minDuration: mergedDurations.length > 0 ? Math.min(...mergedDurations) : 0,
    maxDuration: mergedDurations.length > 0 ? Math.max(...mergedDurations) : 0,
  }
}

// TODO: Future Nostr Integration Points
// - Add support for confidence scoring based on multiple taggers
// - Add support for reputation-weighted merging (trusted taggers take precedence)
// - Add support for zap-based validation (paid votes increase confidence)
// - Consider adding conflict resolution strategies (e.g., majority vote, weighted average)