// src/actions/party-order.ts
//
import { useMemo } from 'react';
import axiosInstance, { endpoints, fetcher } from 'src/lib/axios';
import type { IPartyOrderItem } from 'src/types/party-order';
import type { SWRConfiguration } from 'swr';
import useSWR, { mutate } from 'swr';

// ----------------------------------------------------------------------

const swrOptions: SWRConfiguration = {
  revalidateIfStale: false,
  revalidateOnFocus: false,
  revalidateOnReconnect: false,
};

// ----------------------------------------------------------------------

type PartyOrdersData = {
  partyOrders: IPartyOrderItem[];
};

export function useGetPartyOrders() {
  const url = endpoints.partyOrder.list;

  const { data, isLoading, error, isValidating } = useSWR<PartyOrdersData>(
    url,
    fetcher,
    swrOptions
  );

  const memoizedValue = useMemo(
    () => ({
      partyOrders: data?.partyOrders || [],
      partyOrdersLoading: isLoading,
      partyOrdersError: error,
      partyOrdersValidating: isValidating,
      partyOrdersEmpty: !isLoading && !isValidating && !data?.partyOrders.length,
    }),
    [data?.partyOrders, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

type PartyOrderData = {
  partyOrder: IPartyOrderItem;
};

export function useGetPartyOrder(partyOrderId: string) {
  const url = partyOrderId ? [endpoints.partyOrder.details, { params: { partyOrderId } }] : '';

  const { data, isLoading, error, isValidating } = useSWR<PartyOrderData>(url, fetcher, swrOptions);

  const memoizedValue = useMemo(
    () => ({
      partyOrder: data?.partyOrder,
      partyOrderLoading: isLoading,
      partyOrderError: error,
      partyOrderValidating: isValidating,
    }),
    [data?.partyOrder, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

type SearchResultsData = {
  results: IPartyOrderItem[];
};

export function useSearchProducts(query: string) {
  const url = query ? [endpoints.product.search, { params: { query } }] : '';

  const { data, isLoading, error, isValidating } = useSWR<SearchResultsData>(url, fetcher, {
    ...swrOptions,
    keepPreviousData: true,
  });

  const memoizedValue = useMemo(
    () => ({
      searchResults: data?.results || [],
      searchLoading: isLoading,
      searchError: error,
      searchValidating: isValidating,
      searchEmpty: !isLoading && !isValidating && !data?.results.length,
    }),
    [data?.results, error, isLoading, isValidating]
  );

  return memoizedValue;
}

// ----------------------------------------------------------------------

export async function createPartyOrder(partyOrderData: IPartyOrderItem) {
  /**
   * Work on server
   */
  const data = { partyOrderData };
  const {
    data: { id },
  } = await axiosInstance.post(endpoints.partyOrder.create, data);

  /**
   * Work in local
   */
  mutate(
    endpoints.partyOrder.list,
    (currentData: any) => {
      const currentPartyOrders: IPartyOrderItem[] = currentData?.partyOrders;

      const partyOrders = [...currentPartyOrders, { ...partyOrderData, id }];

      return { ...currentData, partyOrders };
    },
    false
  );
}

// ----------------------------------------------------------------------

export async function updatePartyOrder(partyOrderData: Partial<IPartyOrderItem>) {
  /**
   * Work on server
   */
  const data = { partyOrderData };
  await axiosInstance.put(endpoints.partyOrder.update, data);

  /**
   * Work in local
   */

  mutate(
    endpoints.partyOrder.list,
    (currentData: any) => {
      const currentPartyOrders: IPartyOrderItem[] = currentData?.partyOrders;

      const partyOrders = currentPartyOrders.map((partyOrder) =>
        partyOrder.id === partyOrderData.id ? { ...partyOrder, ...partyOrderData } : partyOrder
      );

      return { ...currentData, partyOrders };
    },
    false
  );
}

// ----------------------------------------------------------------------

export async function deletePartyOrder(partyOrderId: string) {
  /**
   * Work on server
   */
  const data = { partyOrderId };
  await axiosInstance.patch(endpoints.partyOrder.delete, data);

  /**
   * Work in local
   */

  mutate(
    endpoints.partyOrder.list,
    (currentData: any) => {
      const currentProducts: IPartyOrderItem[] = currentData?.partyOrders;

      const partyOrders = currentProducts.filter((partyOrder) => partyOrder.id !== partyOrderId);

      return { ...currentData, partyOrders };
    },
    false
  );
}

// ----------------------------------------------------------------------

// TODO: implement partyOrder changeStatus with url below
//  const url = endpoints.order.changeStatus(orderId);
export async function changeStatus(partyOrderData: any, dummy: any) {
  return true;
  // /**
  //  * Work on server
  //  */
  // const data = { partyOrderData };
  // await axiosInstance.put(endpoints.partyOrder.update, data);

  // /**
  //  * Work in local
  //  */

  // mutate(
  //   endpoints.partyOrder.list,
  //   (currentData: any) => {
  //     const currentPartyOrders: IPartyOrderItem[] = currentData?.partyOrders;

  //     const partyOrders = currentPartyOrders.map((partyOrder) =>
  //       partyOrder.id === partyOrderData.id ? { ...partyOrder, ...partyOrderData } : partyOrder
  //     );

  //     return { ...currentData, partyOrders };
  //   },
  //   false
  // );
}