"use client";

import { useRef, useState, useEffect, useCallback, useMemo } from "react";
import { useRouter } from "next/navigation";
import { LayoutGrid, Loader2, Plus } from "lucide-react";
import type { WidgetItem, DashboardAllocation } from "@/types/dashboard";
import { apiGet, apiPost } from "@/utils/api-client";
import { useSortableGrid } from "@/hooks/useSortableGrid";
import { DEFAULT_ALLOCATION } from "./AllocationStateView";
import { AddWidgetModal } from "./AddWidgetModal";
import { WidgetCardContent } from "./WidgetCard";
import { Button } from "@/components/ui/button";

const LAYOUT_STORAGE_KEY = "dashboard-grid-layout";
const DEFAULT_W = 2;
const DEFAULT_H = 2;
/** Column count of the persisted coordinate space — kept at 4 so the payload
 *  written to /api/widget-layout/save is byte-identical to what GridStack
 *  produced, and any layout already saved by the old grid still loads. */
const GRID_COLUMNS = 4;
/** Widgets per visual row (each widget is DEFAULT_W of GRID_COLUMNS). */
const ITEMS_PER_ROW = Math.max(1, Math.floor(GRID_COLUMNS / DEFAULT_W));

const NON_ALLOCATION_DEFAULT: DashboardAllocation = {
  slices: null,
  totals: null,
  loading: false,
  error: null,
};

export type DashboardGridLayout = Record<
  string,
  { x: number; y: number; w: number; h: number }
>;

function areOrdersEqual(a: string[], b: string[]): boolean {
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i += 1) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

function loadSavedLayout(): DashboardGridLayout {
  if (typeof window === "undefined") return {};
  try {
    const raw = localStorage.getItem(LAYOUT_STORAGE_KEY);
    if (!raw) return {};
    const parsed = JSON.parse(raw) as DashboardGridLayout;
    return typeof parsed === "object" && parsed !== null ? parsed : {};
  } catch {
    return {};
  }
}

function saveLayoutToStorage(layout: DashboardGridLayout) {
  try {
    localStorage.setItem(LAYOUT_STORAGE_KEY, JSON.stringify(layout));
  } catch {
    // ignore (private mode / quota)
  }
}

function sanitizeNumber(value: unknown, fallback: number): number {
  const n = Number(value);
  return Number.isFinite(n) ? n : fallback;
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null;
}

/** Accepts every shape the backend has historically returned for a layout. */
function normalizeBackendLayout(payload: unknown): DashboardGridLayout {
  const parseEntry = (raw: unknown, fallbackWidgetId?: string) => {
    if (!isRecord(raw)) return null;
    const idRaw = raw.widget_id ?? fallbackWidgetId;
    const widgetId =
      typeof idRaw === "string" ? idRaw.trim() : typeof idRaw === "number" ? String(idRaw) : "";
    if (!widgetId) return null;

    const x = Math.max(0, Math.trunc(sanitizeNumber(raw.x, 0)));
    const y = Math.max(0, Math.trunc(sanitizeNumber(raw.y, 0)));
    const w = Math.max(1, Math.trunc(sanitizeNumber(raw.w ?? raw.width, DEFAULT_W)));
    const h = Math.max(1, Math.trunc(sanitizeNumber(raw.h ?? raw.height, DEFAULT_H)));
    return { widgetId, value: { x, y, w, h } };
  };

  const out: DashboardGridLayout = {};

  if (Array.isArray(payload)) {
    payload.forEach((item) => {
      const parsed = parseEntry(item);
      if (parsed) out[parsed.widgetId] = parsed.value;
    });
    return out;
  }

  if (!isRecord(payload)) return out;

  const nested =
    (Array.isArray(payload.widgets) && payload.widgets) ||
    (Array.isArray(payload.layout) && payload.layout) ||
    null;
  if (nested) {
    nested.forEach((item) => {
      const parsed = parseEntry(item);
      if (parsed) out[parsed.widgetId] = parsed.value;
    });
    return out;
  }

  Object.entries(payload).forEach(([widgetId, item]) => {
    const parsed = parseEntry(item, widgetId);
    if (parsed) out[parsed.widgetId] = parsed.value;
  });
  return out;
}

/** Derive grid coordinates from a visual order, preserving each widget's w/h. */
function layoutFromOrder(
  order: string[],
  previous: DashboardGridLayout
): DashboardGridLayout {
  const next: DashboardGridLayout = {};
  order.forEach((id, index) => {
    const prev = previous[id];
    next[id] = {
      x: (index % ITEMS_PER_ROW) * DEFAULT_W,
      y: Math.floor(index / ITEMS_PER_ROW) * DEFAULT_H,
      w: Math.max(1, sanitizeNumber(prev?.w, DEFAULT_W)),
      h: Math.max(1, sanitizeNumber(prev?.h, DEFAULT_H)),
    };
  });
  return next;
}

/** Read a saved layout back into a visual order (row-major by y then x). */
function orderFromLayout(widgetIds: string[], layout: DashboardGridLayout): string[] {
  const positioned = widgetIds.filter((id) => layout[id]);
  const unpositioned = widgetIds.filter((id) => !layout[id]);
  positioned.sort((a, b) => {
    const pa = layout[a];
    const pb = layout[b];
    if (pa.y !== pb.y) return pa.y - pb.y;
    return pa.x - pb.x;
  });
  return [...positioned, ...unpositioned];
}

interface DashboardWidgetGridProps {
  widgets: WidgetItem[];
  allocations: Record<string, DashboardAllocation>;
  currency?: string;
  piePalette: string[];
  allWidgets: WidgetItem[];
  selectedWidgetIds: string[];
  onAddWidget: (widget: WidgetItem) => void;
  onSaveOrder: (orderedWidgetIds: string[]) => Promise<void>;
}

export function DashboardWidgetGrid({
  widgets,
  allocations,
  currency,
  piePalette,
  allWidgets,
  selectedWidgetIds,
  onAddWidget,
  onSaveOrder,
}: DashboardWidgetGridProps) {
  const router = useRouter();
  const [layout, setLayout] = useState<DashboardGridLayout>(loadSavedLayout);
  const [showAddModal, setShowAddModal] = useState(false);
  const [saving, setSaving] = useState(false);
  const lastSavedOrderRef = useRef<string[]>([]);
  const hasLoadedLayoutFromBackendRef = useRef(false);
  const layoutRef = useRef(layout);
  layoutRef.current = layout;

  const availableToAdd = allWidgets.filter(
    (w) => w.file_path === "asset_allocation" && !selectedWidgetIds.includes(w.widget_id)
  );

  /** Widgets in their stored order, falling back to priority then id. */
  const baseOrderedIds = useMemo(() => {
    const byPriority = [...widgets].sort((a, b) => {
      const aPriority = Number(a.priority ?? Number.MAX_SAFE_INTEGER);
      const bPriority = Number(b.priority ?? Number.MAX_SAFE_INTEGER);
      if (aPriority !== bPriority) return aPriority - bPriority;
      return a.widget_id.localeCompare(b.widget_id);
    });
    return orderFromLayout(
      byPriority.map((w) => w.widget_id),
      layout
    );
    // `layout` is intentionally read here so a layout arriving from the backend
    // re-seeds the order once; live drags are owned by useSortableGrid.
  }, [widgets, layout]);

  const widgetsById = useMemo(() => {
    const map = new Map<string, WidgetItem>();
    widgets.forEach((w) => map.set(w.widget_id, w));
    return map;
  }, [widgets]);

  useEffect(() => {
    if (!areOrdersEqual(lastSavedOrderRef.current, selectedWidgetIds)) {
      lastSavedOrderRef.current = selectedWidgetIds;
    }
  }, [selectedWidgetIds]);

  // One-time hydrate from the server so the layout follows the user's account
  // rather than just this browser.
  useEffect(() => {
    if (hasLoadedLayoutFromBackendRef.current || widgets.length === 0) return;
    hasLoadedLayoutFromBackendRef.current = true;
    let cancelled = false;

    const loadLayoutFromBackend = async () => {
      try {
        const backendData = await apiGet<unknown>("/api/widget-layout/save");
        const backendLayout = normalizeBackendLayout(backendData);
        if (cancelled || Object.keys(backendLayout).length === 0) return;
        setLayout((prev) => {
          const merged = { ...prev, ...backendLayout };
          saveLayoutToStorage(merged);
          return merged;
        });
      } catch (error) {
        console.warn("[DashboardWidgetGrid] Failed to load persisted layout from backend", error);
      }
    };

    void loadLayoutFromBackend();
    return () => {
      cancelled = true;
    };
  }, [widgets.length]);

  const persistLayoutToBackend = useCallback(async (next: DashboardGridLayout) => {
    if (Object.keys(next).length === 0) return;
    const widgetsPayload = Object.entries(next).map(([widget_id, value]) => ({
      widget_id,
      x: value.x,
      y: value.y,
      width: value.w,
      height: value.h,
    }));
    try {
      await apiPost("/api/widget-layout/save", { widgets: widgetsPayload });
    } catch (error) {
      console.warn("[DashboardWidgetGrid] Failed to persist full layout", error);
    }
  }, []);

  /** Single commit path for a completed reorder — mirrors what the GridStack
   *  `dragstop` handler used to do: local state, localStorage, layout API and
   *  the asset-allocation order API. */
  const handleReorder = useCallback(
    (nextOrder: string[]) => {
      const nextLayout = layoutFromOrder(nextOrder, layoutRef.current);
      setLayout(nextLayout);
      saveLayoutToStorage(nextLayout);
      void persistLayoutToBackend(nextLayout);

      const assetOrder = nextOrder.filter((id) => selectedWidgetIds.includes(id));
      if (assetOrder.length > 0 && !areOrdersEqual(assetOrder, lastSavedOrderRef.current)) {
        lastSavedOrderRef.current = assetOrder;
        setSaving(true);
        onSaveOrder(assetOrder).finally(() => setSaving(false));
      }
    },
    [onSaveOrder, persistLayoutToBackend, selectedWidgetIds]
  );

  const { order, activeId, isKeyboardMode, registerItem, getHandleProps } = useSortableGrid({
    ids: baseOrderedIds,
    onReorder: handleReorder,
  });

  if (widgets.length === 0) {
    return (
      <section className="mt-8">
        {/* Was a dashed emerald panel with a gradient circle and a 📊 emoji —
            off-palette and the only emoji in the product. */}
        <div className="flex flex-col items-center justify-center rounded-lg border border-dashed border-border bg-card px-6 py-14 text-center">
          <span
            className="mb-4 flex size-12 items-center justify-center rounded-full bg-muted text-muted-foreground"
            aria-hidden
          >
            <LayoutGrid className="size-6" />
          </span>
          <p className="text-base font-semibold text-foreground">No widgets yet</p>
          <p className="mt-1.5 max-w-md text-sm leading-relaxed text-muted-foreground">
            Add asset allocation widgets to build a dashboard around the parts of
            your portfolio you follow most closely.
          </p>
          <Button className="mt-5" onClick={() => router.push("/settings/dashboard")}>
            <Plus className="size-4" aria-hidden />
            Add your first widget
          </Button>
        </div>
      </section>
    );
  }

  return (
    <section className="mt-8">
      <div className="widgets-section-header mb-4 flex flex-wrap items-center justify-between gap-3">
        <div>
          <h2 className="text-lg font-semibold tracking-tight text-foreground">
            Your widgets
          </h2>
          <p className="mt-0.5 text-sm text-muted-foreground">
            Drag a widget by its header to rearrange. Your layout is saved
            automatically.
          </p>
        </div>

        <div className="flex items-center gap-3">
          {saving && (
            <span
              className="flex items-center gap-1.5 text-xs font-medium text-muted-foreground"
              role="status"
              aria-live="polite"
            >
              <Loader2 className="size-3.5 animate-spin" aria-hidden />
              Saving…
            </span>
          )}
          <Button size="sm" onClick={() => setShowAddModal(true)}>
            <Plus className="size-4" aria-hidden />
            Add widget
          </Button>
        </div>
      </div>

      {/* Plain CSS grid: one column on phones, two from sm up — the same 2-up
          layout GridStack produced, with gutters matching the stat cards. */}
      <ul className="grid list-none grid-cols-1 gap-4 p-0 sm:grid-cols-2">
        {order.map((widgetId) => {
          const widget = widgetsById.get(widgetId);
          if (!widget) return null;

          const allocation =
            allocations[widgetId] ??
            (widget.file_path === "asset_allocation"
              ? DEFAULT_ALLOCATION
              : NON_ALLOCATION_DEFAULT);
          const isActive = activeId === widgetId;

          return (
            <li
              key={widgetId}
              ref={registerItem(widgetId)}
              data-widget-id={widgetId}
              className={
                "min-h-[19rem] transition-[transform,opacity,box-shadow] duration-200 " +
                (isActive
                  ? "z-10 scale-[1.01] opacity-90 shadow-lg [&_*]:pointer-events-none"
                  : "")
              }
            >
              <WidgetCardContent
                widget={widget}
                allocation={allocation}
                currency={currency}
                piePalette={piePalette}
                dragHandleProps={getHandleProps(widgetId)}
                isDragging={isActive}
                isKeyboardDragging={isActive && isKeyboardMode}
              />
            </li>
          );
        })}
      </ul>

      {/* Screen-reader narration for keyboard reordering. */}
      <p aria-live="polite" className="sr-only">
        {activeId && isKeyboardMode
          ? `${widgetsById.get(activeId)?.name ?? "Widget"} picked up. Use the arrow keys to move it, then press Space to drop.`
          : ""}
      </p>

      {showAddModal && (
        <AddWidgetModal
          available={availableToAdd}
          onSelect={(w) => {
            onAddWidget(w);
            setShowAddModal(false);
          }}
          onClose={() => setShowAddModal(false)}
        />
      )}
    </section>
  );
}
