import Foundation
import Testing
@testable import IrdP2PSignaling

/// Against the real Go signal (open mint) and mailbox servers on loopback.
@Suite(.enabled(if: LocalServers.isAvailable), .serialized) struct MailboxServerTests {
    @Test func mintDepositReplayDedupAndGap() async throws {
        let servers = try LocalServers()
        defer { servers.stop() }
        try await servers.waitUntilReady()
        let http = URLSessionHTTPTransport()
        let mint = OpenMintTokenProvider(mintURL: servers.signalBase.appendingPathComponent("mailbox-credentials"), origin: LocalServers.origin, http: http, ttlSeconds: 600)
        let client = MailboxClient(endpoint: servers.mailboxBase, tokens: mint, http: http)
        let room = "/orbitdb/zdpu\(UUID().uuidString)/chat"

        let d1 = try await client.deposit(room: room, Data("first".utf8))
        #expect(!d1.deduped)
        let d2 = try await client.deposit(room: room, Data("first".utf8))
        #expect(d2.deduped && d2.seq == d1.seq)
        let d3 = try await client.deposit(room: room, Data([0x02, 0xff, 0x00]))
        #expect(d3.seq > d1.seq)

        let page = try await client.replay(room: room, limit: 100)
        #expect(page.messages.map(\.payload) == [Data("first".utf8), Data([0x02, 0xff, 0x00])])
        #expect(page.oldestSeq == d1.seq && page.latestSeq == d3.seq && !page.hasMore)

        let tail = try await client.replayAll(room: room, after: d1.seq)
        #expect(tail.messages.map(\.seq) == [d3.seq] && tail.cursor == d3.seq && !tail.gap)
        let gap = try await client.replayAll(room: room, after: MailboxSeq("1"))
        #expect(gap.gap)

        // a token minted for another room is out of scope
        let scoped = OpenMintTokenProvider(mintURL: servers.signalBase.appendingPathComponent("mailbox-credentials"), origin: LocalServers.origin, http: http, ttlSeconds: 600, scopeToRoom: true)
        let scopedClient = MailboxClient(endpoint: servers.mailboxBase, tokens: StaticTokenProvider { _ in try await scoped.token(for: "elsewhere") }, http: http)
        do {
            _ = try await scopedClient.deposit(room: room, Data([1]))
            Issue.record("expected token_out_of_scope")
        } catch let e as P2PError {
            #expect(e.mailboxCode == .tokenOutOfScope)
        }
    }

    @Test func mintRequiresAnAllowedOriginAndOversizeIs413() async throws {
        let servers = try LocalServers()
        defer { servers.stop() }
        try await servers.waitUntilReady()
        let http = URLSessionHTTPTransport()
        let noOrigin = OpenMintTokenProvider(mintURL: servers.signalBase.appendingPathComponent("mailbox-credentials"), origin: nil, http: http)
        do { _ = try await noOrigin.token(for: "r"); Issue.record("expected 403") } catch let e as P2PError {
            if case .http(let status, _, _) = e { #expect(status == 403) } else { Issue.record("wrong error \(e)") }
        }
        let mint = OpenMintTokenProvider(mintURL: servers.signalBase.appendingPathComponent("mailbox-credentials"), origin: LocalServers.origin, http: http)
        let client = MailboxClient(endpoint: servers.mailboxBase, tokens: mint, http: http)
        do { _ = try await client.deposit(room: "big", Data(count: 65 * 1024)); Issue.record("expected 413") } catch let e as P2PError {
            #expect(e.mailboxCode == .messageTooLarge)
        }
    }
}