import { useCallback, useEffect, useMemo, useState } from "react";
import { useSearchParams } from "react-router";
import {
  EMPTY_FILTERS,
  eventTypeLabel,
  formatDateRange,
  moduleLabel,
  type EventAnalyticsFilters,
} from "@/lib/features/event-analytics/types";

const FILTER_PARAM_KEYS = Object.keys(
  EMPTY_FILTERS,
) as (keyof EventAnalyticsFilters)[];

const hasAnyFilterParam = (params: URLSearchParams) =>
  FILTER_PARAM_KEYS.some((key) => params.has(key));

const filterParamsOnly = (params: URLSearchParams) => {
  const only = new URLSearchParams();
  for (const key of FILTER_PARAM_KEYS) {
    const value = params.get(key);
    if (value) only.set(key, value);
  }
  return only;
};

export function useEventFilters({
  rememberAs,
}: {
  rememberAs?: string;
} = {}) {
  const [searchParams, setSearchParams] = useSearchParams();

  const [remembered] = useState(() => {
    if (!rememberAs || typeof window === "undefined") return null;
    return window.sessionStorage.getItem(rememberAs);
  });

  const filters = useMemo<EventAnalyticsFilters>(
    () => ({
      from: searchParams.get("from"),
      to: searchParams.get("to"),
      eventTypes:
        searchParams.get("eventTypes")?.split(",").filter(Boolean) ?? [],
      memberId: searchParams.get("memberId"),
      currency: searchParams.get("currency"),
      property: searchParams.get("property"),
      source: searchParams.get("source"),
      utmSource: searchParams.get("utmSource"),
      utmMedium: searchParams.get("utmMedium"),
      search: searchParams.get("search"),
    }),
    [searchParams],
  );

  const FILTER_KEYS = [
    "from",
    "to",
    "eventTypes",
    "memberId",
    "currency",
    "property",
    "source",
    "utmSource",
    "utmMedium",
    "search",
  ] as const;

  const setFilters = useCallback(
    (next: Partial<EventAnalyticsFilters>) => {
      const merged = { ...filters, ...next };
      const params = new URLSearchParams(searchParams);
      for (const key of FILTER_KEYS) params.delete(key);
      if (merged.from) params.set("from", merged.from);
      if (merged.to) params.set("to", merged.to);
      if (merged.eventTypes.length)
        params.set("eventTypes", merged.eventTypes.join(","));
      if (merged.memberId) params.set("memberId", merged.memberId);
      if (merged.currency) params.set("currency", merged.currency);
      if (merged.property) params.set("property", merged.property);
      if (merged.source) params.set("source", merged.source);
      if (merged.utmSource) params.set("utmSource", merged.utmSource);
      if (merged.utmMedium) params.set("utmMedium", merged.utmMedium);
      if (merged.search) params.set("search", merged.search);
      setSearchParams(params, { replace: true });
    },
    [filters, searchParams, setSearchParams],
  );

  const resetFilters = useCallback(() => {
    const params = new URLSearchParams(searchParams);
    for (const key of FILTER_KEYS) params.delete(key);
    setSearchParams(params, { replace: true });
  }, [searchParams, setSearchParams]);

  useEffect(() => {
    if (!remembered) return;
    if (hasAnyFilterParam(searchParams)) return;
    const next = new URLSearchParams(searchParams);
    for (const [key, value] of new URLSearchParams(remembered)) {
      next.set(key, value);
    }
    setSearchParams(next, { replace: true });
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  useEffect(() => {
    if (!rememberAs || typeof window === "undefined") return;
    const qs = filterParamsOnly(searchParams).toString();
    if (qs) window.sessionStorage.setItem(rememberAs, qs);
    else window.sessionStorage.removeItem(rememberAs);
  }, [rememberAs, searchParams]);

  const hasActiveFilters =
    Boolean(filters.from) ||
    Boolean(filters.to) ||
    filters.eventTypes.length > 0 ||
    Boolean(filters.memberId) ||
    Boolean(filters.currency) ||
    Boolean(filters.property) ||
    Boolean(filters.source) ||
    Boolean(filters.utmSource) ||
    Boolean(filters.utmMedium) ||
    Boolean(filters.search);

  const filterRows = useMemo(() => {
    const rows: { label: string; value: string }[] = [];
    rows.push({
      label: "Date range",
      value:
        filters.from || filters.to
          ? formatDateRange(filters.from, filters.to)
          : "All time",
    });
    if (filters.eventTypes.length)
      rows.push({
        label: "Event types",
        value: filters.eventTypes.map(eventTypeLabel).join(", "),
      });
    if (filters.memberId)
      rows.push({ label: "Member ID", value: filters.memberId });
    if (filters.currency)
      rows.push({ label: "Currency", value: filters.currency });
    if (filters.property)
      rows.push({ label: "Property", value: filters.property });
    if (filters.source)
      rows.push({ label: "Module", value: moduleLabel(filters.source) });
    if (filters.utmSource)
      rows.push({ label: "Campaign source", value: filters.utmSource });
    if (filters.utmMedium)
      rows.push({ label: "Campaign medium", value: filters.utmMedium });
    if (filters.search) rows.push({ label: "Search", value: filters.search });
    return rows;
  }, [filters]);

  const filtersSummary = filterRows
    .map((r) => `${r.label}: ${r.value}`)
    .join(" · ");

  return {
    filters,
    setFilters,
    resetFilters,
    hasActiveFilters,
    filterRows,
    filtersSummary,
    EMPTY_FILTERS,
  };
}
