// worker-homeserve.js (Versión SaaS - Ultra Estable con Reintentos y Logs)
import { chromium } from 'playwright';
import pg from 'pg';

const { Pool } = pg;

// --- CONFIGURACIÓN ---
const CONFIG = {
  DATABASE_URL: process.env.DATABASE_URL,
  LOGIN_URL: 'https://www.clientes.homeserve.es/cgi-bin/fccgi.exe?w3exec=PROF_PASS',
  BASE_CGI: 'https://www.clientes.homeserve.es/cgi-bin/fccgi.exe',
  NAV_TIMEOUT: 60000,
  POLL_INTERVAL_MS: 5000 
};

const pool = new Pool({ connectionString: CONFIG.DATABASE_URL, ssl: false });

// --- UTILS ---
function checkWeekend(dateStr) {
    if (!dateStr) return; 
    const parts = dateStr.split('/');
    if (parts.length !== 3) return; 
    const d = new Date(parseInt(parts[2]), parseInt(parts[1]) - 1, parseInt(parts[0]));
    if (d.getDay() === 0 || d.getDay() === 6) {
        throw new Error(`⛔ ERROR: La fecha ${dateStr} es fin de semana.`);
    }
}

async function getHomeServeCreds(ownerId) {
    const q = await pool.query(
        "SELECT username, password_hash FROM provider_credentials WHERE provider = 'homeserve' AND status = 'active' AND owner_id = $1 LIMIT 1",
        [ownerId]
    );
    if (q.rowCount === 0) throw new Error(`Sin credenciales para ID: ${ownerId}`);
    return { 
        user: q.rows[0].username, 
        pass: Buffer.from(q.rows[0].password_hash, 'base64').toString('utf-8') 
    };
}

// --- PLAYWRIGHT HELPERS ---
async function withBrowser(fn) {
  const browser = await chromium.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
  const context = await browser.newContext();
  const page = await context.newPage();
  try { return await fn(page); } finally { await browser.close().catch(() => {}); }
}

async function findLocatorInFrames(page, selector) {
  for (const fr of page.frames()) {
    const loc = fr.locator(selector);
    try { if (await loc.count()) return { frame: fr, locator: loc }; } catch (_) {}
  }
  return null;
}

async function clickFirstThatExists(page, selectors) {
  for (const sel of selectors) {
    const hit = await findLocatorInFrames(page, sel);
    if (hit) { await hit.locator.first().click(); return sel; }
  }
  return null;
}

async function fillFirstThatExists(page, selectors, value) {
  for (const sel of selectors) {
    const hit = await findLocatorInFrames(page, sel);
    if (hit) { await hit.locator.first().fill(String(value)); return sel; }
  }
  return null;
}

// --- INYECCIÓN EN HOMESERVE ---
async function loginAndProcess(page, creds, jobData) {
  console.log(`>>> 1. Navegando a HomeServe (${creds.user})...`);
  
  if (jobData.appointment_date) checkWeekend(jobData.appointment_date);
  if (!jobData.observation || jobData.observation.trim().length === 0) {
      throw new Error('⛔ ERROR: El campo Observaciones es obligatorio.');
  }

  // Aceptar diálogos molestos
  page.on('dialog', async dialog => {
      console.log(`   [DIALOG] Mensaje detectado: ${dialog.message()}`);
      await dialog.accept();
  });

  // Login a prueba de fallos (Espera a que cargue todo)
  await page.goto(CONFIG.LOGIN_URL, { waitUntil: 'load', timeout: CONFIG.NAV_TIMEOUT });
  console.log("   [DEBUG] Buscando campos de login...");
  
  let loginExitoso = false;
  for (let i = 0; i < 10; i++) {
      const u = await findLocatorInFrames(page, 'input[name="w3user"]');
      const p = await findLocatorInFrames(page, 'input[name="w3clau"]');
      
      if (u && p) {
          await u.locator.first().fill(creds.user);
          await p.locator.first().fill(creds.pass);
          loginExitoso = true;
          break;
      }
      await page.waitForTimeout(1000); // Reintento si los frames tardan en cargar
  }

  if (!loginExitoso) throw new Error("No se cargaron los campos de login de HomeServe.");

  await page.keyboard.press('Enter');
  await page.waitForTimeout(4000); // Esperar que procese el login

  const isStillAtLogin = await findLocatorInFrames(page, 'input[type="password"]');
  if (isStillAtLogin) throw new Error(`Login fallido en HomeServe.`);

  console.log(`>>> 2. Login OK. Navegando al expediente ${jobData.service_number}...`);

  const serviceUrl = `${CONFIG.BASE_CGI}?w3exec=ver_servicioencurso&Servicio=${jobData.service_number}&Pag=1`;
  await page.goto(serviceUrl, { waitUntil: 'domcontentloaded', timeout: CONFIG.NAV_TIMEOUT });
  await page.waitForTimeout(2000);

  const changeBtn = await clickFirstThatExists(page, ['input[name="repaso"]']);
  if (!changeBtn) throw new Error(`No veo el botón 'repaso'.`);

  console.log('>>> 3. Accediendo al formulario. Rellenando datos...');
  await page.waitForTimeout(2000);

  // Traducción y selección de estado (CON REFRESCO FORZADO PARA LA WEB)
  let targetCode = jobData.new_status;
  const statusOk = await page.evaluate((code) => {
      const select = document.querySelector('select[name="ESTADO"]');
      if (!select) return false;
      for (const opt of select.options) {
          if (opt.value == code || opt.text.toUpperCase().includes(code.toUpperCase())) {
              select.value = opt.value;
              // Disparamos los eventos para engañar a HomeServe y que crea que fue un humano
              select.dispatchEvent(new Event('change', { bubbles: true }));
              select.dispatchEvent(new Event('blur', { bubbles: true }));
              return true;
          }
      }
      return false;
  }, targetCode);

  if (!statusOk) throw new Error(`Estado '${jobData.new_status}' no encontrado.`);

  if (jobData.appointment_date) await fillFirstThatExists(page, ['input[name="FECSIG"]'], jobData.appointment_date);
  await fillFirstThatExists(page, ['textarea[name="Observaciones"]'], jobData.observation);

  if (jobData.inform_client) {
     const informCheck = await findLocatorInFrames(page, 'input[name="INFORMO"]');
     if (informCheck && !(await informCheck.locator.first().isChecked())) {
         await informCheck.locator.first().check();
     }
  }

  // Retraso clave para que los scripts de HomeServe asienten los datos
  await page.waitForTimeout(1000); 
  console.log('>>> 4. Guardando cambios en HomeServe...');
  
  const saveBtnHit = await findLocatorInFrames(page, 'input[name="BTNCAMBIAESTADO"]');
  if (!saveBtnHit) throw new Error('No encuentro el botón para guardar los cambios.');

  await saveBtnHit.locator.first().click();
  console.log('   -> Clic realizado, esperando confirmación del servidor (4s)...');
  await page.waitForTimeout(4000); 

  // Verificación del texto en pantalla (Buscando en todos los frames)
  const resultText = await page.evaluate(() => {
      // HomeServe suele meter el resultado en rojo o negrita
      const frameConTexto = Array.from(window.frames).map(f => {
          try { return f.document.querySelector('font[color="#FF0000"], .Estilo4, b, .mensaje'); } catch(e){ return null;}
      }).find(el => el != null);
      
      const elPrincipal = document.querySelector('font[color="#FF0000"], .Estilo4, b, .mensaje');
      const nodoFinal = elPrincipal || frameConTexto;
      return nodoFinal ? nodoFinal.innerText : "";
  });

  if (resultText && resultText.trim().length > 0) {
      console.log(`>>> Web dice: ${resultText.trim()}`);
      const textUpper = resultText.toUpperCase();
      if (!textUpper.includes('EXITO') && !textUpper.includes('ÉXITO') && !textUpper.includes('MODIFICADO') && !textUpper.includes('ACTUALIZADO')) {
          throw new Error(`Error en HomeServe: ${resultText.trim()}`);
      }
  }
  
  return { success: true };
}

// --- BUCLE DE COLA ---
async function pollQueue() {
    try {
        const res = await pool.query(`
            UPDATE robot_queue SET status = 'RUNNING', updated_at = NOW()
            WHERE id = (SELECT id FROM robot_queue WHERE status = 'PENDING' AND provider = 'homeserve' ORDER BY created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1)
            RETURNING *;
        `);

        if (res.rowCount > 0) {
            const job = res.rows[0];
            console.log(`\n🤖 TRABAJO #${job.id} | Empresa ID: ${job.owner_id} | Siniestro: ${job.service_number}`);

            try {
                const creds = await getHomeServeCreds(job.owner_id);
                await withBrowser(async (page) => {
                    await loginAndProcess(page, creds, job);
                });
                await pool.query("UPDATE robot_queue SET status = 'DONE', updated_at = NOW() WHERE id = $1", [job.id]);
                console.log(`✅ COMPLETADO #${job.id}\n`);
            } catch (err) {
                console.error(`❌ ERROR #${job.id}:`, err.message);
                await pool.query("UPDATE robot_queue SET status = 'FAILED', error_msg = $1, updated_at = NOW() WHERE id = $2", [err.message, job.id]);
            }
            setTimeout(pollQueue, 1000);
        } else {
            setTimeout(pollQueue, CONFIG.POLL_INTERVAL_MS);
        }
    } catch (e) {
        console.error("Error crítico:", e.message);
        setTimeout(pollQueue, CONFIG.POLL_INTERVAL_MS);
    }
}

console.log("🚀 Robot HomeServe SaaS Online.");
pollQueue();