// "use node";

// import { action } from "../_generated/server";
// import { v } from "convex/values";
// import { api, internal } from "../_generated/api";
// import { Client } from "ssh2";
// import { readFileSync } from "fs";
// import { decryptSMTPPasswordNode } from "./utils/nodeCrypto";

// /**
//  * Interface para configuração SSH
//  */
// interface SSHConfig {
// 	host: string;
// 	port: number;
// 	username: string;
// 	password?: string;
// 	keyPath?: string;
// }

// /**
//  * Executar comando via SSH
//  */
// async function executarComandoSSH(
// 	config: SSHConfig,
// 	comando: string
// ): Promise<{ sucesso: boolean; output: string; erro?: string }> {
// 	return new Promise((resolve) => {
// 		const conn = new Client();
// 		let output = "";
// 		let errorOutput = "";

// 		conn.on("ready", () => {
// 			conn.exec(comando, (err, stream) => {
// 				if (err) {
// 					conn.end();
// 					resolve({ sucesso: false, output: "", erro: err.message });
// 					return;
// 				}

// 				stream
// 					.on("close", (code: number | null, signal: string | null) => {
// 						conn.end();
// 						if (code === 0) {
// 							resolve({ sucesso: true, output: output.trim() });
// 						} else {
// 							resolve({
// 								sucesso: false,
// 								output: output.trim(),
// 								erro: `Comando retornou código ${code}${signal ? ` (signal: ${signal})` : ""}. ${errorOutput}`,
// 							});
// 						}
// 					})
// 					.on("data", (data: Buffer) => {
// 						output += data.toString();
// 					})
// 					.stderr.on("data", (data: Buffer) => {
// 						errorOutput += data.toString();
// 					});
// 			});
// 		}).on("error", (err) => {
// 			resolve({ sucesso: false, output: "", erro: err.message });
// 		}).connect({
// 			host: config.host,
// 			port: config.port,
// 			username: config.username,
// 			password: config.password,
// 			privateKey: config.keyPath ? readFileSync(config.keyPath) : undefined,
// 			readyTimeout: 10000,
// 		});
// 	});
// }

// /**
//  * Ler arquivo via SSH
//  */
// async function lerArquivoSSH(
// 	config: SSHConfig,
// 	caminho: string
// ): Promise<{ sucesso: boolean; conteudo?: string; erro?: string }> {
// 	const comando = `cat "${caminho}" 2>&1`;
// 	const resultado = await executarComandoSSH(config, comando);

// 	if (!resultado.sucesso) {
// 		return { sucesso: false, erro: resultado.erro || "Erro ao ler arquivo" };
// 	}

// 	return { sucesso: true, conteudo: resultado.output };
// }

// /**
//  * Escrever arquivo via SSH
//  */
// async function escreverArquivoSSH(
// 	config: SSHConfig,
// 	caminho: string,
// 	conteudo: string
// ): Promise<{ sucesso: boolean; erro?: string }> {
// 	// Escapar conteúdo para shell
// 	const conteudoEscapado = conteudo
// 		.replace(/\\/g, "\\\\")
// 		.replace(/"/g, '\\"')
// 		.replace(/\$/g, "\\$")
// 		.replace(/`/g, "\\`");

// 	const comando = `cat > "${caminho}" << 'JITSI_CONFIG_EOF'
// ${conteudo}
// JITSI_CONFIG_EOF`;

// 	const resultado = await executarComandoSSH(config, comando);

// 	if (!resultado.sucesso) {
// 		return { sucesso: false, erro: resultado.erro || "Erro ao escrever arquivo" };
// 	}

// 	return { sucesso: true };
// }

// /**
//  * Aplicar configurações do Jitsi no servidor Docker via SSH
//  */
// export const aplicarConfiguracaoServidor = action({
// 	args: {
// 		configId: v.id("configuracaoJitsi"),
// 		sshPassword: v.optional(v.string()), // Senha SSH (se não usar chave)
// 	},
// 	returns: v.union(
// 		v.object({
// 			sucesso: v.literal(true),
// 			mensagem: v.string(),
// 			detalhes: v.optional(v.string()),
// 		}),
// 		v.object({ sucesso: v.literal(false), erro: v.string() })
// 	),
// 	handler: async (ctx, args): Promise<
// 		| { sucesso: true; mensagem: string; detalhes?: string }
// 		| { sucesso: false; erro: string }
// 	> => {
// 		try {
// 			// Buscar configuração
// 			const config = await ctx.runQuery(api.configuracaoJitsi.obterConfigJitsi, {});

// 			if (!config || config._id !== args.configId) {
// 				return { sucesso: false as const, erro: "Configuração não encontrada" };
// 			}

// 			// Verificar se tem configurações SSH
// 			const configFull = await ctx.runQuery(api.configuracaoJitsi.obterConfigJitsiCompleta, {
// 				configId: args.configId,
// 			});

// 			if (!configFull || !configFull.sshHost) {
// 				return {
// 					sucesso: false as const,
// 					erro: "Configurações SSH não estão definidas. Configure o servidor SSH primeiro.",
// 				};
// 			}

// 			// Configurar SSH
// 			let sshPasswordDecrypted: string | undefined = undefined;

// 			// Se senha foi fornecida, usar ela. Caso contrário, tentar descriptografar a armazenada
// 			if (args.sshPassword) {
// 				sshPasswordDecrypted = args.sshPassword;
// 			} else if (configFull.sshPasswordHash && configFull.sshPasswordHash !== "********") {
// 				// Tentar descriptografar senha armazenada
// 				try {
// 					sshPasswordDecrypted = await decryptSMTPPasswordNode(configFull.sshPasswordHash);
// 				} catch (error) {
// 					return {
// 						sucesso: false as const,
// 						erro: "Não foi possível descriptografar a senha SSH armazenada. Forneça a senha novamente.",
// 					};
// 				}
// 			}

// 			const sshConfig: SSHConfig = {
// 				host: configFull.sshHost,
// 				port: configFull.sshPort || 22,
// 				username: configFull.sshUsername || "",
// 				password: sshPasswordDecrypted,
// 				keyPath: configFull.sshKeyPath || undefined,
// 			};

// 			if (!sshConfig.username) {
// 				return { sucesso: false as const, erro: "Usuário SSH não configurado" };
// 			}

// 			if (!sshConfig.password && !sshConfig.keyPath) {
// 				return {
// 					sucesso: false as const,
// 					erro: "Senha SSH ou caminho da chave deve ser fornecido",
// 				};
// 			}

// 			const basePath = configFull.jitsiConfigPath || "~/.jitsi-meet-cfg";
// 			const dockerComposePath = configFull.dockerComposePath || ".";

// 			// Extrair host e porta do domain
// 			const [host, portStr] = configFull.domain.split(":");
// 			const port = portStr ? parseInt(portStr, 10) : configFull.useHttps ? 443 : 80;
// 			const protocol = configFull.useHttps ? "https" : "http";

// 			const detalhes: string[] = [];

// 			// 1. Atualizar arquivo .env do docker-compose
// 			if (dockerComposePath) {
// 				const envContent = `# Configuração Jitsi - Atualizada automaticamente pelo SGSE
// CONFIG=${basePath}
// TZ=America/Recife
// ENABLE_LETSENCRYPT=0
// HTTP_PORT=${protocol === "https" ? 8000 : port}
// HTTPS_PORT=${configFull.useHttps ? port : 8443}
// PUBLIC_URL=${protocol}://${host}${portStr ? `:${port}` : ""}
// DOMAIN=${host}
// ENABLE_AUTH=0
// ENABLE_GUESTS=1
// ENABLE_TRANSCRIPTION=0
// ENABLE_RECORDING=0
// ENABLE_PREJOIN_PAGE=0
// START_AUDIO_MUTED=0
// START_VIDEO_MUTED=0
// ENABLE_XMPP_WEBSOCKET=0
// ENABLE_P2P=1
// MAX_NUMBER_OF_PARTICIPANTS=10
// RESOLUTION_WIDTH=1280
// RESOLUTION_HEIGHT=720
// JWT_APP_ID=${configFull.appId}
// JWT_APP_SECRET=
// `;

// 				const envPath = `${dockerComposePath}/.env`;
// 				const resultadoEnv = await escreverArquivoSSH(sshConfig, envPath, envContent);

// 				if (!resultadoEnv.sucesso) {
// 					return {
// 						sucesso: false as const,
// 						erro: `Erro ao atualizar .env: ${resultadoEnv.erro}`,
// 					};
// 				}

// 				detalhes.push(`✓ Arquivo .env atualizado: ${envPath}`);
// 			}

// 			// 2. Atualizar configuração do Prosody (conforme documentação oficial)
// 			const prosodyConfigPath = `${basePath}/prosody/config/${host}.cfg.lua`;
// 			const prosodyContent = `-- Configuração Prosody para ${host}
// -- Gerada automaticamente pelo SGSE
// -- Baseado na documentação oficial do Jitsi Meet

// VirtualHost "${host}"
//     authentication = "anonymous"
//     modules_enabled = {
//         "bosh";
//         "websocket";
//         "ping";
//         "speakerstats";
//         "turncredentials";
//         "presence";
//         "conference_duration";
//         "stats";
//     }
//     c2s_require_encryption = false
//     allow_anonymous_s2s = false
//     bosh_max_inactivity = 60
//     bosh_max_polling = 5
//     bosh_max_stanzas = 5

// Component "conference.${host}" "muc"
//     storage = "memory"
//     muc_room_locking = false
//     muc_room_default_public_jids = true
//     muc_room_cache_size = 1000
//     muc_log_presences = true

// Component "jitsi-videobridge.${host}"
//     component_secret = ""

// Component "focus.${host}"
//     component_secret = ""
// `;

// 			const resultadoProsody = await escreverArquivoSSH(sshConfig, prosodyConfigPath, prosodyContent);

// 			if (!resultadoProsody.sucesso) {
// 				return {
// 					sucesso: false as const,
// 					erro: `Erro ao atualizar Prosody: ${resultadoProsody.erro}`,
// 				};
// 			}

// 			detalhes.push(`✓ Configuração Prosody atualizada: ${prosodyConfigPath}`);

// 			// 3. Atualizar configuração do Jicofo
// 			const jicofoConfigPath = `${basePath}/jicofo/sip-communicator.properties`;
// 			const jicofoContent = `# Configuração Jicofo
// # Gerada automaticamente pelo SGSE
// org.jitsi.jicofo.BRIDGE_MUC=JvbBrewery@internal.${host}
// org.jitsi.jicofo.jid=XMPP_USER@${host}
// org.jitsi.jicofo.BRIDGE_MUC_JID=MUC_BRIDGE_JID@internal.${host}
// org.jitsi.jicofo.app.ID=${configFull.appId}
// `;

// 			const resultadoJicofo = await escreverArquivoSSH(sshConfig, jicofoConfigPath, jicofoContent);

// 			if (!resultadoJicofo.sucesso) {
// 				return {
// 					sucesso: false as const,
// 					erro: `Erro ao atualizar Jicofo: ${resultadoJicofo.erro}`,
// 				};
// 			}

// 			detalhes.push(`✓ Configuração Jicofo atualizada: ${jicofoConfigPath}`);

// 			// 4. Atualizar configuração do JVB
// 			const jvbConfigPath = `${basePath}/jvb/sip-communicator.properties`;
// 			const jvbContent = `# Configuração JVB (Jitsi Video Bridge)
// # Gerada automaticamente pelo SGSE
// org.jitsi.videobridge.AUTHORIZED_SOURCE_REGEXP=.*@${host}/.*
// org.jitsi.videobridge.xmpp.user.shard.HOSTNAME=${host}
// org.jitsi.videobridge.xmpp.user.shard.DOMAIN=auth.${host}
// org.jitsi.videobridge.xmpp.user.shard.USERNAME=jvb
// org.jitsi.videobridge.xmpp.user.shard.MUC_JIDS=JvbBrewery@internal.${host}
// `;

// 			const resultadoJvb = await escreverArquivoSSH(sshConfig, jvbConfigPath, jvbContent);

// 			if (!resultadoJvb.sucesso) {
// 				return {
// 					sucesso: false as const,
// 					erro: `Erro ao atualizar JVB: ${resultadoJvb.erro}`,
// 				};
// 			}

// 			detalhes.push(`✓ Configuração JVB atualizada: ${jvbConfigPath}`);

// 			// 5. Reiniciar containers Docker
// 			if (dockerComposePath) {
// 				const resultadoRestart = await executarComandoSSH(
// 					sshConfig,
// 					`cd "${dockerComposePath}" && docker-compose restart 2>&1 || docker compose restart 2>&1`
// 				);

// 				if (!resultadoRestart.sucesso) {
// 					return {
// 						sucesso: false as const,
// 						erro: `Erro ao reiniciar containers: ${resultadoRestart.erro}`,
// 					};
// 				}

// 				detalhes.push(`✓ Containers Docker reiniciados`);
// 			}

// 			// Atualizar timestamp de configuração no servidor
// 			await ctx.runMutation(internal.configuracaoJitsi.marcarConfiguradoNoServidor, {
// 				configId: args.configId,
// 			});

// 			return {
// 				sucesso: true as const,
// 				mensagem: "Configurações aplicadas com sucesso no servidor Jitsi",
// 				detalhes: detalhes.join("\n"),
// 			};
// 		} catch (error: unknown) {
// 			const errorMessage = error instanceof Error ? error.message : String(error);
// 			return {
// 				sucesso: false as const,
// 				erro: `Erro ao aplicar configurações: ${errorMessage}`,
// 			};
// 		}
// 	},
// });

// /**
//  * Testar conexão SSH
//  */
// export const testarConexaoSSH = action({
// 	args: {
// 		sshHost: v.string(),
// 		sshPort: v.optional(v.number()),
// 		sshUsername: v.string(),
// 		sshPassword: v.optional(v.string()),
// 		sshKeyPath: v.optional(v.string()),
// 	},
// 	returns: v.union(
// 		v.object({ sucesso: v.literal(true), mensagem: v.string() }),
// 		v.object({ sucesso: v.literal(false), erro: v.string() })
// 	),
// 		handler: async (ctx, args): Promise<
// 		| { sucesso: true; mensagem: string }
// 		| { sucesso: false; erro: string }
// 	> => {
// 		try {
// 			if (!args.sshPassword && !args.sshKeyPath) {
// 				return {
// 					sucesso: false as const,
// 					erro: "Senha SSH ou caminho da chave deve ser fornecido",
// 				};
// 			}

// 			const sshConfig: SSHConfig = {
// 				host: args.sshHost,
// 				port: args.sshPort || 22,
// 				username: args.sshUsername,
// 				password: args.sshPassword || undefined,
// 				keyPath: args.sshKeyPath || undefined,
// 			};

// 			// Tentar executar um comando simples
// 			const resultado = await executarComandoSSH(sshConfig, "echo 'SSH_OK'");

// 			if (resultado.sucesso && resultado.output.includes("SSH_OK")) {
// 				return {
// 					sucesso: true as const,
// 					mensagem: "Conexão SSH estabelecida com sucesso",
// 				};
// 			}

// 			return {
// 				sucesso: false as const,
// 				erro: resultado.erro || "Falha ao estabelecer conexão SSH",
// 			};
// 		} catch (error: unknown) {
// 			const errorMessage = error instanceof Error ? error.message : String(error);
// 			return {
// 				sucesso: false as const,
// 				erro: `Erro ao testar SSH: ${errorMessage}`,
// 			};
// 		}
// 	},
// });