// worker-homeserve.js (Versión Detective V2 - URL Corregida)
'use strict';

const { chromium } = require('playwright');
const admin = require('firebase-admin');

// --- CONFIGURACIÓN ---
const CONFIG = {
  QUEUE_COLLECTION: process.env.QUEUE_COLLECTION || 'homeserve_cambios_estado',
  RESULT_COLLECTION: process.env.RESULT_COLLECTION || 'homeserve_cambios_estado_log',
  HS_CRED_DOC_PATH: process.env.HS_CRED_DOC_PATH || 'providerCredentials/homeserve',
  
  // ¡CAMBIO IMPORTANTE! Usamos la URL completa de login
  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,
  RESCAN_SECONDS: 60
};

// --- UTILS ---
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
function toServerTimestamp() { return admin.firestore.FieldValue.serverTimestamp(); }
function mustEnv(name) {
  const v = process.env[name];
  if (!v) throw new Error(`Falta variable: ${name}`);
  return v;
}
function pickFirstNonEmpty(...vals) {
  for (const v of vals) {
    if (v !== undefined && v !== null && String(v).trim() !== '') return String(v).trim();
  }
  return '';
}

// --- FIREBASE ---
function initFirebase() {
  if (!process.env.FIREBASE_PRIVATE_KEY) throw new Error('Missing FIREBASE_PRIVATE_KEY');
  if (!admin.apps.length) {
    admin.initializeApp({
      credential: admin.credential.cert({
        projectId: mustEnv('FIREBASE_PROJECT_ID'),
        clientEmail: mustEnv('FIREBASE_CLIENT_EMAIL'),
        privateKey: mustEnv('FIREBASE_PRIVATE_KEY').replace(/\\n/g, '\n'),
      }),
    });
  }
  return admin.firestore();
}

// --- CREDENCIALES (Lectura de Firestore) ---
async function getHomeServeCreds(db) {
  // Prioridad 1: ENV
  const envUser = pickFirstNonEmpty(process.env.HOMESERVE_USER);
  const envPass = pickFirstNonEmpty(process.env.HOMESERVE_PASS);
  if (envUser && envPass) return { user: envUser, pass: envPass };

  // Prioridad 2: Firestore (providerCredentials/homeserve)
  const path = CONFIG.HS_CRED_DOC_PATH; 
  const parts = path.split('/');
  
  if (parts.length === 2) {
    const snap = await db.collection(parts[0]).doc(parts[1]).get();
    if (snap.exists) {
      const d = snap.data();
      const user = pickFirstNonEmpty(d.user, d.username, d.usuario);
      const pass = pickFirstNonEmpty(d.pass, d.password, d.clave);
      
      console.log(`[Creds] Leído de Firestore: Usuario termina en ...${user.slice(-3)}`); // Log seguro
      if (user && pass) return { user, pass };
    }
  }
  throw new Error('No se encontraron credenciales en providerCredentials/homeserve');
}

// --- 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 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;
}

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;
}

// --- DIAGNÓSTICO ---
async function getDebugInfo(page) {
    try {
        const title = await page.title();
        const url = page.url();
        // Coge los primeros 500 caracteres de texto visible para ver si hay mensajes de error
        const bodyText = await page.evaluate(() => document.body.innerText.substring(0, 500).replace(/\n/g, ' '));
        return `URL: ${url} || TITULO: "${title}" || TEXTO: "${bodyText}..."`;
    } catch (e) {
        return "No se pudo obtener info de debug.";
    }
}

// --- LÓGICA PRINCIPAL ---
async function loginAndProcess(page, creds, jobData) {
  console.log('>>> 1. Iniciando navegación a LOGIN...');
  
  // 1. IR A LA PÁGINA DE LOGIN CORRECTA
  await page.goto(CONFIG.LOGIN_URL, { waitUntil: 'domcontentloaded', timeout: CONFIG.NAV_TIMEOUT });
  await page.waitForTimeout(1000);

  // 2. RELLENAR LOGIN
  const userFilled = await fillFirstThatExists(page, ['input[name="w3user"]', 'input[name*="user" i]', 'input[type="text"]'], creds.user);
  const passFilled = await fillFirstThatExists(page, ['input[name="w3clau"]', 'input[name*="pass" i]', 'input[type="password"]'], creds.pass);

  if (!userFilled || !passFilled) {
      const debug = await getDebugInfo(page);
      throw new Error(`No encontré los campos de usuario/contraseña. ¿La página cargó bien? DEBUG: ${debug}`);
  }

  // 3. CLICK ENTRAR
  await page.keyboard.press('Enter'); 
  // Opcional: click en botón si Enter no va
  // await clickFirstThatExists(page, ['input[type="image"]', 'button[type="submit"]']);
  
  await page.waitForTimeout(3000); // Esperar redirección

  // VERIFICACIÓN DE LOGIN: Si seguimos viendo el campo de password, falló.
  const stillLogin = await findLocatorInFrames(page, 'input[type="password"]');
  if (stillLogin) {
      const debug = await getDebugInfo(page);
      throw new Error(`Parece que el login falló (sigo viendo el input password). DEBUG: ${debug}`);
  }

  console.log('>>> 2. Login parece correcto. Buscando servicio...');

  // 4. IR AL SERVICIO DIRECTAMENTE
  const serviceUrl = new URL(CONFIG.BASE_CGI);
  serviceUrl.searchParams.set('w3exec', 'ver_servicioencurso');
  serviceUrl.searchParams.set('Servicio', String(jobData.serviceNumber));
  serviceUrl.searchParams.set('Pag', '1');

  await page.goto(serviceUrl.toString(), { waitUntil: 'domcontentloaded', timeout: CONFIG.NAV_TIMEOUT });
  await page.waitForTimeout(2000);

  // 5. BUSCAR BOTÓN "CAMBIAR ESTADO" (REPASO)
  const changeBtn = await clickFirstThatExists(page, [
    'input[name="repaso"]', 
    'input[title*="Cambiar el Estado" i]', 
    'input[src*="estado1.gif" i]'
  ]);

  if (!changeBtn) {
    const debug = await getDebugInfo(page);
    throw new Error(`Login OK, pero NO veo el botón 'repaso' en el servicio ${jobData.serviceNumber}. ¿El parte está cerrado? DEBUG: ${debug}`);
  }

  // 6. CAMBIAR ESTADO
  await page.waitForLoadState('domcontentloaded');
  await page.waitForTimeout(1000);

  // Seleccionar estado
  const statusOk = await page.evaluate((code) => {
      const s = document.querySelector('select'); // Asumimos que es el primer select principal
      if (!s) return false;
      for (const opt of s.options) {
          if (opt.value == code || opt.text.includes(code)) {
              s.value = opt.value;
              return true;
          }
      }
      return false;
  }, jobData.newStatusValue);

  if (!statusOk) throw new Error(`No encontré el estado ${jobData.newStatusValue} en el desplegable.`);

  if (jobData.observation) {
      await fillFirstThatExists(page, ['textarea'], jobData.observation);
  }

  // 7. GUARDAR
  const saveBtn = await clickFirstThatExists(page, ['input[value*="Enviar" i]', 'input[value*="Guardar" i]']);
  if (!saveBtn) throw new Error('No encuentro botón Guardar.');
  
  await page.waitForTimeout(3000);
  return { success: true };
}

// --- GESTIÓN DE COLAS ---
async function claimJobById(db, jobId) {
    const ref = db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId);
    return await db.runTransaction(async (tx) => {
      const snap = await tx.get(ref);
      if (!snap.exists || snap.data().status !== 'PENDING') return null;
      tx.set(ref, { status: 'RUNNING', claimedAt: toServerTimestamp() }, { merge: true });
      return { id: jobId, ...snap.data() };
    });
}

async function markJobDone(db, jobId, result) {
    await db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId).set({ status: 'DONE', result }, { merge: true });
    await db.collection(CONFIG.RESULT_COLLECTION).add({ jobId, ok: true, ...result, createdAt: toServerTimestamp() });
}

async function markJobFailed(db, jobId, err) {
    const errData = { message: String(err?.message || err) };
    await db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId).set({ status: 'FAILED', error: errData }, { merge: true });
    await db.collection(CONFIG.RESULT_COLLECTION).add({ jobId, ok: false, error: errData, createdAt: toServerTimestamp() });
}

async function processJob(db, job) {
  console.log(`>>> Procesando: ${job.id}`);
  try {
    const creds = await getHomeServeCreds(db);
    await withBrowser(async (page) => {
      const res = await loginAndProcess(page, creds, {
        serviceNumber: job.parteId || job.serviceNumber,
        newStatusValue: job.nuevoEstado || job.newStatusValue,
        observation: job.nota || ''
      });
      await markJobDone(db, job.id, res);
      console.log(`✅ OK: ${job.id}`);
    });
  } catch (err) {
    console.error(`❌ ERROR: ${err.message}`);
    await markJobFailed(db, job.id, err);
  }
}

function startWorker(db) {
  const queue = [];
  const run = async () => {
      while(queue.length) { await processJob(db, await claimJobById(db, queue.shift())); }
  };
  db.collection(CONFIG.QUEUE_COLLECTION).where('status', '==', 'PENDING').onSnapshot(s => {
      s.docChanges().forEach(c => { if(c.type==='added') { queue.push(c.doc.id); run(); } });
  });
  console.log('🚀 Worker V2 LISTO');
}

startWorker(initFirebase());