OPEN_CODEX_API/src/config/models.ts

/**
 * Configuração de modelos de IA disponíveis
 * Mapeia os nomes de exibição para os IDs usados pela API
 */

export interface ModelConfig {
  name: string; // Nome exibido na interface
  id: string; // ID enviado para a API
  description?: string; // Descrição opcional do modelo
}

/**
 * Interface para modelo retornado pela API do banco de dados
 */
export interface ModelIA {
  id: number;
  provider_id: number;
  name: string;
  model_identifier: string;
  cost_input_per_million: string;
  cost_output_per_million: string;
  is_active: number;
  created_at: string;
  updated_at: string;
}

/**
 * Lista de modelos disponíveis
 * NOTA: Estes dados correspondem à tabela de modelos do banco de dados.
 * Futuramente será integrado com API para buscar dinamicamente.
 */
export const AVAILABLE_MODELS: ModelConfig[] = [
  {
    name: 'GPT-4.1',
    id: '1',
    description: 'Modelo GPT-4.1',
  },
  {
    name: 'GPT-4o',
    id: '2',
    description: 'Modelo GPT-4o',
  },
  {
    name: 'GPT-5 Mini',
    id: '3',
    description: 'Modelo GPT-5 Mini',
  },
  {
    name: 'Gemini 2.0 Flash',
    id: '4',
    description: 'Google Gemini 2.0 Flash',
  },
  {
    name: 'Claude Sonnet 4.5',
    id: '5',
    description: 'Anthropic Claude Sonnet 4.5',
  },
  {
    name: 'DeepSeek V3.2 Chat',
    id: '6',
    description: 'DeepSeek V3.2 Chat',
  },
  {
    name: 'DeepSeek V3.2 Reasoner',
    id: '7',
    description: 'DeepSeek V3.2 Reasoner',
  },
  {
    name: 'Gemini 2.5 Flash',
    id: '8',
    description: 'Google Gemini 2.5 Flash',
  },
  {
    name: 'Gemini 2.5 Flash-Lite',
    id: '9',
    description: 'Google Gemini 2.5 Flash-Lite',
  },
  {
    name: 'Claude Haiku 4.5',
    id: '10',
    description: 'Anthropic Claude Haiku 4.5',
  },
  {
    name: 'GPT-4o Mini',
    id: '11',
    description: 'Modelo GPT-4o Mini',
  },
];

/**
 * Mapeia o nome do modelo para o ID da API
 *
 * @param modelName - Nome do modelo exibido na interface
 * @returns ID do modelo para a API, ou o próprio nome se não encontrado
 */
export function getModelId(modelName: string): string {
  const model = AVAILABLE_MODELS.find(m => m.name === modelName);
  return model?.id || modelName;
}

/**
 * Mapeia o ID da API para o nome de exibição
 *
 * @param modelId - ID do modelo na API
 * @returns Nome do modelo para exibir, ou o próprio ID se não encontrado
 */
export function getModelName(modelId: string): string {
  const model = AVAILABLE_MODELS.find(m => m.id === modelId);
  return model?.name || modelId;
}

/**
 * Obtém a configuração completa de um modelo pelo nome
 *
 * @param modelName - Nome do modelo
 * @returns Configuração do modelo ou undefined
 */
export function getModelConfig(modelName: string): ModelConfig | undefined {
  return AVAILABLE_MODELS.find(m => m.name === modelName);
}

/**
 * Retorna apenas os nomes dos modelos para uso em dropdowns
 */
export function getModelNames(): string[] {
  return AVAILABLE_MODELS.map(m => m.name);
}

/**
 * Busca modelos de IA disponíveis no banco de dados
 *
 * @returns Promise com array de modelos ativos
 */
export async function fetchModelsFromDatabase(): Promise<ModelConfig[]> {
  try {
    // Importa dinamicamente para evitar circular dependency
    const { apiService } = await import('@/services/api');

    const response = await apiService.get<ModelIA[]>('/webhook/codex/get_models_ia');

    console.log('Modelos carregados da API:', response.data);

    // Filtra apenas modelos ativos e converte para ModelConfig
    return response.data
      .filter(model => model.is_active === 1)
      .map((model: ModelIA) => ({
        name: model.name,
        id: model.id.toString(),
        description: `${model.model_identifier}`,
      }));
  } catch (error) {
    console.error('Erro ao buscar modelos da API:', error);

    // Fallback para modelos hardcoded em caso de erro
    console.warn('Usando modelos hardcoded como fallback');
    return AVAILABLE_MODELS;
  }
}