import {
  listCampaignTags,
  type CampaignGroupListQuery,
  type CampaignGroupStatus,
  type CampaignTag,
} from "@/lib/features/notifications/action";
import {
  FilterDrawer,
  FilterSection,
  type FilterChip,
} from "@/routes/promo-code-campaigns/_components/FilterDrawer";
import {
  Checkbox,
  MultiSelect,
  SimpleGrid,
  Switch,
  TextInput,
} from "@mantine/core";
import { DatePickerInput } from "@mantine/dates";
import {
  IconCalendarEvent,
  IconCalendarPlus,
  IconTag,
  IconToggleLeft,
  IconUserCheck,
} from "@tabler/icons-react";
import { useEffect, useState } from "react";
import { GROUP_STATUS_META } from "./shared";

type DateRange = [string | null, string | null];

export type CampaignFilters = {
  status: string[];
  tags: string[];
  pendingOnly: boolean;
  createdBy: string;
  created: DateRange;
  scheduled: DateRange;
};

export const EMPTY_CAMPAIGN_FILTERS: CampaignFilters = {
  status: [],
  tags: [],
  pendingOnly: false,
  createdBy: "",
  created: [null, null],
  scheduled: [null, null],
};

const STATUS_KEYS = Object.keys(GROUP_STATUS_META) as CampaignGroupStatus[];

const hasRange = ([from, to]: DateRange) => Boolean(from || to);

const formatDay = (day: string) =>
  new Date(`${day}T00:00:00`).toLocaleDateString("en-GB", {
    day: "numeric",
    month: "short",
    year: "numeric",
  });

const rangeLabel = ([from, to]: DateRange) => {
  if (from && to) return `${formatDay(from)} – ${formatDay(to)}`;
  if (from) return `from ${formatDay(from)}`;
  return `until ${formatDay(to as string)}`;
};

export const countCampaignFilters = (filters: CampaignFilters): number =>
  filters.status.length +
  filters.tags.length +
  Number(filters.pendingOnly) +
  Number(Boolean(filters.createdBy.trim())) +
  Number(hasRange(filters.created)) +
  Number(hasRange(filters.scheduled));

export const toListQuery = (
  filters: CampaignFilters,
): CampaignGroupListQuery => ({
  status: filters.status.join(",") || undefined,
  tags: filters.tags,
  pending: filters.pendingOnly,
  createdBy: filters.createdBy.trim() || undefined,
  createdFrom: filters.created[0] ?? undefined,
  createdTo: filters.created[1] ?? undefined,
  scheduledFrom: filters.scheduled[0] ?? undefined,
  scheduledTo: filters.scheduled[1] ?? undefined,
});

export const filtersFromParams = (params: URLSearchParams): CampaignFilters => {
  const list = (key: string) =>
    (params.get(key) || "").split(",").filter(Boolean);
  return {
    status: list("campaignStatus"),
    tags: list("campaignTags"),
    pendingOnly: params.get("campaignPending") === "true",
    createdBy: params.get("campaignCreatedBy") || "",
    created: [
      params.get("campaignCreatedFrom"),
      params.get("campaignCreatedTo"),
    ],
    scheduled: [
      params.get("campaignScheduledFrom"),
      params.get("campaignScheduledTo"),
    ],
  };
};

export const filtersToParams = (
  filters: CampaignFilters,
): Record<string, string | null> => ({
  campaignStatus: filters.status.join(",") || null,
  campaignTags: filters.tags.join(",") || null,
  campaignPending: filters.pendingOnly ? "true" : null,
  campaignCreatedBy: filters.createdBy.trim() || null,
  campaignCreatedFrom: filters.created[0],
  campaignCreatedTo: filters.created[1],
  campaignScheduledFrom: filters.scheduled[0],
  campaignScheduledTo: filters.scheduled[1],
});

export function useCampaignTagOptions(refreshKey?: number): CampaignTag[] {
  const [tags, setTags] = useState<CampaignTag[]>([]);
  useEffect(() => {
    listCampaignTags().then((res) => {
      if (res.success) setTags(res.data ?? []);
    });
  }, [refreshKey]);
  return tags;
}

export function campaignFilterChips(
  filters: CampaignFilters,
  tagOptions: CampaignTag[],
  onChange: (filters: CampaignFilters) => void,
): FilterChip[] {
  const update = (patch: Partial<CampaignFilters>) => () =>
    onChange({ ...filters, ...patch });
  const chips: FilterChip[] = [
    ...filters.status.map((status) => ({
      key: `status-${status}`,
      label: `Status: ${GROUP_STATUS_META[status as CampaignGroupStatus]?.label ?? status}`,
      onRemove: update({ status: filters.status.filter((s) => s !== status) }),
    })),
    ...filters.tags.map((tagId) => ({
      key: `tag-${tagId}`,
      label: `Tag: ${tagOptions.find((t) => t.id === tagId)?.name ?? "…"}`,
      onRemove: update({ tags: filters.tags.filter((t) => t !== tagId) }),
    })),
  ];
  if (filters.pendingOnly) {
    chips.push({
      key: "pending",
      label: "Pending only",
      onRemove: update({ pendingOnly: false }),
    });
  }
  if (filters.createdBy.trim()) {
    chips.push({
      key: "created-by",
      label: `Created by: ${filters.createdBy.trim()}`,
      onRemove: update({ createdBy: "" }),
    });
  }
  if (hasRange(filters.created)) {
    chips.push({
      key: "created",
      label: `Created ${rangeLabel(filters.created)}`,
      onRemove: update({ created: [null, null] }),
    });
  }
  if (hasRange(filters.scheduled)) {
    chips.push({
      key: "scheduled",
      label: `Scheduled ${rangeLabel(filters.scheduled)}`,
      onRemove: update({ scheduled: [null, null] }),
    });
  }
  return chips;
}

const CampaignFilterDrawer: React.FC<{
  opened: boolean;
  onClose: () => void;
  filters: CampaignFilters;
  tagOptions: CampaignTag[];
  onChange: (filters: CampaignFilters) => void;
}> = ({ opened, onClose, filters, tagOptions, onChange }) => {
  const [createdBy, setCreatedBy] = useState(filters.createdBy);

  useEffect(() => setCreatedBy(filters.createdBy), [filters.createdBy]);

  useEffect(() => {
    if (createdBy === filters.createdBy) return;
    const timer = setTimeout(() => onChange({ ...filters, createdBy }), 400);
    return () => clearTimeout(timer);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [createdBy]);

  return (
    <FilterDrawer
      opened={opened}
      onClose={onClose}
      activeCount={countCampaignFilters(filters)}
      onReset={() => onChange(EMPTY_CAMPAIGN_FILTERS)}
    >
      <FilterSection
        icon={<IconToggleLeft size={15} />}
        title="Status"
        description="Where each campaign is in its lifecycle"
      >
        <Checkbox.Group
          value={filters.status}
          onChange={(status) => onChange({ ...filters, status })}
        >
          <SimpleGrid cols={2} spacing="xs" verticalSpacing="xs">
            {STATUS_KEYS.map((status) => (
              <Checkbox
                key={status}
                value={status}
                label={GROUP_STATUS_META[status].label}
              />
            ))}
          </SimpleGrid>
        </Checkbox.Group>
        <Switch
          label="Only campaigns with notifications still to send"
          checked={filters.pendingOnly}
          onChange={(e) =>
            onChange({ ...filters, pendingOnly: e.currentTarget.checked })
          }
        />
      </FilterSection>

      <FilterSection
        icon={<IconCalendarEvent size={15} />}
        title="Scheduled date"
        description="Campaigns with a notification scheduled in this range"
      >
        <DatePickerInput
          type="range"
          placeholder="Any date"
          value={filters.scheduled}
          onChange={(scheduled) =>
            onChange({ ...filters, scheduled: scheduled as DateRange })
          }
          allowSingleDateInRange
          clearable
          valueFormat="DD MMM YYYY"
        />
      </FilterSection>

      <FilterSection
        icon={<IconCalendarPlus size={15} />}
        title="Created date"
        description="When the campaign was created"
      >
        <DatePickerInput
          type="range"
          placeholder="Any date"
          value={filters.created}
          onChange={(created) =>
            onChange({ ...filters, created: created as DateRange })
          }
          allowSingleDateInRange
          clearable
          valueFormat="DD MMM YYYY"
        />
      </FilterSection>

      <FilterSection
        icon={<IconUserCheck size={15} />}
        title="Created by"
        description="Email of the person who created the campaign"
      >
        <TextInput
          placeholder="email contains…"
          value={createdBy}
          onChange={(e) => setCreatedBy(e.currentTarget.value)}
        />
      </FilterSection>

      <FilterSection
        icon={<IconTag size={15} />}
        title="Tags"
        description="Campaigns carrying every selected tag"
        withDivider={false}
      >
        <MultiSelect
          placeholder={filters.tags.length ? "" : "Pick tags"}
          data={tagOptions.map((t) => ({ value: t.id, label: t.name }))}
          value={filters.tags}
          onChange={(tags) => onChange({ ...filters, tags })}
          searchable
          clearable
          nothingFoundMessage="No tags yet"
        />
      </FilterSection>
    </FilterDrawer>
  );
};

export default CampaignFilterDrawer;
