import { useCallback, useRef } from "react";
import useSwr, { mutate } from "swr";
import { enqueueSnackbar } from "notistack";
import { promocodeApi } from "./requests";

import type {
  CreatePromocodeBody,
  PromocodeList,
} from "@root/model/promocodes";

export function usePromocodes(
  page: number,
  pageSize: number,
  promocodeId: string,
  to: number,
  from: number
) {
  const promocodesCountRef = useRef<number>(0);
  const swrResponse = useSwr(
    ["promocodes", page, pageSize],
    async (key) => {
      const result = await promocodeApi.getPromocodeList({
        limit: key[2],
        filter: {
          active: true,
        },
        page: key[1],
      });

      promocodesCountRef.current = result.count;
      return result;
    },
    {
      onError(err) {
        console.log("Error fetching promocodes", err);
        enqueueSnackbar(err.message, { variant: "error" });
      },
      focusThrottleInterval: 60e3,
      keepPreviousData: true,
    }
  );

  const createPromocode = useCallback(
    async function (body: CreatePromocodeBody) {
      try {
        await promocodeApi.createPromocode(body);
        mutate(["promocodes", page, pageSize]);
      } catch (error) {
        console.log("Error creating promocode", error);
        if (error instanceof Error)
          enqueueSnackbar(error.message, { variant: "error" });
      }
    },
    [page, pageSize]
  );

  const deletePromocode = useCallback(
    async function (id: string) {
      try {
        await mutate<PromocodeList | undefined, void>(
          ["promocodes", page, pageSize],
          promocodeApi.deletePromocode(id),
          {
            optimisticData(currentData, displayedData) {
              if (!displayedData) return;

              return {
                count: displayedData.count - 1,
                items: displayedData.items.filter((item) => item.id !== id),
              };
            },
            rollbackOnError: true,
            populateCache(result, currentData) {
              if (!currentData) return;

              return {
                count: currentData.count - 1,
                items: currentData.items.filter((item) => item.id !== id),
              };
            },
          }
        );
      } catch (error) {
        console.log("Error deleting promocode", error);
        if (error instanceof Error)
          enqueueSnackbar(error.message, { variant: "error" });
      }
    },
    [page, pageSize]
  );

  const promocodeStatistics = useSwr(
    ["promocodeStatistics", promocodeId, from, to],
    async ([_, id, from, to]) => {
      if (!id) {
        return null;
      }

      const promocodeStatisticsResponse =
        await promocodeApi.getPromocodeStatistics(id, from, to);

      return promocodeStatisticsResponse;
    },
    {
      onError(err) {
        console.log("Error fetching promocode statistics", err);
        enqueueSnackbar(err.message, { variant: "error" });
      },
      focusThrottleInterval: 60e3,
      keepPreviousData: true,
    }
  );

  const createFastLink = useCallback(
    async function (id: string) {
      try {
        await promocodeApi.createFastlink(id);
        mutate(["promocodes", page, pageSize]);
      } catch (error) {
        console.log("Error creating fast link", error);
        if (error instanceof Error)
          enqueueSnackbar(error.message, { variant: "error" });
      }
    },
    [page, pageSize]
  );

  return {
    ...swrResponse,
    createPromocode,
    deletePromocode,
    createFastLink,
    promocodeStatistics: promocodeStatistics.data,
    promocodesCount: promocodesCountRef.current,
  };
}

export function useAllPromocodes() {
  const swrResponse = useSwr("allPromocodes", promocodeApi.getAllPromocodes, {
    keepPreviousData: true,
    suspense: true,
    onError(err) {
      console.log("Error fetching all promocodes", err);
      enqueueSnackbar(err.message, { variant: "error" });
    },
  });

  return swrResponse.data;
}