'use client';

import { createContext, useContext, useEffect, useRef, type ReactNode } from 'react';
import { useParams } from 'next/navigation';

import { useUIStore } from '@/stores/ui-store';
import { apiFetch } from '@/lib/api/client';
import type { Port } from '@/lib/db/schema/ports';

interface PortContextValue {
  ports: Port[];
  currentPort: Port | null;
  currentPortId: string | null;
  currentPortSlug: string | null;
  /** Per-port feature-flag map — currently just the Tenancies module.
   *  Resolved server-side in the dashboard layout. Consumers read via
   *  `useTenanciesModuleEnabled()`. */
  tenanciesModuleByPort: Record<string, boolean>;
  /** Per-port Maintenance-module flag. Resolved server-side in the
   *  dashboard layout; consumers read via `useMaintenanceModuleEnabled()`.
   *  Defaults to enabled (unset port => true). */
  maintenanceModuleByPort: Record<string, boolean>;
}

const PortContext = createContext<PortContextValue>({
  ports: [],
  currentPort: null,
  currentPortId: null,
  currentPortSlug: null,
  tenanciesModuleByPort: {},
  maintenanceModuleByPort: {},
});

interface PortProviderProps {
  children: ReactNode;
  ports: Port[];
  defaultPortId: string | null;
  tenanciesModuleByPort?: Record<string, boolean>;
  maintenanceModuleByPort?: Record<string, boolean>;
}

export function PortProvider({
  children,
  ports,
  defaultPortId,
  tenanciesModuleByPort = {},
  maintenanceModuleByPort = {},
}: PortProviderProps) {
  const params = useParams();
  const portSlugFromUrl = params?.portSlug as string | undefined;

  const setPort = useUIStore((s) => s.setPort);
  const currentPortId = useUIStore((s) => s.currentPortId);
  const currentPortSlug = useUIStore((s) => s.currentPortSlug);

  // Resolve current port - URL slug takes priority over stored port
  const currentPort =
    ports.find((p) => p.slug === portSlugFromUrl) ??
    ports.find((p) => p.id === currentPortId) ??
    (defaultPortId ? (ports.find((p) => p.id === defaultPortId) ?? null) : null);

  // Sync Zustand store whenever the active port changes
  useEffect(() => {
    if (currentPort && (currentPort.id !== currentPortId || currentPort.slug !== currentPortSlug)) {
      setPort(currentPort.id, currentPort.slug);
    }
  }, [currentPort, currentPortId, currentPortSlug, setPort]);

  // Remember the last port the user landed on (URL-derived or
  // explicit-switch) so the next login routes here automatically. Tracked
  // in a ref-keyed dedupe so we only PATCH when the active port actually
  // changes - re-renders inside the same port don't write. Fire-and-forget;
  // a transient network failure shouldn't block navigation, and the
  // post-login resolver verifies access so a stale value can't strand the
  // user on a 403.
  const lastPersistedPortIdRef = useRef<string | null>(null);
  useEffect(() => {
    if (!currentPort) return;
    if (lastPersistedPortIdRef.current === currentPort.id) return;
    lastPersistedPortIdRef.current = currentPort.id;
    void apiFetch('/api/v1/me', {
      method: 'PATCH',
      body: { preferences: { defaultPortId: currentPort.id } },
    }).catch(() => {
      /* silent - best-effort */
    });
  }, [currentPort]);

  return (
    <PortContext.Provider
      value={{
        ports,
        currentPort: currentPort ?? null,
        currentPortId: currentPort?.id ?? null,
        currentPortSlug: currentPort?.slug ?? null,
        tenanciesModuleByPort,
        maintenanceModuleByPort,
      }}
    >
      {children}
    </PortContext.Provider>
  );
}

export function usePortContext(): PortContextValue {
  return useContext(PortContext);
}

/** Read the tenancies-module-enabled flag for the currently-active port.
 *  Server-side resolved in the dashboard layout, so this is a synchronous
 *  read with no fetch latency or hydration flicker. */
export function useTenanciesModuleEnabled(): boolean {
  const { currentPortId, tenanciesModuleByPort } = useContext(PortContext);
  if (!currentPortId) return false;
  return tenanciesModuleByPort[currentPortId] ?? false;
}

/** Read the maintenance-module-enabled flag for the currently-active port.
 *  Defaults to ENABLED (true) when unset so the feature stays visible
 *  unless an admin has explicitly turned it off. Server-side resolved in
 *  the dashboard layout — synchronous read, no fetch latency/flicker. */
export function useMaintenanceModuleEnabled(): boolean {
  const { currentPortId, maintenanceModuleByPort } = useContext(PortContext);
  if (!currentPortId) return true;
  return maintenanceModuleByPort[currentPortId] ?? true;
}
