adSegmentMerge.test.ts

/**
 * Unit Tests for Ad Segment Merge Logic
 *
 * Tests cover all required POC scenarios:
 * 1. Ad inside a chapter (skip occurs, chapter unchanged)
 * 2. Two overlapping ads merged/deduped
 * 3. Ad touching chapter boundary exactly
 * 4. Invalid ad dropped
 * 5. Scrub backwards into ad → skip again (tested in playerAdSkip.test.ts)
 */

import {
  validateAdSegment,
  filterValidAdSegments,
  mergeAdSegments,
  findAdSegmentAtTime,
  adSegmentsOverlap,
} from '~/services/adSegments/adSegmentMerge'
import { AdSegment, AdSegmentValidationError } from '~/services/adSegments/adSegmentTypes'

describe('Ad Segment Validation', () => {
  test('valid ad segment passes validation', () => {
    const segment: AdSegment = {
      id: 'ad-001',
      startTime: 10,
      endTime: 40,
      taggerPubkey: 'npub1test',
    }

    const result = validateAdSegment(segment)

    expect(result.valid).toBe(true)
    expect(result.errors).toHaveLength(0)
  })

  test('invalid ad: missing endTime', () => {
    const segment: any = {
      id: 'ad-002',
      startTime: 10,
      taggerPubkey: 'npub1test',
      // endTime missing
    }

    const result = validateAdSegment(segment)

    expect(result.valid).toBe(false)
    expect(result.errors).toContain(AdSegmentValidationError.MISSING_END_TIME)
  })

  test('invalid ad: endTime <= startTime', () => {
    const segment: AdSegment = {
      id: 'ad-003',
      startTime: 100,
      endTime: 100, // Equal to startTime
      taggerPubkey: 'npub1test',
    }

    const result = validateAdSegment(segment)

    expect(result.valid).toBe(false)
    expect(result.errors).toContain(AdSegmentValidationError.INVALID_TIME_RANGE)
  })

  test('invalid ad: negative times', () => {
    const segment: AdSegment = {
      id: 'ad-004',
      startTime: -10,
      endTime: 20,
      taggerPubkey: 'npub1test',
    }

    const result = validateAdSegment(segment)

    expect(result.valid).toBe(false)
    expect(result.errors).toContain(AdSegmentValidationError.NEGATIVE_TIME)
  })

  test('invalid ad: missing tagger', () => {
    const segment: AdSegment = {
      id: 'ad-005',
      startTime: 10,
      endTime: 20,
      taggerPubkey: '',
    }

    const result = validateAdSegment(segment)

    expect(result.valid).toBe(false)
    expect(result.errors).toContain(AdSegmentValidationError.MISSING_TAGGER)
  })
})

describe('Filter Valid Ad Segments', () => {
  test('filters out invalid segments', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 40, taggerPubkey: 'npub1test' }, // Valid
      { id: 'ad-002', startTime: 50, endTime: 50, taggerPubkey: 'npub1test' }, // Invalid (endTime == startTime)
      { id: 'ad-003', startTime: 60, endTime: 90, taggerPubkey: 'npub1test' }, // Valid
      { id: 'ad-004', startTime: 100, endTime: 80, taggerPubkey: 'npub1test' }, // Invalid (endTime < startTime)
    ]

    const valid = filterValidAdSegments(segments, false)

    expect(valid).toHaveLength(2)
    expect(valid[0].id).toBe('ad-001')
    expect(valid[1].id).toBe('ad-003')
  })
})

describe('Merge Overlapping Ad Segments', () => {
  test('merges two overlapping ads', () => {
    const segments: AdSegment[] = [
      {
        id: 'ad-001',
        startTime: 10,
        endTime: 30,
        taggerPubkey: 'npub1tagger1',
      },
      {
        id: 'ad-002',
        startTime: 25,
        endTime: 50,
        taggerPubkey: 'npub1tagger2',
      },
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(1)
    expect(merged[0].startTime).toBe(10)
    expect(merged[0].endTime).toBe(50)
    expect(merged[0].sourceSegmentIds).toEqual(['ad-001', 'ad-002'])
    expect(merged[0].allTaggerPubkeys).toEqual(['npub1tagger1', 'npub1tagger2'])
  })

  test('merges adjacent ads (touching boundaries)', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' },
      { id: 'ad-002', startTime: 30, endTime: 50, taggerPubkey: 'npub1test' }, // Starts exactly where ad-001 ends
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(1)
    expect(merged[0].startTime).toBe(10)
    expect(merged[0].endTime).toBe(50)
  })

  test('does not merge non-overlapping ads', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' },
      { id: 'ad-002', startTime: 50, endTime: 70, taggerPubkey: 'npub1test' },
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(2)
    expect(merged[0].startTime).toBe(10)
    expect(merged[0].endTime).toBe(30)
    expect(merged[1].startTime).toBe(50)
    expect(merged[1].endTime).toBe(70)
  })

  test('merges multiple overlapping ads into one', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test1' },
      { id: 'ad-002', startTime: 20, endTime: 40, taggerPubkey: 'npub1test2' },
      { id: 'ad-003', startTime: 35, endTime: 60, taggerPubkey: 'npub1test3' },
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(1)
    expect(merged[0].startTime).toBe(10)
    expect(merged[0].endTime).toBe(60)
    expect(merged[0].sourceSegmentIds).toEqual(['ad-001', 'ad-002', 'ad-003'])
    expect(merged[0].allTaggerPubkeys).toHaveLength(3)
  })

  test('handles empty input', () => {
    const merged = mergeAdSegments([])
    expect(merged).toHaveLength(0)
  })

  test('handles single ad segment', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' },
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(1)
    expect(merged[0].startTime).toBe(10)
    expect(merged[0].endTime).toBe(30)
  })

  test('filters invalid ads before merging', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' }, // Valid
      { id: 'ad-002', startTime: 40, endTime: 40, taggerPubkey: 'npub1test' }, // Invalid
      { id: 'ad-003', startTime: 50, endTime: 70, taggerPubkey: 'npub1test' }, // Valid
    ]

    const merged = mergeAdSegments(segments)

    // Should only merge the 2 valid segments
    expect(merged).toHaveLength(2)
  })
})

describe('Find Ad Segment at Time', () => {
  const mergedSegments = [
    { startTime: 10, endTime: 30, sourceSegmentIds: ['ad-001'], primaryTaggerPubkey: 'npub1test', allTaggerPubkeys: ['npub1test'] },
    { startTime: 50, endTime: 70, sourceSegmentIds: ['ad-002'], primaryTaggerPubkey: 'npub1test', allTaggerPubkeys: ['npub1test'] },
    { startTime: 100, endTime: 120, sourceSegmentIds: ['ad-003'], primaryTaggerPubkey: 'npub1test', allTaggerPubkeys: ['npub1test'] },
  ]

  test('finds ad segment at time within range', () => {
    const found = findAdSegmentAtTime(mergedSegments, 20)
    expect(found).not.toBeNull()
    expect(found?.startTime).toBe(10)
    expect(found?.endTime).toBe(30)
  })

  test('finds ad segment at start time (inclusive)', () => {
    const found = findAdSegmentAtTime(mergedSegments, 50)
    expect(found).not.toBeNull()
    expect(found?.startTime).toBe(50)
  })

  test('does NOT find ad segment at end time (exclusive)', () => {
    const found = findAdSegmentAtTime(mergedSegments, 70)
    expect(found).toBeNull()
  })

  test('returns null when time is before all ads', () => {
    const found = findAdSegmentAtTime(mergedSegments, 5)
    expect(found).toBeNull()
  })

  test('returns null when time is after all ads', () => {
    const found = findAdSegmentAtTime(mergedSegments, 200)
    expect(found).toBeNull()
  })

  test('returns null when time is in gap between ads', () => {
    const found = findAdSegmentAtTime(mergedSegments, 80)
    expect(found).toBeNull()
  })

  test('handles empty segment list', () => {
    const found = findAdSegmentAtTime([], 50)
    expect(found).toBeNull()
  })
})

describe('Ad Segments Overlap Check', () => {
  test('detects overlapping segments', () => {
    const a: AdSegment = { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' }
    const b: AdSegment = { id: 'ad-002', startTime: 20, endTime: 40, taggerPubkey: 'npub1test' }

    expect(adSegmentsOverlap(a, b)).toBe(true)
    expect(adSegmentsOverlap(b, a)).toBe(true)
  })

  test('detects touching segments (boundaries meet)', () => {
    const a: AdSegment = { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' }
    const b: AdSegment = { id: 'ad-002', startTime: 30, endTime: 50, taggerPubkey: 'npub1test' }

    expect(adSegmentsOverlap(a, b)).toBe(false) // Half-open intervals: [10, 30) and [30, 50) don't overlap
  })

  test('detects non-overlapping segments', () => {
    const a: AdSegment = { id: 'ad-001', startTime: 10, endTime: 30, taggerPubkey: 'npub1test' }
    const b: AdSegment = { id: 'ad-002', startTime: 50, endTime: 70, taggerPubkey: 'npub1test' }

    expect(adSegmentsOverlap(a, b)).toBe(false)
  })
})

describe('POC Test Scenarios', () => {
  test('Scenario 1: Ad inside a chapter', () => {
    // Chapter: 0-300s
    // Ad: 100-130s (inside chapter)
    const adSegment: AdSegment = {
      id: 'ad-001',
      startTime: 100,
      endTime: 130,
      taggerPubkey: 'npub1test',
    }

    // Ad is valid and not affected by chapter boundaries
    const validation = validateAdSegment(adSegment)
    expect(validation.valid).toBe(true)

    // Chapter remains unchanged (chapters are independent from ads)
    const chapterStart = 0
    const chapterEnd = 300

    // Ad occurs within chapter but doesn't split it
    expect(adSegment.startTime).toBeGreaterThanOrEqual(chapterStart)
    expect(adSegment.endTime).toBeLessThanOrEqual(chapterEnd)
  })

  test('Scenario 2: Two overlapping ads merged', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 50, endTime: 80, taggerPubkey: 'npub1test1' },
      { id: 'ad-002', startTime: 70, endTime: 100, taggerPubkey: 'npub1test2' },
    ]

    const merged = mergeAdSegments(segments)

    expect(merged).toHaveLength(1)
    expect(merged[0].startTime).toBe(50)
    expect(merged[0].endTime).toBe(100)
  })

  test('Scenario 3: Ad touching chapter boundary exactly', () => {
    // Chapter 1: 0-120s
    // Chapter 2: 120-300s
    // Ad: 100-120s (ends exactly at chapter boundary)

    const adSegment: AdSegment = {
      id: 'ad-001',
      startTime: 100,
      endTime: 120,
      taggerPubkey: 'npub1test',
    }

    const validation = validateAdSegment(adSegment)
    expect(validation.valid).toBe(true)

    // Ad is NOT clamped or modified based on chapter boundary
    expect(adSegment.endTime).toBe(120)
  })

  test('Scenario 4: Invalid ad dropped', () => {
    const segments: AdSegment[] = [
      { id: 'ad-001', startTime: 10, endTime: 40, taggerPubkey: 'npub1test' }, // Valid
      { id: 'ad-invalid', startTime: 100, endTime: 100, taggerPubkey: 'npub1test' }, // Invalid
      { id: 'ad-003', startTime: 150, endTime: 180, taggerPubkey: 'npub1test' }, // Valid
    ]

    const valid = filterValidAdSegments(segments, false)
    const merged = mergeAdSegments(segments)

    // Invalid ad should be filtered out
    expect(valid).toHaveLength(2)
    expect(merged).toHaveLength(2)

    // Check that invalid ad is not in results
    const invalidIds = merged.flatMap((m) => m.sourceSegmentIds)
    expect(invalidIds).not.toContain('ad-invalid')
  })
})