import { unstable_cache } from "next/cache";
import { prisma } from "@/lib/prisma";
import { normalizeShiftOverrides, type ShiftOverrideDay } from "@/lib/settings";
import type { RecapMachine, RecapQuery, RecapResponse } from "@/lib/recap/types";

type ShiftLike = {
  name: string;
  startTime?: string | null;
  endTime?: string | null;
  start?: string | null;
  end?: string | null;
  enabled?: boolean;
};

const WEEKDAY_KEYS: ShiftOverrideDay[] = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
const WEEKDAY_KEY_MAP: Record<string, ShiftOverrideDay> = {
  Mon: "mon",
  Tue: "tue",
  Wed: "wed",
  Thu: "thu",
  Fri: "fri",
  Sat: "sat",
  Sun: "sun",
};

const STOP_TYPES = new Set(["microstop", "macrostop"]);
const STOP_STATUS = new Set(["STOP", "DOWN", "OFFLINE"]);
const CACHE_TTL_SEC = 180;
const MOLD_IDLE_MIN = 10;

function safeNum(value: unknown) {
  if (typeof value === "number" && Number.isFinite(value)) return value;
  if (typeof value === "string") {
    const n = Number(value);
    if (Number.isFinite(n)) return n;
  }
  return null;
}

function toIso(value?: Date | null) {
  return value ? value.toISOString() : null;
}

function round2(value: number) {
  return Math.round(value * 100) / 100;
}

function parseDate(input?: string | null) {
  if (!input) return null;
  const n = Number(input);
  if (!Number.isNaN(n)) return new Date(n);
  const d = new Date(input);
  return Number.isNaN(d.getTime()) ? null : d;
}

function normalizeRange(start?: Date, end?: Date) {
  const now = new Date();
  const safeEnd = end && Number.isFinite(end.getTime()) ? end : now;
  const defaultStart = new Date(safeEnd.getTime() - 24 * 60 * 60 * 1000);
  const safeStart = start && Number.isFinite(start.getTime()) ? start : defaultStart;
  if (safeStart.getTime() > safeEnd.getTime()) {
    return { start: new Date(safeEnd.getTime() - 24 * 60 * 60 * 1000), end: safeEnd };
  }
  return { start: safeStart, end: safeEnd };
}

function parseTimeMinutes(input?: string | null) {
  if (!input) return null;
  const match = /^(\d{2}):(\d{2})$/.exec(input.trim());
  if (!match) return null;
  const h = Number(match[1]);
  const m = Number(match[2]);
  if (!Number.isInteger(h) || !Number.isInteger(m) || h < 0 || h > 23 || m < 0 || m > 59) return null;
  return h * 60 + m;
}

function getLocalMinutes(ts: Date, timeZone: string) {
  try {
    const parts = new Intl.DateTimeFormat("en-US", {
      timeZone,
      hour12: false,
      hour: "2-digit",
      minute: "2-digit",
    }).formatToParts(ts);
    const h = Number(parts.find((p) => p.type === "hour")?.value ?? "0");
    const m = Number(parts.find((p) => p.type === "minute")?.value ?? "0");
    return h * 60 + m;
  } catch {
    return ts.getUTCHours() * 60 + ts.getUTCMinutes();
  }
}

function getLocalDayKey(ts: Date, timeZone: string): ShiftOverrideDay {
  try {
    const weekday = new Intl.DateTimeFormat("en-US", { timeZone, weekday: "short" }).format(ts);
    return WEEKDAY_KEY_MAP[weekday] ?? WEEKDAY_KEYS[ts.getUTCDay()];
  } catch {
    return WEEKDAY_KEYS[ts.getUTCDay()];
  }
}

function resolveShiftName(
  shifts: ShiftLike[],
  overrides: Record<string, ShiftLike[]> | undefined,
  ts: Date,
  timeZone: string
) {
  const dayKey = getLocalDayKey(ts, timeZone);
  const dayOverrides = overrides?.[dayKey];
  const activeShifts = dayOverrides ?? shifts;
  if (!activeShifts.length) return null;

  const nowMin = getLocalMinutes(ts, timeZone);
  for (const shift of activeShifts) {
    if (shift.enabled === false) continue;
    const start = parseTimeMinutes(shift.startTime ?? shift.start ?? null);
    const end = parseTimeMinutes(shift.endTime ?? shift.end ?? null);
    if (start == null || end == null) continue;
    if (start <= end) {
      if (nowMin >= start && nowMin < end) return shift.name;
    } else if (nowMin >= start || nowMin < end) {
      return shift.name;
    }
  }

  return null;
}

function normalizeShiftAlias(shift?: string | null) {
  const normalized = String(shift ?? "").trim().toLowerCase();
  if (!normalized) return null;
  if (normalized === "shift1" || normalized === "shift2" || normalized === "shift3") return normalized;
  return null;
}

function eventDurationSec(data: unknown) {
  let blob = data;
  if (typeof blob === "string") {
    try {
      blob = JSON.parse(blob);
    } catch {
      blob = null;
    }
  }
  const record = typeof blob === "object" && blob ? (blob as Record<string, unknown>) : null;
  const innerCandidate = record?.data ?? record ?? {};
  const inner =
    typeof innerCandidate === "object" && innerCandidate !== null
      ? (innerCandidate as Record<string, unknown>)
      : {};

  return (
    safeNum(inner.stoppage_duration_seconds) ??
    safeNum(inner.stop_duration_seconds) ??
    safeNum(inner.duration_seconds) ??
    safeNum(record?.durationSeconds) ??
    0
  );
}

function avg(sum: number, count: number) {
  if (!count) return null;
  return round2(sum / count);
}

export function parseRecapQuery(input: {
  machineId?: string | null;
  start?: string | null;
  end?: string | null;
  shift?: string | null;
}) {
  return {
    machineId: input.machineId ? String(input.machineId).trim() : undefined,
    start: parseDate(input.start),
    end: parseDate(input.end),
    shift: normalizeShiftAlias(input.shift),
  };
}

async function computeRecap(params: Required<Pick<RecapQuery, "orgId">> & {
  machineId?: string;
  start: Date;
  end: Date;
  shift?: string;
}): Promise<RecapResponse> {
  const machineFilter = params.machineId ? { id: params.machineId } : {};
  const machines = await prisma.machine.findMany({
    where: { orgId: params.orgId, ...machineFilter },
    orderBy: { name: "asc" },
    select: { id: true, name: true, location: true },
  });

  if (!machines.length) {
    return {
      range: { start: params.start.toISOString(), end: params.end.toISOString() },
      machines: [],
    };
  }

  const machineIds = machines.map((m) => m.id);
  const [settings, shifts, cyclesRaw, kpisRaw, eventsRaw, reasonsRaw, workOrdersRaw, hbRangeRaw, hbLatestRaw] =
    await Promise.all([
      prisma.orgSettings.findUnique({
        where: { orgId: params.orgId },
        select: { timezone: true, shiftScheduleOverridesJson: true },
      }),
      prisma.orgShift.findMany({
        where: { orgId: params.orgId },
        orderBy: { sortOrder: "asc" },
        select: { name: true, startTime: true, endTime: true, enabled: true, sortOrder: true },
      }),
      prisma.machineCycle.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          ts: { gte: params.start, lte: params.end },
        },
        select: {
          machineId: true,
          ts: true,
          workOrderId: true,
          sku: true,
          goodDelta: true,
          scrapDelta: true,
        },
      }),
      prisma.machineKpiSnapshot.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          ts: { gte: params.start, lte: params.end },
        },
        select: {
          machineId: true,
          ts: true,
          oee: true,
          availability: true,
          performance: true,
          quality: true,
        },
      }),
      prisma.machineEvent.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          ts: { gte: params.start, lte: params.end },
        },
        select: {
          machineId: true,
          ts: true,
          eventType: true,
          data: true,
        },
      }),
      prisma.reasonEntry.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          kind: "downtime",
          capturedAt: { gte: params.start, lte: params.end },
        },
        select: {
          machineId: true,
          capturedAt: true,
          reasonCode: true,
          reasonLabel: true,
          durationSeconds: true,
        },
      }),
      prisma.machineWorkOrder.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
        },
        orderBy: { updatedAt: "desc" },
        select: {
          machineId: true,
          workOrderId: true,
          sku: true,
          targetQty: true,
          status: true,
          createdAt: true,
          updatedAt: true,
        },
      }),
      prisma.machineHeartbeat.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          ts: { gte: params.start, lte: params.end },
        },
        orderBy: [{ machineId: "asc" }, { ts: "asc" }],
        select: {
          machineId: true,
          ts: true,
          tsServer: true,
          status: true,
        },
      }),
      prisma.machineHeartbeat.findMany({
        where: {
          orgId: params.orgId,
          machineId: { in: machineIds },
          ts: { lte: params.end },
        },
        orderBy: [{ machineId: "asc" }, { ts: "desc" }],
        distinct: ["machineId"],
        select: {
          machineId: true,
          ts: true,
          tsServer: true,
          status: true,
        },
      }),
    ]);

  const timeZone = settings?.timezone || "UTC";
  const shiftOverrides = normalizeShiftOverrides(settings?.shiftScheduleOverridesJson);
  const orderedEnabledShifts = shifts.filter((s) => s.enabled !== false).sort((a, b) => a.sortOrder - b.sortOrder);
  const shiftIndex = params.shift ? Number(params.shift.replace("shift", "")) - 1 : -1;
  const targetShiftName = shiftIndex >= 0 ? orderedEnabledShifts[shiftIndex]?.name ?? "__missing_shift__" : null;

  const inTargetShift = (ts: Date) => {
    if (!targetShiftName) return true;
    const resolved = resolveShiftName(shifts, shiftOverrides, ts, timeZone);
    return resolved === targetShiftName;
  };

  const cycles = targetShiftName ? cyclesRaw.filter((row) => inTargetShift(row.ts)) : cyclesRaw;
  const kpis = targetShiftName ? kpisRaw.filter((row) => inTargetShift(row.ts)) : kpisRaw;
  const events = targetShiftName ? eventsRaw.filter((row) => inTargetShift(row.ts)) : eventsRaw;
  const reasons = targetShiftName ? reasonsRaw.filter((row) => inTargetShift(row.capturedAt)) : reasonsRaw;
  const hbRange = targetShiftName ? hbRangeRaw.filter((row) => inTargetShift(row.ts)) : hbRangeRaw;

  const cyclesByMachine = new Map<string, typeof cycles>();
  const cyclesAllByMachine = new Map<string, typeof cyclesRaw>();
  const kpisByMachine = new Map<string, typeof kpis>();
  const eventsByMachine = new Map<string, typeof events>();
  const reasonsByMachine = new Map<string, typeof reasons>();
  const workOrdersByMachine = new Map<string, typeof workOrdersRaw>();
  const hbRangeByMachine = new Map<string, typeof hbRange>();
  const hbLatestByMachine = new Map(hbLatestRaw.map((row) => [row.machineId, row]));

  for (const row of cycles) {
    const list = cyclesByMachine.get(row.machineId) ?? [];
    list.push(row);
    cyclesByMachine.set(row.machineId, list);
  }

  for (const row of cyclesRaw) {
    const list = cyclesAllByMachine.get(row.machineId) ?? [];
    list.push(row);
    cyclesAllByMachine.set(row.machineId, list);
  }

  for (const row of kpis) {
    const list = kpisByMachine.get(row.machineId) ?? [];
    list.push(row);
    kpisByMachine.set(row.machineId, list);
  }

  for (const row of events) {
    const list = eventsByMachine.get(row.machineId) ?? [];
    list.push(row);
    eventsByMachine.set(row.machineId, list);
  }

  for (const row of reasons) {
    const list = reasonsByMachine.get(row.machineId) ?? [];
    list.push(row);
    reasonsByMachine.set(row.machineId, list);
  }

  for (const row of workOrdersRaw) {
    const list = workOrdersByMachine.get(row.machineId) ?? [];
    list.push(row);
    workOrdersByMachine.set(row.machineId, list);
  }

  for (const row of hbRange) {
    const list = hbRangeByMachine.get(row.machineId) ?? [];
    list.push(row);
    hbRangeByMachine.set(row.machineId, list);
  }

  const machineRows: RecapMachine[] = machines.map((machine) => {
    const machineCycles = cyclesByMachine.get(machine.id) ?? [];
    const machineCyclesAll = cyclesAllByMachine.get(machine.id) ?? [];
    const machineKpis = kpisByMachine.get(machine.id) ?? [];
    const machineEvents = eventsByMachine.get(machine.id) ?? [];
    const machineReasons = reasonsByMachine.get(machine.id) ?? [];
    const machineWorkOrders = workOrdersByMachine.get(machine.id) ?? [];
    const machineHbRange = hbRangeByMachine.get(machine.id) ?? [];
    const latestHb = hbLatestByMachine.get(machine.id) ?? null;

    const targetBySku = new Map<string, number>();
    for (const wo of machineWorkOrders) {
      if (!wo.sku || wo.targetQty == null) continue;
      targetBySku.set(wo.sku, (targetBySku.get(wo.sku) ?? 0) + Number(wo.targetQty));
    }

    const skuMap = new Map<string, { sku: string; good: number; scrap: number; target: number | null }>();
    let goodParts = 0;
    let scrapParts = 0;

    for (const cycle of machineCycles) {
      const sku = cycle.sku || "N/A";
      const good = safeNum(cycle.goodDelta) ?? 0;
      const scrap = safeNum(cycle.scrapDelta) ?? 0;
      goodParts += good;
      scrapParts += scrap;

      const row = skuMap.get(sku) ?? {
        sku,
        good: 0,
        scrap: 0,
        target: targetBySku.has(sku) ? targetBySku.get(sku) ?? null : null,
      };
      row.good += good;
      row.scrap += scrap;
      skuMap.set(sku, row);
    }

    const bySku = [...skuMap.values()]
      .map((row) => {
        const produced = row.good + row.scrap;
        const progressPct = row.target && row.target > 0 ? round2((produced / row.target) * 100) : null;
        return { ...row, progressPct };
      })
      .sort((a, b) => b.good - a.good);

    let oeeSum = 0;
    let oeeCount = 0;
    let availabilitySum = 0;
    let availabilityCount = 0;
    let performanceSum = 0;
    let performanceCount = 0;
    let qualitySum = 0;
    let qualityCount = 0;

    for (const kpi of machineKpis) {
      const oee = safeNum(kpi.oee);
      const availability = safeNum(kpi.availability);
      const performance = safeNum(kpi.performance);
      const quality = safeNum(kpi.quality);

      if (oee != null) {
        oeeSum += oee;
        oeeCount += 1;
      }
      if (availability != null) {
        availabilitySum += availability;
        availabilityCount += 1;
      }
      if (performance != null) {
        performanceSum += performance;
        performanceCount += 1;
      }
      if (quality != null) {
        qualitySum += quality;
        qualityCount += 1;
      }
    }

    let stopDurSecFromEvents = 0;
    let stopsCount = 0;
    for (const event of machineEvents) {
      const type = String(event.eventType || "").toLowerCase();
      if (!STOP_TYPES.has(type)) continue;
      stopsCount += 1;
      stopDurSecFromEvents += eventDurationSec(event.data);
    }

    const reasonAgg = new Map<string, { reasonLabel: string; seconds: number; count: number }>();
    let stopDurSecFromReasons = 0;
    for (const reason of machineReasons) {
      const label = reason.reasonLabel?.trim() || reason.reasonCode || "Sin razón";
      const seconds = Math.max(0, safeNum(reason.durationSeconds) ?? 0);
      stopDurSecFromReasons += seconds;
      const agg = reasonAgg.get(label) ?? { reasonLabel: label, seconds: 0, count: 0 };
      agg.seconds += seconds;
      agg.count += 1;
      reasonAgg.set(label, agg);
    }

    const topReasons = [...reasonAgg.values()]
      .sort((a, b) => b.seconds - a.seconds)
      .slice(0, 3)
      .map((row) => ({
        reasonLabel: row.reasonLabel,
        minutes: round2(row.seconds / 60),
        count: row.count,
      }));

    const totalMin = round2(Math.max(stopDurSecFromEvents, stopDurSecFromReasons) / 60);

    let ongoingStopMin: number | null = null;
    const latestStatus = String(latestHb?.status ?? "").toUpperCase();
    const latestTs = latestHb?.tsServer ?? latestHb?.ts ?? null;
    if (latestTs && STOP_STATUS.has(latestStatus)) {
      let downStart = latestTs;
      for (let i = machineHbRange.length - 1; i >= 0; i -= 1) {
        const hb = machineHbRange[i];
        const hbStatus = String(hb.status ?? "").toUpperCase();
        if (!STOP_STATUS.has(hbStatus)) break;
        downStart = hb.tsServer ?? hb.ts;
      }
      ongoingStopMin = round2(Math.max(0, (params.end.getTime() - downStart.getTime()) / 60000));
    }

    const cyclesByWorkOrder = new Map<
      string,
      { goodParts: number; firstTs: Date | null; lastTs: Date | null }
    >();
    for (const cycle of machineCycles) {
      if (!cycle.workOrderId) continue;
      const current = cyclesByWorkOrder.get(cycle.workOrderId) ?? {
        goodParts: 0,
        firstTs: null,
        lastTs: null,
      };
      current.goodParts += safeNum(cycle.goodDelta) ?? 0;
      if (!current.firstTs || cycle.ts < current.firstTs) current.firstTs = cycle.ts;
      if (!current.lastTs || cycle.ts > current.lastTs) current.lastTs = cycle.ts;
      cyclesByWorkOrder.set(cycle.workOrderId, current);
    }

    const completed = machineWorkOrders
      .filter((wo) => String(wo.status).toUpperCase() === "COMPLETED")
      .filter((wo) => wo.updatedAt >= params.start && wo.updatedAt <= params.end)
      .map((wo) => {
        const progress = cyclesByWorkOrder.get(wo.workOrderId) ?? {
          goodParts: 0,
          firstTs: null,
          lastTs: null,
        };
        const durationHrs =
          progress.firstTs && progress.lastTs
            ? round2((progress.lastTs.getTime() - progress.firstTs.getTime()) / 3600000)
            : 0;
        return {
          id: wo.workOrderId,
          sku: wo.sku,
          goodParts: progress.goodParts,
          durationHrs,
        };
      })
      .sort((a, b) => b.goodParts - a.goodParts);

    const activeWo = machineWorkOrders.find((wo) => String(wo.status).toUpperCase() !== "COMPLETED") ?? null;

    let activeProgressPct: number | null = null;
    let activeStartedAt: string | null = null;
    if (activeWo) {
      const progress = cyclesByWorkOrder.get(activeWo.workOrderId);
      const produced = (progress?.goodParts ?? 0) + (machineCycles
        .filter((row) => row.workOrderId === activeWo.workOrderId)
        .reduce((sum, row) => sum + (safeNum(row.scrapDelta) ?? 0), 0));
      if (activeWo.targetQty && activeWo.targetQty > 0) {
        activeProgressPct = round2((produced / activeWo.targetQty) * 100);
      }
      activeStartedAt = toIso(progress?.firstTs ?? activeWo.createdAt);
    }

    const cutoffTs = new Date(params.end.getTime() - MOLD_IDLE_MIN * 60000);
    const hasRecentCycle = machineCyclesAll.some((cycle) => cycle.ts >= cutoffTs && cycle.ts <= params.end);
    const moldChangeInProgress =
      !!activeWo && String(activeWo.status).toUpperCase() === "PENDING" && !hasRecentCycle;

    let uptimePct: number | null = null;
    if (machineHbRange.length) {
      let onlineCount = 0;
      for (const hb of machineHbRange) {
        const status = String(hb.status ?? "").toUpperCase();
        if (!STOP_STATUS.has(status)) onlineCount += 1;
      }
      uptimePct = round2((onlineCount / machineHbRange.length) * 100);
    }

    return {
      machineId: machine.id,
      machineName: machine.name,
      location: machine.location,
      production: {
        goodParts,
        scrapParts,
        totalCycles: machineCycles.length,
        bySku,
      },
      oee: {
        avg: avg(oeeSum, oeeCount),
        availability: avg(availabilitySum, availabilityCount),
        performance: avg(performanceSum, performanceCount),
        quality: avg(qualitySum, qualityCount),
      },
      downtime: {
        totalMin,
        stopsCount,
        topReasons,
        ongoingStopMin,
      },
      workOrders: {
        completed,
        active: activeWo
          ? {
              id: activeWo.workOrderId,
              sku: activeWo.sku,
              progressPct: activeProgressPct,
              startedAt: activeStartedAt,
            }
          : null,
        moldChangeInProgress,
      },
      heartbeat: {
        lastSeenAt: toIso(latestTs),
        uptimePct,
      },
    };
  });

  return {
    range: {
      start: params.start.toISOString(),
      end: params.end.toISOString(),
    },
    machines: machineRows,
  };
}

export async function getRecapDataCached(params: RecapQuery): Promise<RecapResponse> {
  const { start, end } = normalizeRange(params.start, params.end);
  const machineId = params.machineId?.trim() || undefined;
  const shift = normalizeShiftAlias(params.shift) ?? undefined;

  const cacheKey = [
    "recap",
    params.orgId,
    machineId ?? "all",
    String(start.getTime()),
    String(end.getTime()),
    shift ?? "all",
  ];

  const cached = unstable_cache(
    () =>
      computeRecap({
        orgId: params.orgId,
        machineId,
        start,
        end,
        shift,
      }),
    cacheKey,
    {
      revalidate: CACHE_TTL_SEC,
      tags: [`recap:${params.orgId}`],
    }
  );

  return cached();
}