const RRLogger = require("../rr/rr-logger");
const { rrCombinedSearch, rrGetAdvisors, rrGetParts } = require("../rr/rr-lookup");
const { QueryJobData } = require("../rr/rr-job-helpers");
const { exportJobToRR } = require("../rr/rr-job-export");
const CdkCalculateAllocations = require("../cdk/cdk-calculate-allocations").default;
const { createRRCustomer } = require("../rr/rr-customers");

const { buildClientAndOpts } = require("../rr/rr-lookup");
const { GraphQLClient } = require("graphql-request");
const queries = require("../graphql-client/queries");

// ---------------- utils ----------------

function resolveJobId(explicit, payload, job) {
  return explicit || payload?.jobId || payload?.jobid || job?.id || job?.jobId || job?.jobid || null;
}

// ---- local helpers (avoid no-undef) ----
const digitsOnly = (s) => String(s || "").replace(/\D/g, "");

const makeVehicleSearchPayloadFromJob = (job) => {
  const vin = job?.v_vin || job?.vehicle?.vin || job?.vehicle_vin || job?.vin;
  if (vin) return { kind: "vin", vin: String(vin).trim() };
  const plate = job?.plate_no || job?.vehicle?.plate || job?.vehicle_plate || job?.plate;
  if (plate) return { kind: "license", license: String(plate).trim() };
  return null;
};

const makeCustomerSearchPayloadFromJob = (job) => {
  const phone = job?.ownr_ph1 || job?.customer?.mobile || job?.customer?.home_phone || job?.customer?.phone;
  const d = digitsOnly(phone);
  if (d.length >= 7) return { kind: "phone", phone: d };

  const lastName = job?.ownr_ln || job?.customer?.last_name || job?.customer?.lastName;
  const company = job?.ownr_co_nm || job?.customer?.company_name || job?.customer?.companyName;
  const lnOrCompany = lastName || company;
  if (lnOrCompany) return { kind: "name", name: { name: String(lnOrCompany).trim() } };

  const vin = job?.v_vin || job?.vehicle?.vin || job?.vehicle_vin || job?.vin;
  if (vin) return { kind: "vin", vin: String(vin).trim() };

  return null;
};

const normalizeCustomerCandidates = (res) => {
  // CombinedSearch may return array or { data: [...] }
  const blocks = Array.isArray(res?.data) ? res.data : Array.isArray(res) ? res : [];
  const out = [];
  for (const blk of blocks) {
    const serv = Array.isArray(blk?.ServVehicle) ? blk.ServVehicle : [];
    const custNos = serv.map((sv) => sv?.VehicleServInfo?.CustomerNo).filter(Boolean);

    const nci = blk?.NameContactId;
    const ind = nci?.NameId?.IndName;
    const bus = nci?.NameId?.BusName;
    const personal = [ind?.FName, ind?.LName].filter(Boolean).join(" ").trim();
    const company = bus?.CompanyName;
    const name = (personal || company || "").trim();

    for (const custNo of custNos) {
      out.push({ custNo, name: name || `Customer ${custNo}` });
    }
  }
  const seen = new Set();
  return out.filter((c) => {
    const key = String(c.custNo || "").trim();
    if (!key || seen.has(key)) return false;
    seen.add(key);
    return true;
  });
};

async function getSessionOrSocket(redisHelpers, socket) {
  let sess = null;
  try {
    sess = await redisHelpers.getSessionData(socket.id);
  } catch {
    /* ignore */
  }
  const bodyshopId = sess?.bodyshopId ?? socket.bodyshopId;
  const email = sess?.email ?? socket.user?.email;
  if (!bodyshopId) throw new Error("No bodyshopId (session/socket)");
  return { bodyshopId, email, sess };
}

async function getBodyshopForSocket({ bodyshopId, socket }) {
  const endpoint = process.env.GRAPHQL_ENDPOINT;
  if (!endpoint) throw new Error("GRAPHQL_ENDPOINT not configured");

  const token = (socket?.data && socket.data.authToken) || (socket?.handshake?.auth && socket.handshake.auth.token);

  const client = new GraphQLClient(endpoint, {});
  const res = await client
    .setHeaders({ Authorization: `Bearer ${token}` })
    .request(queries.GET_BODYSHOP_BY_ID, { id: bodyshopId });

  const bodyshop = res?.bodyshops_by_pk;
  if (!bodyshop) throw new Error(`Bodyshop not found: ${bodyshopId}`);
  return bodyshop;
}

// ---------------- register handlers ----------------

function registerRREvents({ socket, redisHelpers }) {
  // RRLogger returns a log(level, message, ctx) function
  const log = RRLogger(socket);

  // Lookups (mirrors Fortellis shape/flow)
  socket.on("rr-lookup-combined", async ({ jobid, params } = {}, cb) => {
    try {
      const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
      const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });

      const res = await rrCombinedSearch(bodyshop, params || {});
      const data = res?.data ?? res;

      cb?.({ jobid: resolveJobId(jobid, { jobid }, null), data });

      // Push to FE to open the table; keep payload as the raw array (FE maps columns itself)
      socket.emit("rr-select-customer", Array.isArray(data) ? data : data?.customers || []);
    } catch (e) {
      log("error", `RR combined lookup error: ${e.message}`, { jobid });
      cb?.({ jobid, error: e.message });
    }
  });

  // Advisors
  socket.on("rr-get-advisors", async (args = {}, ack) => {
    try {
      const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
      const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
      const res = await rrGetAdvisors(bodyshop, args);
      ack?.({ ok: true, result: res });
      socket.emit("rr-get-advisors:result", res);
    } catch (err) {
      log("error", err?.message || "get advisors failed", { err });
      ack?.({ ok: false, error: err?.message || "get advisors failed" });
    }
  });

  // Parts
  socket.on("rr-get-parts", async (args = {}, ack) => {
    try {
      const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
      const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });
      const res = await rrGetParts(bodyshop, args);
      ack?.({ ok: true, result: res });
      socket.emit("rr-get-parts:result", res);
    } catch (err) {
      log("error", err?.message || "get parts failed", { err });
      ack?.({ ok: false, error: err?.message || "get parts failed" });
    }
  });

  // Persist customer selection (or flag create-new)
  socket.on("rr-selected-customer", async (selected, ack) => {
    try {
      await getSessionOrSocket(redisHelpers, socket);
      const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};

      // Signal create-new intent
      if (!selected || selected?.create === true || selected?.__new === true) {
        await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrCreateCustomer: true });
        log("info", "rr-selected-customer:new-customer-intent");
        socket.emit("rr-customer-create-required");
        return ack?.({ ok: true, action: "create" });
      }

      await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedCustomer: selected });
      log("info", "rr-selected-customer", { selected });
      ack?.({ ok: true });
    } catch (err) {
      log("error", err?.message || "select customer failed", { err });
      ack?.({ ok: false, error: err?.message || "select customer failed" });
    }
  });

  // Optional explicit create-customer from UI form
  socket.on("rr-create-customer", async ({ jobId, fields } = {}, ack) => {
    try {
      const { bodyshopId } = await getSessionOrSocket(redisHelpers, socket);
      const bodyshop = await getBodyshopForSocket({ bodyshopId, socket });

      if (!jobId) throw new Error("jobId required");
      const job = await QueryJobData({ redisHelpers }, jobId);

      const { custNo } = await createRRCustomer({ bodyshop, job, overrides: fields || {}, socket });

      const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
      await redisHelpers.setSessionTransactionData(socket.id, {
        ...tx,
        rrSelectedCustomer: { custNo },
        rrCreateCustomer: false
      });

      log("info", "rr-create-customer:success", { custNo });
      socket.emit("rr-customer-created", { custNo });
      ack?.({ ok: true, custNo });
    } catch (err) {
      log("error", err?.message || "create customer failed", { err });
      ack?.({ ok: false, error: err?.message || "create customer failed" });
    }
  });

  // Vehicle selection helpers
  socket.on("rr-selected-vehicle", async (selected, ack) => {
    try {
      await getSessionOrSocket(redisHelpers, socket);
      if (!selected?.vin) throw new Error("selected vehicle must include vin");
      const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
      await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedVehicle: selected });
      log("info", "rr-selected-vehicle", { vin: selected.vin });
      ack?.({ ok: true });
    } catch (err) {
      log("error", err?.message || "select vehicle failed", { err });
      ack?.({ ok: false, error: err?.message || "select vehicle failed" });
    }
  });

  socket.on("rr-create-vehicle", async (vehicle, ack) => {
    try {
      await getSessionOrSocket(redisHelpers, socket);
      if (!vehicle?.vin) throw new Error("vehicle.vin required");
      const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
      await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrSelectedVehicle: vehicle });
      log("info", "rr-create-vehicle", { vin: vehicle.vin });
      ack?.({ ok: true });
    } catch (err) {
      log("error", err?.message || "create vehicle failed", { err });
      ack?.({ ok: false, error: err?.message || "create vehicle failed" });
    }
  });

  socket.on("rr-export-job", async (payload = {}) => {
    const log = RRLogger(socket, { ns: "rr" });

    try {
      // -------- 1) Resolve job --------
      let job = payload.job || payload.txEnvelope?.job;
      const jobId = payload.jobId || payload.jobid || payload.txEnvelope?.jobId || job?.id;

      if (!job) {
        if (!jobId) throw new Error("RR export: job or jobId required");
        job = await QueryJobData({ redisHelpers }, jobId);
      }

      // -------- 2) Resolve bodyshop (+ full row via GraphQL) --------
      let bodyshopId = payload.bodyshopId || payload.bodyshopid || payload.bodyshopUUID || job?.bodyshop?.id;
      if (!bodyshopId) {
        const sess = await getSessionOrSocket(redisHelpers, socket);
        bodyshopId = sess.bodyshopId;
      }
      if (!bodyshopId) throw new Error("RR export: bodyshopId required");

      const bodyshop =
        job?.bodyshop && (job.bodyshop.rr_dealerid || job.bodyshop.rr_configuration)
          ? job.bodyshop
          : await getBodyshopForSocket({ bodyshopId, socket });

      // -------- 3) Resolve advisor number from the posting form --------
      const tx = (await redisHelpers.getSessionTransactionData(socket.id)) || {};
      const advisorNo = payload.advisorNo || payload.advNo || payload.txEnvelope?.advisorNo || tx.rrAdvisorNo || null;

      if (!advisorNo || String(advisorNo).trim() === "") {
        socket.emit("export-failed", { vendor: "rr", jobId, error: "Advisor is required (advisorNo)." });
        return;
      }
      // Persist for subsequent steps if useful
      await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrAdvisorNo: String(advisorNo) });

      // -------- 4) Resolve selected customer (payload → tx) --------
      let selectedCustomer = null;

      // from payload
      if (payload.selectedCustomer) {
        if (typeof payload.selectedCustomer === "object" && payload.selectedCustomer.custNo) {
          selectedCustomer = { custNo: String(payload.selectedCustomer.custNo) };
        } else if (typeof payload.selectedCustomer === "string" || typeof payload.selectedCustomer === "number") {
          selectedCustomer = { custNo: String(payload.selectedCustomer) };
        }
      }

      // from tx
      if (!selectedCustomer && tx.rrSelectedCustomer) {
        if (typeof tx.rrSelectedCustomer === "object" && tx.rrSelectedCustomer.custNo) {
          selectedCustomer = { custNo: String(tx.rrSelectedCustomer.custNo) };
        } else {
          selectedCustomer = { custNo: String(tx.rrSelectedCustomer) };
        }
      }

      // Flags
      const forceCreate = payload.forceCreate === true || tx.rrCreateCustomer === true;
      const autoCreateOnNoMatch = payload.autoCreateOnNoMatch !== false; // default TRUE

      // -------- 5) If no selection & not "forceCreate", try auto-search first --------
      if (!selectedCustomer && !forceCreate) {
        const customerQuery = makeCustomerSearchPayloadFromJob(job);
        const vehicleQuery = makeVehicleSearchPayloadFromJob(job);
        const query = customerQuery || vehicleQuery;

        if (query) {
          log("info", "rr-export-job:customer-preselect-search", { query, jobId });
          const searchRes = await rrCombinedSearch(bodyshop, query);
          const candidates = normalizeCustomerCandidates(searchRes);

          if (candidates.length === 1) {
            // auto-pick single hit
            selectedCustomer = { custNo: String(candidates[0].custNo) };
            await redisHelpers.setSessionTransactionData(socket.id, {
              ...tx,
              rrSelectedCustomer: selectedCustomer.custNo,
              rrCreateCustomer: false
            });
            log("info", "rr-export-job:auto-selected-customer", { jobId, custNo: selectedCustomer.custNo });
          } else if (candidates.length > 1) {
            // multiple matches → ask UI to pick and STOP here
            const table = candidates.map((c) => ({
              CustomerId: c.custNo,
              customerId: c.custNo,
              CustomerName: { FirstName: c.name || String(c.custNo), LastName: "" }
            }));
            socket.emit("rr-select-customer", table);
            socket.emit("rr-log-event", { level: "info", message: "RR: customer selection required", ts: Date.now() });
            return;
          } else {
            // 0 matches → auto-create by default
            if (autoCreateOnNoMatch) {
              const { createRRCustomer } = require("../rr/rr-customers");
              const created = await createRRCustomer({ bodyshop, job, socket });
              const custNo = created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey;
              if (!custNo) throw new Error("RR create customer returned no custNo");
              selectedCustomer = { custNo: String(custNo) };
              await redisHelpers.setSessionTransactionData(socket.id, {
                ...tx,
                rrSelectedCustomer: selectedCustomer.custNo,
                rrCreateCustomer: false
              });
              log("info", "rr-export-job:auto-created-customer", { jobId, custNo: selectedCustomer.custNo });
            } else {
              await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrCreateCustomer: true });
              socket.emit("rr-customer-create-required");
              socket.emit("rr-log-event", { level: "info", message: "RR: create customer required", ts: Date.now() });
              return;
            }
          }
        } else {
          // no usable query → fall back to create or UI prompt
          if (autoCreateOnNoMatch) {
            const { createRRCustomer } = require("../rr/rr-customers");
            const created = await createRRCustomer({ bodyshop, job, socket });
            const custNo = created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey;
            if (!custNo) throw new Error("RR create customer returned no custNo");
            selectedCustomer = { custNo: String(custNo) };
            await redisHelpers.setSessionTransactionData(socket.id, {
              ...tx,
              rrSelectedCustomer: selectedCustomer.custNo,
              rrCreateCustomer: false
            });
            log("info", "rr-export-job:auto-created-customer(no-query)", { jobId, custNo: selectedCustomer.custNo });
          } else {
            await redisHelpers.setSessionTransactionData(socket.id, { ...tx, rrCreateCustomer: true });
            socket.emit("rr-customer-create-required");
            socket.emit("rr-log-event", { level: "info", message: "RR: create customer required", ts: Date.now() });
            return;
          }
        }
      }

      // -------- 6) If still not selected & creation is allowed, create now --------
      if (!selectedCustomer && (forceCreate || autoCreateOnNoMatch)) {
        const { createRRCustomer } = require("../rr/rr-customers");
        const created = await createRRCustomer({ bodyshop, job, socket });
        const custNo = created?.custNo || created?.customerNo || created?.CustomerNo || created?.dmsRecKey;
        if (!custNo) throw new Error("RR create customer returned no custNo");
        selectedCustomer = { custNo: String(custNo) };
        await redisHelpers.setSessionTransactionData(socket.id, {
          ...tx,
          rrSelectedCustomer: selectedCustomer.custNo,
          rrCreateCustomer: false
        });
        log("info", "rr-export-job:customer-created", { jobId, custNo: selectedCustomer.custNo });
      }

      if (!selectedCustomer?.custNo) throw new Error("RR export: selected customer missing custNo");

      // -------- 7) Perform export (ensure SV + create/update RO) --------
      const result = await exportJobToRR({
        bodyshop,
        job,
        selectedCustomer,
        advisorNo,
        existing: payload.existing,
        socket
      });

      if (result?.success) {
        socket.emit("export-success", { vendor: "rr", jobId, roStatus: result.roStatus });
      } else {
        socket.emit("export-failed", {
          vendor: "rr",
          jobId,
          roStatus: result?.roStatus,
          error: result?.error || "RR export failed"
        });
      }

      socket.emit("rr-export-job:result", { jobId, bodyshopId, result });
    } catch (error) {
      const jobId = payload.jobId || payload.jobid || payload.txEnvelope?.jobId || payload?.job?.id;
      log("error", `Error during RR export: ${error.message}`, { jobId, stack: error.stack });
      try {
        socket.emit("export-failed", { vendor: "rr", jobId, error: error.message });
      } catch {
        /* ignore */
      }
    }
  });

  // Allocations (RR reuses CDK calculator)
  socket.on("rr-calculate-allocations", async (jobid, cb) => {
    try {
      const allocations = await CdkCalculateAllocations(socket, jobid);
      cb?.(allocations);
      socket.emit("rr-calculate-allocations:result", allocations);
    } catch (e) {
      log("error", `RR allocations error: ${e.message}`, { jobid });
      cb?.({ ok: false, error: e.message });
    }
  });
}

module.exports = registerRREvents;