import { Router, json } from 'itty-router';
import { completionController } from '../../controllers/completion';
import { apiKeysController } from '../../controllers/apikeys';
import { libx } from 'libx.js/build/bundles/essentials.js';
import { supportedModels as supportedModelsData } from 'ai.libx.js';

function groupModelsByProvider(models: any): any {
	const providers: any = {};

	for (const [key, value] of Object.entries(models)) {
		// Key format: "provider/model-name" or "provider/models/model-name"
		const parts = key.split('/');
		const provider = parts[0];

		if (!providers[provider]) {
			providers[provider] = [];
		}

		providers[provider].push({
			id: key,
			name: parts.slice(1).join('/'),
			...value as any
		});
	}

	return providers;
}

export default (base: string) => {
	const router = Router({ base });

	// Health check
	router.get('/health', (req) => {
		return json({
			status: 'ok',
			version: '1.0.0',
			timestamp: new Date().toISOString()
		});
	});

	// Completion endpoints
	router.post('/completion', completionController.handleRequest);
	router.post('/completion/stream', completionController.handleStream);

	// GET /v1/models - List all supported models grouped by provider
	router.get('/models', async (req: any) => {
		try {
			const groupedByProvider = groupModelsByProvider(supportedModelsData);

			// Calculate stats
			const stats: any = {};
			for (const [provider, models] of Object.entries(groupedByProvider)) {
				stats[provider] = {
					total: (models as any[]).length,
					enabled: (models as any[]).filter((m: any) => m.enabled !== false).length
				};
			}

			return json({
				providers: Object.keys(groupedByProvider),
				stats,
				models: groupedByProvider
			});
		} catch (error: any) {
			libx.log.e('Error in /v1/models', error);
			return json({
				error: error.message
			}, { status: 500 });
		}
	});

	// GET /v1/models/:provider - List models for specific provider
	router.get('/models/:provider', async (req: any) => {
		try {
			const { provider } = req.params;
			const groupedByProvider = groupModelsByProvider(supportedModelsData);

			const providerLower = provider.toLowerCase();
			const providerModels = groupedByProvider[providerLower];

			if (!providerModels) {
				return json({
					error: `Provider '${provider}' not found`,
					availableProviders: Object.keys(groupedByProvider)
				}, { status: 404 });
			}

			return json({
				provider: providerLower,
				total: providerModels.length,
				enabled: providerModels.filter((m: any) => m.enabled !== false).length,
				models: providerModels
			});
		} catch (error: any) {
			libx.log.e('Error in /v1/models/:provider', error);
			return json({
				error: error.message
			}, { status: 500 });
		}
	});

	// API Keys management routes
	router.post('/apikeys', apiKeysController.createApiKey);
	router.get('/apikeys', apiKeysController.listApiKeys);
	router.get('/apikeys/:apiKey', apiKeysController.getApiKey);
	router.delete('/apikeys/:apiKey', apiKeysController.revokeApiKey);
	router.post('/apikeys/:apiKey/providers', apiKeysController.addProviderKey);
	router.delete('/apikeys/:apiKey/providers/:provider', apiKeysController.removeProviderKey);
	router.get('/apikeys/:apiKey/usage', apiKeysController.getUsageStats);

	return { base, router };
};