import Foundation
import RastrilloApple
import RastrilloTestSupport
import XCTest
@testable import DocsKit

/// Stands in for NativeConnection: which transport the account has right now.
@MainActor private final class Session {
    var current: NativeTransport?
    init(_ current: NativeTransport?) { self.current = current }
}

private func list(_ titles: [String]) -> Data {
    let documents = titles.enumerated().map { #"{"sqid":"d\#($0.offset)","title":"\#($0.element)"}"# }
    return Data(#"{"documents":[\#(documents.joined(separator: ","))],"can_create":true}"#.utf8)
}

/// A server for one writable, empty document: its stream stays open without
/// events, and every update is accepted. Answers by request, since the model's
/// stream and saves race.
private func documentServer() -> ScriptedTransport {
    ScriptedTransport { call in
        switch (call.kind, call.method, call.path) {
        case (.request, "GET", "/d/doc"):
            return .respond(status: 200, body: Data(#"{"sqid":"doc","title":"Doc","guid":"doc-guid","can_write":true,"can_share":false}"#.utf8))
        case (.request, "GET", "/d/doc/updates"):
            return .respond(status: 200, headers: ["Docs-Seq": "0"])
        case (.stream, _, "/d/doc/stream"):
            return .hang
        case (.request, "POST", "/d/doc/updates"):
            return .respond(status: 204)
        default:
            return nil
        }
    }
}

final class TransportSupplierTests: XCTestCase {
    @MainActor func testEachRequestUsesTheSessionsCurrentTransport() async {
        let first = ScriptedTransport([.respond(status: 200, body: list(["Before"]))])
        let replacement = ScriptedTransport([.respond(status: 200, body: list(["After", "Signing in again"]))])
        let session = Session(first)
        let model = DocsModel(transport: { session.current })
        await model.load()
        XCTAssertEqual(model.documents.map(\.title), ["Before"])
        session.current = replacement
        await model.load()
        XCTAssertEqual(model.listState, .loaded)
        XCTAssertEqual(model.documents.map(\.title), ["After", "Signing in again"])
        XCTAssertEqual(first.calls.count, 1, "The model kept using the transport it was created with")
        XCTAssertEqual(replacement.calls.count, 1)
    }

    /// The case the supplier exists for: an edit made while one session
    /// is in place is sent with whichever session is current when it is sent.
    @MainActor func testUnsentEditGoesOutOnTheReplacementTransport() async throws {
        let ended = documentServer()
        let session = Session(ended)
        let model = DocsModel(transport: { session.current })
        await model.open("doc")
        XCTAssertEqual(model.detail?.sqid, "doc")
        let deadline = ContinuousClock.now.advanced(by: .seconds(5))
        // Opening an empty document inserts its first paragraph and saves it.
        while model.hasUnsavedChanges && .now < deadline { try await Task.sleep(for: .milliseconds(10)) }
        XCTAssertFalse(model.hasUnsavedChanges)
        let sentBefore = ended.committed.filter { $0.method == "POST" }.count

        let replacement = documentServer()
        session.current = replacement
        model.didRender(model.projectionGeneration)
        XCTAssertTrue(model.enqueue(["op": .string("display_edit"), "at": .number(0), "length": .number(0), "text": .string("Hello")]))
        while model.hasUnsavedChanges && .now < deadline { try await Task.sleep(for: .milliseconds(10)) }
        XCTAssertFalse(model.hasUnsavedChanges, "The edit was never acknowledged")

        XCTAssertEqual(ended.committed.filter { $0.method == "POST" }.count, sentBefore, "The edit went out on the ended session")
        XCTAssertEqual(replacement.committed.map(\.path), ["/d/doc/updates"])
        await model.discardAll()
    }
}