import openrouter from './openrouter';
import ollama from './ollama';
import vllm from './vllm';
import cerebras from './cerebras';
import google from './google';
import longcat from './longcat';
import cohere from './cohere';
import inception from './inception';
import mistral from './mistral';
import closedrouter from './closedrouter';
import nvidia from './nvidia';
import xiaomi from './xiaomi';
import openai from './openai';
import anthropic from './anthropic';
import huggingface from './huggingface';
import type { Result } from '~~/types/result';
import type { Gateway, GatewayFetchError } from '~~/server/utils/ai-provider';
import type { Model as ModelDrizzle } from '~/composables/useModels';

export interface NormalizedModel {
    id: string;
    name?: string;
    cost?: Record<string, string | undefined>;
    attributes: {
        inputModalities: string[];
        outputModalities: string[];
        capabilities: string[];
        contextWindow?: number | null;
        supported_parameters?: string[];
    };
    releasedAt?: number;
}

export interface ProviderModule {
    id: string;
    baseUrl: string;
    modelsEndpoint: string | null;

    createGateway(config: {
        apiKey?: string;
        baseURL: string;
        model?: ModelDrizzle;
    }): Result<Gateway, GatewayFetchError>;

    getAuthHeaders(apiKey?: string): Record<string, string | undefined>;

    fetchModels(config: {
        baseURL: string;
        apiKey?: string;
        modelsDevData: any;
    }): Promise<NormalizedModel[]>;
}

const providers = [
    openrouter,
    ollama,
    vllm,
    cerebras,
    google,
    longcat,
    cohere,
    inception,
    mistral,
    closedrouter,
    nvidia,
    xiaomi,
    openai,
    anthropic,
    huggingface,
];

type ProviderId = typeof providers[number]['id'];
type Provider = typeof providers[number];

const registry = new Map<ProviderId, Provider>(providers.map((p) => [p.id, p]));

export function getProvider<T extends ProviderId>(id: T): Provider | undefined {
    return registry.get(id);
}

export function getAllProviders() {
    return Array.from(registry.values());
}

export function getProviderIds() {
    return Array.from(registry.keys());
}

export function getProviderBaseUrl<T extends ProviderId>(id: T): string {
    return registry.get(id)?.baseUrl ?? '';
}