import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import pg from 'pg';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Try local first (with SSH tunnel), then remote directly
const URLS = [
  'postgresql://edumanager:EduManager2026!Seguro@127.0.0.1:5432/edumanager',
  'postgresql://edumanager:EduManager2026!Seguro@150.230.87.131:5432/edumanager'
];

async function run() {
  const backupPath = path.join(__dirname, '../backup_supabase_2026-04-19_migrado.json');
  console.log(`Lendo backup de: ${backupPath}`);
  
  if (!fs.existsSync(backupPath)) {
    console.error('ERRO: Arquivo de backup não encontrado!');
    process.exit(1);
  }

  const raw = fs.readFileSync(backupPath, 'utf8');
  const backupData = JSON.parse(raw);
  const students = backupData.students || [];
  
  console.log(`Encontrados ${students.length} alunos no arquivo de backup.`);

  let pool;
  for (const url of URLS) {
    try {
      console.log(`Tentando conectar ao banco via: ${url.split('@')[1]}...`);
      pool = new pg.Pool({ connectionString: url, connectionTimeoutMillis: 5000 });
      await pool.query('SELECT NOW()');
      console.log('Conectado com sucesso!');
      break;
    } catch (err) {
      console.warn(`Falha ao conectar via ${url.split('@')[1]}: ${err.message}`);
      pool = null;
    }
  }

  if (!pool) {
    console.error('ERRO: Não foi possível conectar ao banco de dados com nenhuma das URLs.');
    process.exit(1);
  }

  let updatedCount = 0;
  let notFoundCount = 0;

  try {
    for (const s of students) {
      // Formatar datas para o padrão YYYY-MM-DD
      const birthDate = s.birthDate ? s.birthDate.split('T')[0] : null;
      const rgIssueDate = s.rgIssueDate ? s.rgIssueDate.split('T')[0] : null;
      const guardianBirthDate = s.guardianBirthDate ? s.guardianBirthDate.split('T')[0] : null;
      const registrationDate = s.registrationDate ? s.registrationDate.split('T')[0] : null;

      // Verificar se o aluno existe
      const { rows } = await pool.query('SELECT id, nome FROM alunos WHERE id = $1', [s.id]);
      
      if (rows.length === 0) {
        console.log(`Aluno não encontrado no banco SQL (Será ignorado): ${s.name} (${s.id})`);
        notFoundCount++;
        continue;
      }

      // Executar o UPDATE dos dados restaurados
      const query = `
        UPDATE alunos
        SET
          rg = $1,
          data_nascimento = $2,
          rg_data_emissao = $3,
          cep = $4,
          rua = $5,
          numero = $6,
          bairro = $7,
          cidade = $8,
          estado = $9,
          tem_responsavel = $10,
          nome_responsavel = $11,
          cpf_responsavel = $12,
          telefone_responsavel = $13,
          data_nascimento_responsavel = $14,
          numero_matricula = $15,
          data_matricula = $16,
          modelo_contrato_id = $17,
          foto_url = $18,
          senha_portal = $19,
          face_descriptor = $20
        WHERE id = $21
      `;

      const values = [
        s.rg || '',
        birthDate,
        rgIssueDate,
        s.addressZip || '',
        s.addressStreet || '',
        s.addressNumber || '',
        s.addressNeighborhood || '',
        s.addressCity || '',
        s.addressState || '',
        s.hasGuardian || false,
        s.guardianName || '',
        s.guardianCpf || '',
        s.guardianPhone || '',
        guardianBirthDate,
        s.enrollmentNumber || null,
        registrationDate,
        s.contractTemplateId || 'default-template',
        s.photo || '',
        s.portalPassword || null,
        s.faceDescriptor ? JSON.stringify(s.faceDescriptor) : null,
        s.id
      ];

      await pool.query(query, values);
      console.log(`Restaurado aluno: ${s.name} (${s.id})`);
      updatedCount++;
    }

    console.log('\n--- RELATÓRIO DE RESTAURAÇÃO ---');
    console.log(`Alunos atualizados com sucesso no SQL: ${updatedCount}`);
    console.log(`Alunos do backup não encontrados no SQL: ${notFoundCount}`);
    console.log('--------------------------------\n');

  } catch (err) {
    console.error('ERRO CRÍTICO DURANTE A RESTAURAÇÃO:', err);
  } finally {
    await pool.end();
  }
}

run();