estados-homeserve/index.js

// worker-homeserve.js
'use strict';

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

// --- CONFIGURACIÓN ---
const CONFIG = {
  // Firestore Collections
  QUEUE_COLLECTION: process.env.QUEUE_COLLECTION || 'homeserve_cambios_estado',
  RESULT_COLLECTION: process.env.RESULT_COLLECTION || 'homeserve_cambios_estado_log',
  
  // Credenciales: Busca en ENV primero, luego en Firestore
  HS_CRED_DOC_PATH: process.env.HS_CRED_DOC_PATH || 'providerCredentials/homeserve',
  
  // URL Base
  CLIENTES_CGI_BASE: process.env.CLIENTES_CGI_BASE || 'https://www.clientes.homeserve.es/cgi-bin/fccgi.exe',

  // Timeouts (Ms)
  NAV_TIMEOUT: 120000,
  SEL_TIMEOUT: 60000,
  
  // Worker Settings
  CLAIM_TTL_MINUTES: 10, // Tiempo antes de robarle la tarea a un worker muerto
  RESCAN_SECONDS: 60     // Cada cuánto mirar si se nos escapó algo
};

// --- UTILS BÁSICOS ---
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
function nowISO() { return new Date().toISOString(); }
function toServerTimestamp() { return admin.firestore.FieldValue.serverTimestamp(); }
function mustEnv(name) {
  const v = process.env[name];
  if (!v) throw new Error(`Falta variable de entorno: ${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 INIT ---
function initFirebase() {
  if (!process.env.FIREBASE_PRIVATE_KEY) throw new Error('Missing env: 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 HOMESERVE ---
async function getHomeServeCreds(db) {
  // 1. Intentar ENV
  const envUser = pickFirstNonEmpty(process.env.HOMESERVE_USER);
  const envPass = pickFirstNonEmpty(process.env.HOMESERVE_PASS);
  if (envUser && envPass) return { user: envUser, pass: envPass };

  // 2. Intentar Firestore
  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);
      if (user && pass) return { user, pass };
    }
  }
  
  throw new Error('No se encontraron credenciales de HomeServe (ni en ENV ni en Firestore).');
}

// --- PLAYWRIGHT HELPERS (LA MAGIA DEL CÓDIGO B) ---
async function withBrowser(fn) {
  const browser = await chromium.launch({
    headless: true, // Pon false si quieres ver lo que hace en local
    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(() => {});
  }
}

// Busca en todos los iframes (vital para HomeServe)
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;
}

// Intenta clickar el primero que encuentre de una lista
async function clickFirstThatExists(page, selectors, opts = {}) {
  for (const sel of selectors) {
    const hit = await findLocatorInFrames(page, sel);
    if (hit) {
      await hit.locator.first().click(opts);
      return sel;
    }
  }
  return null;
}

// Intenta llenar texto en el primero que encuentre
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;
}

// Lógica inteligente para checkboxes
async function checkInformoClienteIfNeeded(page, enabled) {
  if (!enabled) return;
  const labels = ['informado al cliente', 'informado al Cliente', 'Marque esta casilla'];
  
  // 1. Buscar por label directa
  for (const txt of labels) {
    const hit = await findLocatorInFrames(page, `label:has-text("${txt}") >> input[type="checkbox"]`);
    if (hit && !(await hit.locator.first().isChecked())) {
      await hit.locator.first().check();
      return;
    }
  }
}

// Lógica inteligente para Dropdowns (Selects)
async function selectStatusByCode(page, code) {
  const ok = await page.evaluate((codeStr) => {
    const selects = Array.from(document.querySelectorAll('select'));
    // 1. Buscar por value exacto
    for (const s of selects) {
      const opt = Array.from(s.options).find(o => o.value.trim() === codeStr);
      if (opt) {
        s.value = opt.value;
        s.dispatchEvent(new Event('change', { bubbles: true }));
        return true;
      }
    }
    // 2. Buscar por texto
    for (const s of selects) {
      const opt = Array.from(s.options).find(o => o.textContent.includes(codeStr));
      if (opt) {
        s.value = opt.value;
        s.dispatchEvent(new Event('change', { bubbles: true }));
        return true;
      }
    }
    return false;
  }, String(code));

  if (!ok) throw new Error(`No se encontró la opción de estado: ${code} en ningún desplegable.`);
}

// --- ACCIONES DE NEGOCIO ---

async function loginAndProcess(page, creds, jobData) {
  const { serviceNumber, newStatusValue, dateString, observation, informoCliente } = jobData;

  // 1. LOGIN
  await page.goto(CONFIG.CLIENTES_CGI_BASE, { waitUntil: 'domcontentloaded', timeout: CONFIG.NAV_TIMEOUT });
  
  const u = await fillFirstThatExists(page, ['input[name*="user" i]', 'input[type="text"]'], creds.user);
  const p = await fillFirstThatExists(page, ['input[name*="pass" i]', 'input[type="password"]'], creds.pass);
  
  if (u && p) {
    const clicked = await clickFirstThatExists(page, ['button[type="submit"]', 'input[type="submit"]', 'input[type="image"]']);
    if (!clicked) await page.keyboard.press('Enter');
    await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {});
  }

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

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

  // 3. CLICK EN "CAMBIAR ESTADO" (REPASO)
  const changeBtn = await clickFirstThatExists(page, [
    'input[name="repaso"]', 
    'input[title*="Cambiar el Estado" i]', 
    'input[src*="estado1.gif" i]'
  ]);
  if (!changeBtn) throw new Error('No se encontró el botón de cambiar estado (repaso). ¿Login fallido?');

  await page.waitForLoadState('domcontentloaded');
  await sleep(1000);

  // 4. RELLENAR FORMULARIO
  // Estado
  await selectStatusByCode(page, newStatusValue);

  // Fecha (si aplica)
  if (dateString) {
    await fillFirstThatExists(page, ['input[name*="fecha" i]', 'input[id*="fecha" i]', 'input[size="10"]'], dateString);
  }

  // Nota
  if (observation) {
    await fillFirstThatExists(page, ['textarea[name*="obs" i]', 'textarea[name*="nota" i]', 'textarea'], observation);
  }

  // Checkbox cliente
  await checkInformoClienteIfNeeded(page, informoCliente);

  // 5. GUARDAR
  const saveBtn = await clickFirstThatExists(page, [
    'input[type="submit"][value*="Enviar" i]',
    'input[type="submit"][value*="Guardar" i]',
    'button:has-text("Enviar")',
    'button:has-text("Guardar")'
  ]);
  
  if (!saveBtn) throw new Error('No se encontró el botón de Guardar.');
  
  await page.waitForLoadState('networkidle', { timeout: 20000 }).catch(() => {});
  
  return { success: true, serviceUrl: serviceUrl.toString() };
}

// --- GESTIÓN DE COLAS (EL CEREBRO DEL CÓDIGO A) ---

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) return null;

    const d = snap.data();
    const st = d.status || 'PENDING';
    const claimedAt = d.claimedAt ? d.claimedAt.toMillis() : 0;
    const now = Date.now();
    const isStale = (st === 'RUNNING') && ((now - claimedAt) > (CONFIG.CLAIM_TTL_MINUTES * 60 * 1000));

    // Solo cogemos PENDING o RUNNING caducados
    if (st !== 'PENDING' && !isStale) return null;

    tx.set(ref, {
      status: 'RUNNING',
      claimedAt: toServerTimestamp(),
      lastSeenAt: toServerTimestamp(),
      workerId: process.env.HOSTNAME || 'worker-local'
    }, { merge: true });

    return { id: jobId, ...d };
  });
}

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

  await db.collection(CONFIG.RESULT_COLLECTION).add({
    jobId,
    ok: true,
    ...result,
    createdAt: toServerTimestamp()
  });
}

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

  await db.collection(CONFIG.RESULT_COLLECTION).add({
    jobId,
    ok: false,
    error: errData,
    createdAt: toServerTimestamp()
  });
}

// --- BUCLE PRINCIPAL ---

async function processJob(db, job) {
  console.log(`>>> Procesando Job: ${job.id}`);
  
  // Mapeo de campos flexibles (para que acepte inputs variados)
  const jobData = {
    serviceNumber: job.parteId || job.serviceNumber || job.codigo,
    newStatusValue: job.nuevoEstado || job.newStatusValue || job.statusCode,
    dateString: job.fecha || job.dateString || '',
    observation: job.nota || job.observation || '',
    informoCliente: job.informoCliente || false
  };

  if (!jobData.serviceNumber || !jobData.newStatusValue) {
    await markJobFailed(db, job.id, new Error('Faltan datos obligatorios: serviceNumber o newStatusValue'));
    return;
  }

  try {
    const creds = await getHomeServeCreds(db);
    
    await withBrowser(async (page) => {
      const res = await loginAndProcess(page, creds, jobData);
      await markJobDone(db, job.id, res);
      console.log(`✅ Job ${job.id} completado.`);
    });
  } catch (err) {
    console.error(`❌ Job ${job.id} falló:`, err.message);
    await markJobFailed(db, job.id, err);
  }
}

// Listener Reactivo
function startWorker(db) {
  const queue = [];
  let isProcessing = false;

  const processQueue = async () => {
    if (isProcessing) return;
    isProcessing = true;
    while (queue.length > 0) {
      const jobId = queue.shift();
      const job = await claimJobById(db, jobId);
      if (job) await processJob(db, job);
    }
    isProcessing = false;
  };

  const enqueue = (id) => {
    if (!queue.includes(id)) {
      queue.push(id);
      processQueue();
    }
  };

  // 1. Escuchar nuevos
  db.collection(CONFIG.QUEUE_COLLECTION)
    .where('status', '==', 'PENDING')
    .onSnapshot(snap => {
      snap.docChanges().forEach(change => {
        if (change.type === 'added') enqueue(change.doc.id);
      });
    });

  // 2. Rescaneo de seguridad (polling)
  setInterval(async () => {
    const snap = await db.collection(CONFIG.QUEUE_COLLECTION)
      .where('status', '==', 'PENDING')
      .limit(10).get();
    snap.forEach(doc => enqueue(doc.id));
  }, CONFIG.RESCAN_SECONDS * 1000);

  console.log('🚀 Worker HomeServe iniciado. Esperando trabajos en Firestore...');
}

// Start
const db = initFirebase();
startWorker(db);