import {
  Autocomplete,
  Button,
  Group,
  MultiSelect,
  Select,
  Text,
  TextInput,
} from "@mantine/core";
import { DatePickerInput } from "@mantine/dates";
import { useDebouncedCallback } from "@mantine/hooks";
import {
  IconCalendarStats,
  IconCoin,
  IconSearch,
  IconSpeakerphone,
  IconTags,
  IconUser,
} from "@tabler/icons-react";
import { useEffect, useMemo, useState } from "react";
import {
  ActiveFilterChips,
  FilterDrawer,
  FilterSection,
  FilterTrigger,
  type FilterChip,
} from "@/routes/promo-code-campaigns/_components/FilterDrawer";
import {
  eventTypeLabel,
  formatDateRange,
  moduleLabel,
  type EventAnalyticsFilters,
} from "@/lib/features/event-analytics/types";

const toDateParam = (value: unknown): string | null => {
  if (!value) return null;
  if (typeof value === "string") {
    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
    const parsed = new Date(value);
    if (Number.isNaN(parsed.getTime())) return null;
    return toDateParam(parsed);
  }
  if (value instanceof Date) {
    if (Number.isNaN(value.getTime())) return null;
    const y = value.getFullYear();
    const m = String(value.getMonth() + 1).padStart(2, "0");
    const d = String(value.getDate()).padStart(2, "0");
    return `${y}-${m}-${d}`;
  }
  return null;
};

const QUICK_RANGES: {
  label: string;
  resolve: () => { from: string; to: string };
}[] = [
    {
      label: "Last 7 days",
      resolve: () => {
        const to = new Date();
        const from = new Date(to.getTime() - 6 * 24 * 60 * 60 * 1000);
        return { from: toDateParam(from)!, to: toDateParam(to)! };
      },
    },
    {
      label: "Last 30 days",
      resolve: () => {
        const to = new Date();
        const from = new Date(to.getTime() - 29 * 24 * 60 * 60 * 1000);
        return { from: toDateParam(from)!, to: toDateParam(to)! };
      },
    },
    {
      label: "This month",
      resolve: () => {
        const to = new Date();
        const from = new Date(to.getFullYear(), to.getMonth(), 1);
        return { from: toDateParam(from)!, to: toDateParam(to)! };
      },
    },
  ];

type FilterBarProps = {
  filters: EventAnalyticsFilters;
  onChange: (next: Partial<EventAnalyticsFilters>) => void;
  onReset: () => void;
  availableEventTypes: string[];
  availableCurrencies: string[];
  availableProperties: string[];
  availableSources: string[];
  availableUtmSources: string[];
  availableUtmMediums: string[];
};

function useFilterChips(
  filters: EventAnalyticsFilters,
  onChange: (next: Partial<EventAnalyticsFilters>) => void,
): FilterChip[] {
  return useMemo(() => {
    const chips: FilterChip[] = [];

    if (filters.from || filters.to) {
      chips.push({
        key: "dates",
        label: `Date range: ${formatDateRange(filters.from, filters.to)}`,
        onRemove: () => onChange({ from: null, to: null }),
      });
    }
    for (const eventType of filters.eventTypes) {
      chips.push({
        key: `type:${eventType}`,
        label: `Event type: ${eventTypeLabel(eventType)}`,
        onRemove: () =>
          onChange({
            eventTypes: filters.eventTypes.filter((t) => t !== eventType),
          }),
      });
    }
    if (filters.source) {
      chips.push({
        key: "source",
        label: `Module: ${moduleLabel(filters.source)}`,
        onRemove: () => onChange({ source: null }),
      });
    }
    if (filters.utmSource) {
      chips.push({
        key: "utmSource",
        label: `Campaign source: ${filters.utmSource}`,
        onRemove: () => onChange({ utmSource: null }),
      });
    }
    if (filters.utmMedium) {
      chips.push({
        key: "utmMedium",
        label: `Campaign medium: ${filters.utmMedium}`,
        onRemove: () => onChange({ utmMedium: null }),
      });
    }
    if (filters.property) {
      chips.push({
        key: "property",
        label: `Property: ${filters.property}`,
        onRemove: () => onChange({ property: null }),
      });
    }
    if (filters.currency) {
      chips.push({
        key: "currency",
        label: `Currency: ${filters.currency}`,
        onRemove: () => onChange({ currency: null }),
      });
    }
    if (filters.memberId) {
      chips.push({
        key: "member",
        label: `Member ID: ${filters.memberId}`,
        onRemove: () => onChange({ memberId: null }),
      });
    }
    if (filters.search) {
      chips.push({
        key: "search",
        label: `Search: ${filters.search}`,
        onRemove: () => onChange({ search: null }),
      });
    }

    return chips;
  }, [filters, onChange]);
}

export function useEventFilterUI({
  filters,
  onChange,
  onReset,
  availableEventTypes,
  availableCurrencies,
  availableProperties,
  availableSources,
  availableUtmSources,
  availableUtmMediums,
}: FilterBarProps) {
  const [opened, setOpened] = useState(false);

  const [draftRange, setDraftRange] = useState<[string | null, string | null]>([
    filters.from,
    filters.to,
  ]);
  useEffect(
    () => setDraftRange([filters.from, filters.to]),
    [filters.from, filters.to],
  );
  const chips = useFilterChips(filters, onChange);

  const [search, setSearch] = useState(filters.search ?? "");
  const [memberId, setMemberId] = useState(filters.memberId ?? "");

  useEffect(() => setSearch(filters.search ?? ""), [filters.search]);
  useEffect(() => setMemberId(filters.memberId ?? ""), [filters.memberId]);

  const pushSearch = useDebouncedCallback(
    (value: string) => onChange({ search: value || null }),
    400,
  );
  const pushMemberId = useDebouncedCallback(
    (value: string) => onChange({ memberId: value || null }),
    400,
  );

  const moduleOptions = useMemo(
    () =>
      availableSources.map((value) => ({ value, label: moduleLabel(value) })),
    [availableSources],
  );

  const eventTypeOptions = useMemo(
    () =>
      availableEventTypes.map((value) => ({
        value,
        label: eventTypeLabel(value),
      })),
    [availableEventTypes],
  );

  return {
    activeCount: chips.length,
    trigger: (
      <FilterTrigger
        activeCount={chips.length}
        onClick={() => setOpened(true)}
      />
    ),
    chips: <ActiveFilterChips chips={chips} onReset={onReset} />,
    drawer: (
      <FilterDrawer
        opened={opened}
        onClose={() => setOpened(false)}
        activeCount={chips.length}
        onReset={onReset}
      >
        <FilterSection
          icon={<IconCalendarStats size={15} />}
          title="Date range"
          description=""
        >
          <Group gap={6} wrap="wrap">
            {QUICK_RANGES.map((range) => {
              const resolved = range.resolve();
              const isActive =
                filters.from === resolved.from && filters.to === resolved.to;
              return (
                <Button
                  key={range.label}
                  size="compact-xs"
                  variant={isActive ? "filled" : "default"}
                  onClick={() => {
                    setDraftRange([resolved.from, resolved.to]);
                    onChange(resolved);
                  }}
                >
                  {range.label}
                </Button>
              );
            })}
          </Group>

          <DatePickerInput
            type="range"
            placeholder="All time"
            clearable
            valueFormat="D MMM YYYY"
            highlightToday
            allowSingleDateInRange
            value={draftRange as any}
            onChange={(range: any) => {
              const [from, to] = (range ?? [null, null]) as [unknown, unknown];
              const next: [string | null, string | null] = [
                toDateParam(from),
                toDateParam(to),
              ];
              setDraftRange(next);
              if (next[0] === null || next[1] !== null) {
                onChange({ from: next[0], to: next[1] });
              }
            }}
          />
          {draftRange[0] && !draftRange[1] && (
            <Text size="xs" c="dimmed">
              Pick an end date to apply this range.
            </Text>
          )}
        </FilterSection>

        <FilterSection
          icon={<IconTags size={15} />}
          title="Event"
          description=""
        >
          <MultiSelect
            label="Event types"
            placeholder={filters.eventTypes.length ? undefined : "All events"}
            data={eventTypeOptions}
            value={filters.eventTypes}
            onChange={(value) => onChange({ eventTypes: value })}
            searchable
            clearable
            hidePickedOptions
          />
          <Select
            label="Module"
            description="Which part of the app the event fired in"
            placeholder="All modules"
            data={moduleOptions}
            value={filters.source}
            onChange={(value) => onChange({ source: value })}
            searchable
            clearable
          />
          <Select
            label="Property"
            placeholder="All properties"
            data={availableProperties}
            value={filters.property}
            onChange={(value) => onChange({ property: value })}
            searchable
            clearable
          />
        </FilterSection>

        <FilterSection
          icon={<IconSpeakerphone size={15} />}
          title="Campaign"
          description="utm tags from the link that started the journey."
        >
          <Autocomplete
            label="Campaign source"
            placeholder="Any source — type to filter"
            data={availableUtmSources}
            value={filters.utmSource ?? ""}
            onChange={(value) => onChange({ utmSource: value || null })}
            clearable
          />
          <Autocomplete
            label="Campaign medium"
            placeholder="Any medium — type to filter"
            data={availableUtmMediums}
            value={filters.utmMedium ?? ""}
            onChange={(value) => onChange({ utmMedium: value || null })}
            clearable
          />
          <Text size="xs" c="dimmed">
            Journeys that did not come from a tagged link carry no utm values
            and are reported as <strong>Direct</strong>.
          </Text>
        </FilterSection>

        <FilterSection
          icon={<IconUser size={15} />}
          title="Member"
          description="Narrow to one member, or search across the records."
        >
          <TextInput
            label="Member number"
            placeholder="Exact, e.g. 1278640"
            value={memberId}
            onChange={(e) => {
              setMemberId(e.currentTarget.value);
              pushMemberId(e.currentTarget.value);
            }}
          />
          <TextInput
            label="Search"
            placeholder="Property, experience or offer"
            leftSection={<IconSearch size={16} />}
            value={search}
            onChange={(e) => {
              setSearch(e.currentTarget.value);
              pushSearch(e.currentTarget.value);
            }}
          />
        </FilterSection>

        {availableCurrencies.length > 0 && (
          <FilterSection
            icon={<IconCoin size={15} />}
            title="Currency"
            description="Revenue is reported per currency, never converted."
            withDivider={false}
          >
            <Select
              label="Currency"
              placeholder="All currencies"
              data={availableCurrencies}
              value={filters.currency}
              onChange={(value) => onChange({ currency: value })}
              clearable
            />
          </FilterSection>
        )}
      </FilterDrawer>
    ),
  };
}
