import Foundation
import XCTest
import RastrilloApple
import RastrilloTestSupport

private struct Empty: Decodable {}

private actor Lines {
  var values: [String] = []
  func append(_ value: String) { values.append(value) }
}

/// Each error class a consumer must tell apart, produced the way an app
/// meets it: through `request`, `stream` and `download` on a transport.
final class ScriptedTransportTests: XCTestCase {
  private func requestFailure(_ step: ScriptedTransport.Step,
                              file: StaticString = #filePath, line: UInt = #line) async -> Error? {
    let transport = ScriptedTransport([step])
    do {
      let _: Empty = try await transport.request("/x", method: "POST", body: Data("{}".utf8))
      XCTFail("The scripted step succeeded", file: file, line: line)
      return nil
    } catch { return error }
  }

  private func assertRequest(_ step: ScriptedTransport.Step, fails expected: NativeClientError,
                             _ retry: NativeClientError.RetryClass,
                             file: StaticString = #filePath, line: UInt = #line) async {
    let error = await requestFailure(step, file: file, line: line)
    guard let typed = error as? NativeClientError else {
      return XCTFail("Expected \(expected), got \(String(describing: error))", file: file, line: line)
    }
    XCTAssertEqual(typed, expected, file: file, line: line)
    XCTAssertEqual(typed.retryClass, retry, file: file, line: line)
  }

  func testOffline() async {
    await assertRequest(.offline(), fails: .offline(.notConnectedToInternet), .offline)
    await assertRequest(.offline(.timedOut), fails: .offline(.timedOut), .offline)
  }

  func testEndedSession() async {
    await assertRequest(.respond(status: 401), fails: .unauthorized, .auth)
    // NoRedirects surfaces the redirect to /signin as a 303.
    await assertRequest(.respond(status: 303, headers: ["Location": "/signin"]), fails: .unauthorized, .auth)
  }

  func testPermanentRefusals() async {
    await assertRequest(.respond(status: 403), fails: .forbidden, .permanent)
    await assertRequest(.respond(status: 404), fails: .notFound, .permanent)
    await assertRequest(.respond(status: 413), fails: .tooLarge, .permanent)
    await assertRequest(.respond(status: 400, body: Data("bad".utf8)),
                        fails: .rejected(status: 400, body: Data("bad".utf8)), .permanent)
    await assertRequest(.respond(status: 422), fails: .rejected(status: 422, body: Data()), .permanent)
  }

  func testConflictKeepsTheServersBody() async {
    let theirs = Data(#"{"value":"theirs"}"#.utf8)
    await assertRequest(.respond(status: 409, body: theirs), fails: .conflict(theirs), .conflict)
  }

  func testRateLimitedCarriesRetryAfter() async {
    await assertRequest(.respond(status: 429, headers: ["Retry-After": "7"]), fails: .rateLimited(retryAfter: 7), .transient)
    await assertRequest(.respond(status: 429), fails: .rateLimited(retryAfter: nil), .transient)
    // A 503 that says when to come back is a rate limit, not a fault.
    await assertRequest(.respond(status: 503, headers: ["retry-after": "3"]), fails: .rateLimited(retryAfter: 3), .transient)
  }

  func testServerFaults() async {
    await assertRequest(.respond(status: 500), fails: .server(status: 500), .transient)
    await assertRequest(.respond(status: 503), fails: .server(status: 503), .transient)
  }

  func testSuccessDecodesAndIsCommitted() async throws {
    let transport = ScriptedTransport([.respond(status: 201, body: Data("{}".utf8))])
    let _: Empty = try await transport.request("/notes", method: "POST", body: Data("{}".utf8))
    XCTAssertEqual(transport.committed.map(\.path), ["/notes"])
    XCTAssertEqual(transport.remainingSteps, 0)
  }

  func testResponseDetailsReturnsAnyStatus() async throws {
    let transport = ScriptedTransport([.respond(status: 401, headers: ["Docs-Seq": "4"])])
    let response = try await transport.responseDetails("/d/1")
    XCTAssertEqual(response.status, 401)
    XCTAssertEqual(response.header("docs-seq"), "4")
    XCTAssertThrowsError(try response.requireSuccess()) { XCTAssertEqual($0 as? NativeClientError, .unauthorized) }
    XCTAssertTrue(transport.committed.isEmpty, "A refused request was recorded as applied")
  }

  func testCommitThenLoseResponse() async {
    let transport = ScriptedTransport([.commitThenLoseResponse()])
    do {
      _ = try await transport.responseDetails("/d/1/updates", method: "POST", body: Data([1, 2]))
      XCTFail("A lost response succeeded")
    } catch {
      XCTAssertEqual(error as? NativeClientError, .offline(.networkConnectionLost))
      XCTAssertEqual((error as? NativeClientError)?.retryClass, .offline)
    }
    // The caller saw a failure, yet the server holds the write: the case a
    // durable outbox must not send twice in effect.
    XCTAssertEqual(transport.committed, [.init(kind: .request, path: "/d/1/updates", method: "POST", body: Data([1, 2]))])
  }

  func testHangUntilCancelled() async throws {
    let transport = ScriptedTransport([.hang])
    let task = Task { try await transport.responseDetails("/slow") }
    while transport.calls.isEmpty { try await Task.sleep(nanoseconds: 1_000_000) }
    task.cancel()
    do {
      _ = try await task.value
      XCTFail("A hung request completed")
    } catch { XCTAssertTrue(error is CancellationError, "Expected cancellation, got \(error)") }
  }

  func testRefusedStreamIsTyped() async {
    let transport = ScriptedTransport([.respond(status: 401), .offline()])
    do {
      try await transport.stream("/d/1/stream") { _ in XCTFail("A refused stream delivered a line") }
      XCTFail("A refused stream opened")
    } catch { XCTAssertEqual(error as? NativeClientError, .unauthorized) }
    do {
      try await transport.stream("/d/1/stream", onOpen: { XCTFail("An offline stream opened") }) { _ in }
      XCTFail("An offline stream opened")
    } catch { XCTAssertEqual(error as? NativeClientError, .offline(.notConnectedToInternet)) }
  }

  func testStreamOpensBeforeLines() async throws {
    let transport = ScriptedTransport([.respond(status: 200, body: Data("event: update\ndata: 42\n\n".utf8))])
    let lines = Lines()
    try await transport.stream("/d/1/stream", onOpen: { await lines.append("opened") }) { await lines.append($0) }
    let received = await lines.values
    XCTAssertEqual(received, ["opened", "event: update", "data: 42", ""])
  }

  func testDownloadWritesOrFailsTyped() async throws {
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false)
    defer { try? FileManager.default.removeItem(at: directory) }
    let transport = ScriptedTransport([.respond(status: 200, body: Data("12345".utf8)), .respond(status: 403)])
    let file = directory.appendingPathComponent("export.xlsx")
    try await transport.download("/export", to: file)
    XCTAssertEqual(try Data(contentsOf: file), Data("12345".utf8))
    do {
      try await transport.download("/export", to: directory.appendingPathComponent("again.xlsx"))
      XCTFail("A refused export succeeded")
    } catch { XCTAssertEqual(error as? NativeClientError, .forbidden) }
  }

  func testUnscriptedCallFailsLoudly() async {
    let transport = ScriptedTransport()
    do {
      _ = try await transport.responseDetails("/surprise")
      XCTFail("An unscripted call succeeded")
    } catch { XCTAssertTrue(error is ScriptedTransport.Unscripted, "Got \(error)") }
    XCTAssertEqual(transport.calls.map(\.path), ["/surprise"])
  }

  func testResponderAnswersRacingCallsByWhatTheyAsk() async throws {
    let transport = ScriptedTransport { call in
      switch (call.kind, call.path) {
      case (.stream, "/d/1/stream"): return .hang
      case (.request, "/d/1/updates"): return .respond(status: 204)
      default: return nil
      }
    }
    let listening = Task { try await transport.stream("/d/1/stream") { _ in } }
    let saved = try await transport.responseDetails("/d/1/updates", method: "POST", body: Data([7]))
    XCTAssertEqual(saved.status, 204)
    XCTAssertEqual(transport.committed.map(\.path), ["/d/1/updates"])
    do {
      _ = try await transport.responseDetails("/elsewhere")
      XCTFail("A declined call succeeded")
    } catch { XCTAssertTrue(error is ScriptedTransport.Unscripted, "Got \(error)") }
    listening.cancel()
    do { try await listening.value; XCTFail("A hung stream completed") } catch { XCTAssertTrue(error is CancellationError) }
  }
}