//
// Copyright (c) Double Symmetry GmbH
// Commercial use requires a license. See https://rntp.dev/pricing
//

import XCTest
@testable import PlayerCore

final class CacheProxyServerTests: XCTestCase {
  private var cacheDir: URL!
  private var cache: AudioCache!
  private var coordinator: DownloadCoordinator!
  private var proxy: CacheProxyServer!

  override func setUp() {
    super.setUp()
    cacheDir = FileManager.default.temporaryDirectory
      .appendingPathComponent("CacheProxyServerTests-\(UUID().uuidString)", isDirectory: true)
    cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
    coordinator = DownloadCoordinator(cache: cache)
    proxy = try! CacheProxyServer(coordinator: coordinator, cache: cache)
    proxy.start()
  }

  override func tearDown() {
    proxy.stop()
    coordinator.cancelAll()
    proxy = nil
    coordinator = nil
    try? FileManager.default.removeItem(at: cacheDir)
    super.tearDown()
  }

  // MARK: - Helpers

  /// Perform a synchronous HTTP GET through the proxy and return (data, response).
  private func fetch(_ url: URL, timeout: TimeInterval = 10.0) throws -> (Data, HTTPURLResponse) {
    let expectation = self.expectation(description: "fetch \(url)")
    var resultData: Data?
    var resultResponse: HTTPURLResponse?
    var resultError: Error?

    let task = URLSession.shared.dataTask(with: url) { data, response, error in
      resultData = data
      resultResponse = response as? HTTPURLResponse
      resultError = error
      expectation.fulfill()
    }
    task.resume()
    wait(for: [expectation], timeout: timeout)

    if let error = resultError { throw error }
    return (resultData ?? Data(), resultResponse!)
  }

  // MARK: - 1. Cache miss with Content-Length

  func testCacheMissWithContentLength() throws {
    let testData = Data(repeating: 0xAA, count: 4096)
    let server = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    server.start()
    defer { server.stop() }

    let upstreamURL = server.url
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)

    let (data, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data, testData, "Proxy should return the full audio data")

    // Verify it was cached
    let key = cache.cacheKey(for: upstreamURL)
    // Give a moment for the download completion handler to finalize
    Thread.sleep(forTimeInterval: 0.5)
    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
    XCTAssertTrue(cache.isFullyCached(key: key))
  }

  // MARK: - 2. Cache miss without Content-Length

  func testCacheMissWithoutContentLength() throws {
    let testData = Data(repeating: 0xBB, count: 2048)
    let server = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: false, contentType: "audio/aac")
    )
    server.start()
    defer { server.stop() }

    let upstreamURL = server.url
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)

    let (data, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data, testData)

    // Content length should be finalized after download completes
    let key = cache.cacheKey(for: upstreamURL)
    Thread.sleep(forTimeInterval: 0.5)
    let info = cache.contentInfo(for: key)
    XCTAssertNotNil(info)
    XCTAssertEqual(info?.contentLength, Int64(testData.count),
                   "Content length should be finalized after download")
  }

  // MARK: - 3. Cache hit

  func testCacheHitServesFromDisk() throws {
    let testData = Data(repeating: 0xCC, count: 1024)
    let fakeURL = URL(string: "https://example.com/cached-track.mp3")!
    let key = cache.cacheKey(for: fakeURL)

    // Pre-populate cache
    let info = AudioCache.ContentInfo(
      contentType: "audio/mpeg",
      contentLength: Int64(testData.count),
      isByteRangeAccessSupported: false
    )
    cache.storeContentInfo(info, for: key, url: fakeURL)
    cache.appendData(testData, for: key)

    let proxyURL = proxy.proxyURL(for: fakeURL, headers: nil)
    let (data, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data, testData)
    // Cache hit should include Content-Length
    let contentLength = response.value(forHTTPHeaderField: "Content-Length")
    XCTAssertEqual(contentLength, "\(testData.count)")
  }

  // MARK: - 4. Partial cache + resume

  func testPartialCacheResumesDownload() throws {
    let testData = Data(repeating: 0xDD, count: 4000)
    let server = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    server.start()
    defer { server.stop() }

    let upstreamURL = server.url
    let key = cache.cacheKey(for: upstreamURL)

    // Pre-populate partial cache (first 1000 bytes)
    let partialData = testData.prefix(1000)
    let info = AudioCache.ContentInfo(
      contentType: "audio/mpeg",
      contentLength: Int64(testData.count),
      isByteRangeAccessSupported: false
    )
    cache.storeContentInfo(info, for: key, url: upstreamURL)
    cache.appendData(partialData, for: key)

    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
    let (data, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 200)
    // The proxy should serve the full data (partial cached + remainder from upstream).
    // Note: LocalAudioServer doesn't support Range requests, so it returns the full file.
    // The DownloadCoordinator appends only new data beyond what's cached.
    // However, since LocalAudioServer returns 200 (not 206), the coordinator will
    // append the full response. The proxy streams whatever is in the cache.
    // The important thing is the client gets data and no error occurs.
    XCTAssertGreaterThanOrEqual(data.count, testData.count)

    Thread.sleep(forTimeInterval: 0.5)
    XCTAssertGreaterThanOrEqual(cache.cachedBytes(for: key), Int64(testData.count))
  }

  // MARK: - 5. Upstream failure

  func testUpstreamFailureReturns502() throws {
    // Use a URL that will fail (nothing listening on this port)
    let badURL = URL(string: "http://localhost:1/nonexistent.mp3")!
    let proxyURL = proxy.proxyURL(for: badURL, headers: nil)

    let (_, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 502, "Should return 502 for upstream failure")
  }

  // MARK: - 6. Preload then play (shared download)

  func testPreloadThenPlaySharesDownload() throws {
    let testData = Data(repeating: 0xEE, count: 8000)
    let server = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    server.start()
    defer { server.stop() }

    let upstreamURL = server.url

    // Start a preload via the coordinator directly
    let preloadDone = expectation(description: "preload done")
    coordinator.download(url: upstreamURL, headers: nil) { result in
      if case .success = result { preloadDone.fulfill() }
    }

    // Immediately make a proxy request — it should attach to the same download
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
    let (data, response) = try fetch(proxyURL)

    wait(for: [preloadDone], timeout: 10.0)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data, testData)

    // Only one download should have been active
    let key = cache.cacheKey(for: upstreamURL)
    XCTAssertTrue(cache.isFullyCached(key: key))
  }

  // MARK: - 7. Large cached file serves completely via serveFromCache

  func testLargeCacheHitServesCompletely() throws {
    // Simulate a fully-cached podcast file (50MB).
    // This tests the serveFromCache 64KB chunked send path.
    let size = 50 * 1024 * 1024
    let testData = Data(repeating: 0x66, count: size)
    let url = URL(string: "https://example.com/big-podcast.mp3")!
    let key = cache.cacheKey(for: url)

    // Pre-populate cache.
    cache = AudioCache(maxSizeBytes: Int64(size + 1024 * 1024), directory: cacheDir)
    let info = AudioCache.ContentInfo(
      contentType: "audio/mpeg",
      contentLength: Int64(size),
      isByteRangeAccessSupported: true
    )
    cache.storeContentInfo(info, for: key, url: url)
    cache.appendData(testData, for: key)

    // Re-create proxy with the larger cache.
    proxy.stop()
    coordinator = DownloadCoordinator(cache: cache)
    proxy = try! CacheProxyServer(coordinator: coordinator, cache: cache)
    proxy.start()

    let proxyURL = proxy.proxyURL(for: url, headers: nil)
    let (data, response) = try fetch(proxyURL, timeout: 30.0)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data.count, size,
                   "All \(size) bytes should be served from cache (no Content-Length mismatch)")
  }

  // MARK: - 8. Large file over slow network streams completely

  func testLargeFileOverSlowNetworkStreamsCompletely() throws {
    // 5MB file with simulated slow network (64KB chunks, 10ms delay each).
    // This is ~780 chunks taking ~8 seconds — enough to expose races
    // between the coordinator writing to cache and the proxy reading it.
    let size = 5 * 1024 * 1024
    let testData = Data(repeating: 0x55, count: size)
    let upstream = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg", simulateSlowNetwork: true)
    )
    upstream.start()
    defer { upstream.stop() }

    let upstreamURL = upstream.url
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
    let (data, response) = try fetch(proxyURL, timeout: 30.0)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data.count, size,
                   "All \(size) bytes should be delivered over slow connection")

    let key = cache.cacheKey(for: upstreamURL)
    XCTAssertTrue(cache.isFullyCached(key: key))
  }

  // MARK: - 9. Large file streams completely from upstream

  func testLargeFileStreamsCompletely() throws {
    // Simulate a podcast-sized file (10MB — large enough to expose
    // chunking race conditions).
    let testData = Data(repeating: 0x77, count: 10 * 1024 * 1024)
    let upstream = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    upstream.start()
    defer { upstream.stop() }

    let upstreamURL = upstream.url
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
    let (data, response) = try fetch(proxyURL, timeout: 30.0)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data.count, testData.count,
                   "All bytes should be delivered (no Content-Length mismatch)")

    let key = cache.cacheKey(for: upstreamURL)
    XCTAssertTrue(cache.isFullyCached(key: key))
    XCTAssertEqual(cache.cachedBytes(for: key), Int64(testData.count))
  }

  // MARK: - 8. Cache hit after full download serves correctly

  func testCacheHitAfterDownload() throws {
    let testData = Data(repeating: 0x88, count: 512 * 1024)
    let upstream = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    upstream.start()

    let upstreamURL = upstream.url
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)

    // First fetch — downloads and caches.
    let (data1, _) = try fetch(proxyURL)
    XCTAssertEqual(data1.count, testData.count)

    // Stop upstream — second fetch must come from cache.
    upstream.stop()

    let (data2, response2) = try fetch(proxyURL)
    XCTAssertEqual(response2.statusCode, 200)
    XCTAssertEqual(data2.count, testData.count)
    XCTAssertEqual(data2, testData, "Cache hit should serve identical data")
  }

  // MARK: - 10. Preload then play serves from cache

  func testPreloadThenPlayServesFromCache() throws {
    let testData = Data(repeating: 0x99, count: 4096)
    let upstream = try LocalAudioServer(
      audioData: testData,
      options: .init(includeContentLength: true, contentType: "audio/mpeg")
    )
    upstream.start()
    defer { upstream.stop() }

    let upstreamURL = upstream.url
    let key = cache.cacheKey(for: upstreamURL)

    // Preload via coordinator (simulating TrackPlayer.preload)
    let preloadDone = expectation(description: "preload complete")
    coordinator.download(url: upstreamURL, headers: nil, cacheKey: key) { _ in
      preloadDone.fulfill()
    }
    wait(for: [preloadDone], timeout: 5.0)

    XCTAssertTrue(cache.isFullyCached(key: key))

    // Now fetch via proxy (simulating playback) — should be a cache hit
    let proxyURL = proxy.proxyURL(for: upstreamURL, headers: nil)
    let (data, response) = try fetch(proxyURL)

    XCTAssertEqual(response.statusCode, 200)
    XCTAssertEqual(data.count, testData.count)
  }

  // MARK: - 9. Range request on cache hit serves correct slice

  func testRangeRequestOnCacheHit() throws {
    let testData = Data((0..<1024).map { UInt8($0 % 256) })
    let url = URL(string: "https://example.com/range-test.mp3")!
    let key = cache.cacheKey(for: url)

    // Pre-populate full cache.
    let info = AudioCache.ContentInfo(
      contentType: "audio/mpeg",
      contentLength: Int64(testData.count),
      isByteRangeAccessSupported: true
    )
    cache.storeContentInfo(info, for: key, url: url)
    cache.appendData(testData, for: key)

    // Request bytes 500-799.
    let proxyURL = proxy.proxyURL(for: url, headers: nil)
    var request = URLRequest(url: proxyURL)
    request.setValue("bytes=500-799", forHTTPHeaderField: "Range")

    let expectation = self.expectation(description: "range fetch")
    var resultData: Data?
    var resultResponse: HTTPURLResponse?

    let task = URLSession.shared.dataTask(with: request) { data, response, _ in
      resultData = data
      resultResponse = response as? HTTPURLResponse
      expectation.fulfill()
    }
    task.resume()
    wait(for: [expectation], timeout: 5.0)

    XCTAssertEqual(resultResponse?.statusCode, 206)
    XCTAssertEqual(resultData?.count, 300)
    XCTAssertEqual(resultData, testData.subdata(in: 500..<800))
  }
}