import Foundation
import Testing
@testable import gitbay

private func makeClient() throws -> (GitbayClient, StubProtocol.Box) {
    let box = StubProtocol.box()
    let client = GitbayClient(
        instance: try GitbayInstance(url: "https://gitbay.org"),
        token: "test-token",
        session: box.session()
    )
    return (client, box)
}

private let logJSON = """
    {"protocol_version":1,"data":[\
    {"sha":"aaaaaaaaaabbbbbbbbbb","subject":"only on side","author_name":"cmc",\
    "author_email":"c@x.test","date":"2026-08-28T02:00:00Z",\
    "signature":{"state":"unsigned"}}],"exit_code":0}
    """

@MainActor
struct LogAtRefTests {

    @Test func noRefReadsTheDefaultBranch() async throws {
        let (client, stub) = try makeClient()
        stub.enqueue(.init(status: 200, json: logJSON))
        let model = LogViewModel(client: client, repoPath: "krz/gitbay")

        await model.load()

        #expect(stub.seen.first?.url.query() == "argv=repo&argv=log&argv=krz/gitbay")
    }

    @Test func aRefIsForwardedToTheCommand() async throws {
        let (client, stub) = try makeClient()
        stub.enqueue(.init(status: 200, json: logJSON))
        let model = LogViewModel(client: client, repoPath: "krz/gitbay", ref: "side")

        await model.load()

        #expect(model.state.value?.first?.subject == "only on side")
        #expect(stub.seen.first?.url.query() ==
            "argv=repo&argv=log&argv=krz/gitbay&argv=--ref&argv=side")
    }

    @Test func anUnknownRefIsAnEmptyState() async throws {
        let (client, stub) = try makeClient()
        stub.enqueue(.init(status: 404, json:
            #"{"protocol_version":1,"error":"no ref \"nope\" in krz/gitbay","exit_code":3}"#))
        let model = LogViewModel(client: client, repoPath: "krz/gitbay", ref: "nope")

        await model.load()

        guard case .empty = model.state else {
            Issue.record("expected .empty, got \(model.state)")
            return
        }
    }
}

@MainActor
struct ExploreTests {

    @Test func exploreListsPublicReposAndPages() async throws {
        let (client, stub) = try makeClient()
        stub.enqueue(.init(status: 200, json: """
            {"protocol_version":1,"data":{"items":[\
            {"path":"krz/gitbay","description":"a forge","topics":["cli","forge"]},\
            {"path":"krz/old","archived":true}],"next":"ZXhwbG9yZTpr"},"exit_code":0}
            """))
        stub.enqueue(.init(status: 200, json: """
            {"protocol_version":1,"data":{"items":[{"path":"krz/space-wiki"}]},"exit_code":0}
            """))
        let list = PagedListModel<PublicRepo>(
            client: client, argv: ["explore"], emptyMessage: "none")

        await list.reload()
        #expect(list.state.value?.map(\.path) == ["krz/gitbay", "krz/old"])
        #expect(list.state.value?[0].topics == ["cli", "forge"])
        #expect(list.state.value?[1].isArchived == true)
        #expect(list.hasMore)

        await list.loadMore()
        #expect(list.state.value?.count == 3)
        #expect(!list.hasMore)
        #expect(stub.seen[1].url.query()?.contains("argv=--cursor&argv=ZXhwbG9yZTpr") == true)
    }

    @Test func ownerAndNameSplitForDisplay() {
        let repo = PublicRepo(path: "audit-labs/audit-tools",
                              description: nil, archived: nil, topics: nil)
        #expect(repo.owner == "audit-labs")
        #expect(repo.name == "audit-tools")
    }
}