//
//  RequestRouterTests.swift
//  Zyquo Router
//
//  Author: Simon-Pierre Boucher
//  Mail: contact@spboucher.ai
//
//  Model-resolution rules: namespaced IDs, unambiguous bare IDs, aliases,
//  disabled models, ambiguity across providers.
//

import XCTest
@testable import ZyquoRouter

final class RequestRouterTests: XCTestCase {
    private func model(_ id: String, _ provider: ProviderID) -> AIModel {
        AIModel(
            id: id,
            provider: provider,
            displayName: id,
            contextWindow: 128_000,
            maxOutputTokens: nil,
            capabilities: ModelCapabilities(),
            pricing: nil,
            parameterSupport: ParameterSupport()
        )
    }

    private var router: RequestRouter {
        RequestRouter(
            catalog: [
                model("alpha-1", .openai),
                model("shared-model", .together),
                model("shared-model", .deepinfra),
                model("meta-llama/Llama-4", .deepinfra),
            ],
            aliases: ["fast": "openai/alpha-1"],
            disabledIDs: ["together/shared-model"]
        )
    }

    func testNamespacedResolution() throws {
        let resolution = try router.resolve("openai/alpha-1")
        XCTAssertEqual(resolution.namespacedID, "openai/alpha-1")
        XCTAssertEqual(resolution.model.provider, .openai)
    }

    func testBareIDUnambiguous() throws {
        XCTAssertEqual(try router.resolve("alpha-1").namespacedID, "openai/alpha-1")
    }

    func testModelIDContainingSlash() throws {
        XCTAssertEqual(
            try router.resolve("deepinfra/meta-llama/Llama-4").namespacedID,
            "deepinfra/meta-llama/Llama-4"
        )
        // Bare form works too: "meta-llama" is not a provider prefix.
        XCTAssertEqual(
            try router.resolve("meta-llama/Llama-4").namespacedID,
            "deepinfra/meta-llama/Llama-4"
        )
    }

    func testAlias() throws {
        XCTAssertEqual(try router.resolve("fast").namespacedID, "openai/alpha-1")
    }

    func testAmbiguousBareID() {
        XCTAssertThrowsError(try router.resolve("shared-model")) { error in
            guard case RequestRouter.RoutingError.ambiguousModel(_, let candidates) = error else {
                return XCTFail("expected ambiguity, got \(error)")
            }
            XCTAssertEqual(Set(candidates), ["together/shared-model", "deepinfra/shared-model"])
        }
    }

    func testDisabledModel() {
        XCTAssertThrowsError(try router.resolve("together/shared-model")) { error in
            guard case RequestRouter.RoutingError.disabledModel = error else {
                return XCTFail("expected disabled, got \(error)")
            }
        }
    }

    func testUnknownModel() {
        XCTAssertThrowsError(try router.resolve("nope")) { error in
            guard case RequestRouter.RoutingError.unknownModel = error else {
                return XCTFail("expected unknown, got \(error)")
            }
        }
    }

    func testFullCatalogHasNoAmbiguousNamespacedIDs() {
        let ids = ModelCatalogData.all.map { RequestRouter.namespacedID(for: $0) }
        XCTAssertEqual(ids.count, Set(ids).count, "namespaced IDs must be unique")
    }
}