"use client";

import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
import { quotaResponseSchema, type QuotaResponse } from "@/lib/validation";

const POLL_INTERVAL_MS = 45_000;
const REQUEST_TIMEOUT_MS = 10_000;

export type QuotaState =
  | { status: "loading" }
  | { status: "ready"; data: QuotaResponse }
  | { status: "error" };

type QuotaContextValue = {
  state: QuotaState;
  refreshing: boolean;
  refresh: () => Promise<QuotaState>;
};

const QuotaContext = createContext<QuotaContextValue | null>(null);

async function fetchQuota(): Promise<QuotaState> {
  try {
    const res = await fetch("/api/quota/offline", {
      cache: "no-store",
      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
    });
    if (!res.ok) return { status: "error" };
    const parsed = quotaResponseSchema.safeParse(await res.json());
    return parsed.success ? { status: "ready", data: parsed.data } : { status: "error" };
  } catch {
    return { status: "error" };
  }
}

export function QuotaProvider({ children }: { children: React.ReactNode }) {
  const [state, setState] = useState<QuotaState>({ status: "loading" });
  const [refreshing, setRefreshing] = useState(false);
  const inflight = useRef<Promise<QuotaState> | null>(null);

  const refresh = useCallback(() => {
    if (inflight.current) return inflight.current;
    setRefreshing(true);
    const request = fetchQuota().then((next) => {
      setState(next);
      setRefreshing(false);
      inflight.current = null;
      return next;
    });
    inflight.current = request;
    return request;
  }, []);

  useEffect(() => {
    let timer: ReturnType<typeof setInterval> | undefined;

    const start = () => {
      clearInterval(timer);
      timer = setInterval(() => void refresh(), POLL_INTERVAL_MS);
    };
    const onVisibility = () => {
      if (document.visibilityState === "visible") {
        void refresh();
        start();
      } else {
        clearInterval(timer);
      }
    };

    void refresh();
    start();
    document.addEventListener("visibilitychange", onVisibility);
    return () => {
      clearInterval(timer);
      document.removeEventListener("visibilitychange", onVisibility);
    };
  }, [refresh]);

  return (
    <QuotaContext.Provider value={{ state, refreshing, refresh }}>{children}</QuotaContext.Provider>
  );
}

export function useQuota() {
  const ctx = useContext(QuotaContext);
  if (!ctx) throw new Error("useQuota harus dipakai di dalam <QuotaProvider>");
  return ctx;
}

export function formatUpdatedAt(iso: string) {
  return new Intl.DateTimeFormat("id-ID", {
    dateStyle: "medium",
    timeStyle: "medium",
    timeZone: "Asia/Makassar",
  }).format(new Date(iso));
}
