'use node';

import { action } from '../_generated/server';
import { v } from 'convex/values';
import { internal } from '../_generated/api';
import * as fs from 'fs';
import * as path from 'path';

/**
 * Action para ler arquivos do sistema de arquivos e analisar funções
 */
export const analisarArquivos = action({
	args: {
		varreduraId: v.id('documentacaoVarredura'),
		arquivos: v.array(v.string()),
		executadoPor: v.id('usuarios')
	},
	returns: v.object({
		arquivosAnalisados: v.number(),
		documentosNovos: v.number(),
		documentosAtualizados: v.number(),
		erros: v.array(v.string())
	}),
	handler: async (ctx, args) => {
		'use node';

		const erros: string[] = [];
		let arquivosAnalisados = 0;
		let documentosNovos = 0;
		let documentosAtualizados = 0;

		console.log('🔍 [analisarArquivos] Iniciando análise de arquivos...');
		console.log(`📁 Total de arquivos: ${args.arquivos.length}`);
		console.log(`📋 Arquivos: ${args.arquivos.join(', ')}`);

		// Tentar diferentes caminhos possíveis
		const caminhosPossiveis = [
			path.join(process.cwd(), 'packages/backend/convex'),
			path.join(process.cwd(), 'convex'),
			path.resolve(__dirname, '../../convex'),
			path.resolve(__dirname, '../../../convex')
		];

		let basePath: string | null = null;
		for (const caminho of caminhosPossiveis) {
			if (fs.existsSync(caminho)) {
				basePath = caminho;
				console.log(`✅ Caminho encontrado: ${basePath}`);
				break;
			}
		}

		if (!basePath) {
			const erro = `Nenhum caminho válido encontrado. Tentados: ${caminhosPossiveis.join(', ')}`;
			console.error(`❌ ${erro}`);
			erros.push(erro);
			await ctx.runMutation(internal.documentacaoVarredura.atualizarVarreduraComResultados, {
				varreduraId: args.varreduraId,
				documentosNovos: 0,
				documentosAtualizados: 0,
				arquivosAnalisados: 0,
				erros: [erro]
			});
			return {
				arquivosAnalisados: 0,
				documentosNovos: 0,
				documentosAtualizados: 0,
				erros: [erro]
			};
		}

		for (const nomeArquivo of args.arquivos) {
			try {
				const arquivoPath = path.join(basePath, nomeArquivo);
				console.log(`📄 Processando: ${arquivoPath}`);

				// Verificar se o arquivo existe
				if (!fs.existsSync(arquivoPath)) {
					const erro = `Arquivo não encontrado: ${nomeArquivo} (caminho: ${arquivoPath})`;
					console.error(`❌ ${erro}`);
					erros.push(erro);
					continue;
				}

				// Ler conteúdo do arquivo
				const conteudo = fs.readFileSync(arquivoPath, 'utf-8');
				console.log(`✅ Arquivo lido: ${nomeArquivo} (${conteudo.length} caracteres)`);

				// Analisar funções no arquivo usando a mutation interna
				const resultado = await ctx.runMutation(
					internal.documentacaoVarredura.processarArquivo,
					{
						varreduraId: args.varreduraId,
						nomeArquivo,
						conteudo,
						executadoPor: args.executadoPor
					}
				);

				console.log(
					`✅ Processado ${nomeArquivo}: ${resultado.documentosNovos} novos, ${resultado.documentosAtualizados} atualizados`
				);

				arquivosAnalisados++;
				documentosNovos += resultado.documentosNovos;
				documentosAtualizados += resultado.documentosAtualizados;
			} catch (error) {
				const erroMsg = error instanceof Error ? error.message : 'Erro desconhecido';
				const erroStack = error instanceof Error ? error.stack : undefined;
				const erroCompleto = `Erro ao processar ${nomeArquivo}: ${erroMsg}${erroStack ? `\n${erroStack}` : ''}`;
				console.error(`❌ ${erroCompleto}`);
				erros.push(erroCompleto);
			}
		}

		console.log(
			`📊 Resumo: ${arquivosAnalisados} arquivos analisados, ${documentosNovos} novos, ${documentosAtualizados} atualizados`
		);

		// Atualizar varredura com os resultados
		await ctx.runMutation(internal.documentacaoVarredura.atualizarVarreduraComResultados, {
			varreduraId: args.varreduraId,
			documentosNovos,
			documentosAtualizados,
			arquivosAnalisados,
			erros
		});

		return {
			arquivosAnalisados,
			documentosNovos,
			documentosAtualizados,
			erros
		};
	}
});