'use client';

import { ChangeEventHandler, useCallback, useEffect, useState } from 'react';
import useSWR from 'swr';
import {
  CellContext,
  ColumnDef,
  ColumnSort,
  SortingState,
} from '@tanstack/react-table';
import toast from 'react-hot-toast';

import { Icon } from '@iconify/react';
import Table from '@/components/Table';
import DebouncedTextInput from '@/components/input/DebouncedTextInput';
import Button from '@/components/Button';
import { useModal } from '@/components/Modal';
import ConfirmationModal from '@/components/modal/ConfirmationModal';
import SelectInput, { OptionType } from '@/components/input/SelectInput';
import RowDropdownOptions from '@/components/table/RowDropdownOptions';
import RowCollapseOptions from '@/components/table/RowCollapseOptions';
import RowOptionsMenuWrapper from '@/components/table/RowOptionsMenuWrapper';
import RequirePermission from '@/components/helper/RequirePermission';

import { Product } from '@/types/api/master-data/product';
import { ProductApi } from '@/services/api/master-data';
import { cn } from '@/lib/helper';
import { isResponseError, isResponseSuccess } from '@/lib/api-helper';
import { useTableFilter } from '@/services/hooks/useTableFilter';
import { ROWS_OPTIONS } from '@/config/constant';

const RowOptionsMenu = ({
  type = 'dropdown',
  props,
  deleteClickHandler,
}: {
  type: 'dropdown' | 'collapse';
  props: CellContext<Product, unknown>;
  deleteClickHandler: () => void;
}) => (
  <RowOptionsMenuWrapper type={type}>
    <RequirePermission permissions='lti.master.products.detail'>
      <Button
        href={`/master-data/product/detail/?productId=${props.row.original.id}`}
        variant='ghost'
        color='primary'
        className='justify-start text-sm'
      >
        <Icon icon='mdi:eye-outline' width={16} height={16} />
        Detail
      </Button>
    </RequirePermission>
    <RequirePermission permissions='lti.master.products.update'>
      <Button
        href={`/master-data/product/detail/edit/?productId=${props.row.original.id}`}
        variant='ghost'
        color='warning'
        className='justify-start text-sm'
      >
        <Icon icon='material-symbols:edit-outline' width={16} height={16} />
        Edit
      </Button>
    </RequirePermission>
    <RequirePermission permissions='lti.master.products.delete'>
      <Button
        onClick={deleteClickHandler}
        variant='ghost'
        color='error'
        className='justify-start text-sm text-error focus-visible:text-error-content hover:text-error-content'
      >
        <Icon
          icon='material-symbols:delete-outline-rounded'
          width={16}
          height={16}
          className='justify-start text-sm'
        />
        Delete
      </Button>
    </RequirePermission>
  </RowOptionsMenuWrapper>
);

const ProductsTable = () => {
  const {
    state: tableFilterState,
    updateFilter,
    setPage,
    setPageSize,
    toQueryString: getTableFilterQueryString,
  } = useTableFilter({
    initial: {
      search: '',
      nameSort: '',
      skuSort: '',
      brandSort: '',
      categorySort: '',
    },
    paramMap: {
      page: 'page',
      pageSize: 'limit',
      nameSort: 'sort_name',
      skuSort: 'sort_sku',
      brandSort: 'sort_brand',
      categorySort: 'sort_category',
    },
  });

  const {
    data: products,
    isLoading,
    mutate: refreshProducts,
  } = useSWR(
    `${ProductApi.basePath}${getTableFilterQueryString()}`,
    ProductApi.getAllFetcher
  );

  const deleteModal = useModal();
  const [selectedProduct, setSelectedProduct] = useState<Product | undefined>(
    undefined
  );
  const [isDeleteLoading, setIsDeleteLoading] = useState(false);
  const [sorting, setSorting] = useState<SortingState>([]);

  const productsColumns: ColumnDef<Product>[] = [
    {
      header: '#',
      cell: (props) =>
        tableFilterState.pageSize * (tableFilterState.page - 1) +
        props.row.index +
        1,
    },
    {
      accessorKey: 'name',
      header: 'Nama',
    },
    {
      accessorKey: 'sku',
      header: 'SKU',
    },
    {
      accessorKey: 'brand',
      header: 'Merek',
    },
    {
      accessorKey: 'product_category',
      header: 'Kategori',
      cell: (props) => props.row.original.product_category?.name ?? '-',
    },
    {
      accessorKey: 'uom',
      header: 'Satuan',
      cell: (props) => props.row.original.uom?.name ?? '-',
    },
    {
      accessorKey: 'product_price',
      header: 'Harga Produk',
      cell: (props) =>
        props.row.original.product_price?.toLocaleString() ?? '-',
    },
    {
      accessorKey: 'selling_price',
      header: 'Harga Jual',
      cell: (props) =>
        props.row.original.selling_price?.toLocaleString() ?? '-',
    },
    {
      accessorKey: 'tax',
      header: 'Pajak (%)',
      cell: (props) => props.row.original.tax ?? '-',
    },
    {
      accessorKey: 'expiry_period',
      header: 'Kadaluarsa (hari)',
      cell: (props) => props.row.original.expiry_period ?? '-',
    },
    {
      accessorKey: 'suppliers',
      header: 'Supplier',
      cell: (props) =>
        props.row.original.suppliers?.map((s) => s.name).join(', ') || '-',
    },
    {
      accessorKey: 'flags',
      header: 'Flags',
      cell: (props) =>
        props.row.original.flags?.length
          ? props.row.original.flags.join(', ')
          : '-',
    },
    {
      header: 'Aksi',
      cell: (props) => {
        const currentPageSize = props.table.getPaginationRowModel().rows.length;
        const currentPageRows = props.table.getPaginationRowModel().flatRows;
        const currentRowRelativeIndex =
          currentPageRows.findIndex((r) => r.id === props.row.id) + 1;

        const isLast2Rows = currentRowRelativeIndex > currentPageSize - 2;

        const deleteClickHandler = () => {
          setSelectedProduct(props.row.original);
          deleteModal.openModal();
        };

        return (
          <>
            {currentPageSize > 2 && (
              <RowDropdownOptions isLast2Rows={isLast2Rows}>
                <RowOptionsMenu
                  type='dropdown'
                  props={props}
                  deleteClickHandler={deleteClickHandler}
                />
              </RowDropdownOptions>
            )}
            {currentPageSize <= 2 && (
              <RowCollapseOptions>
                <RowOptionsMenu
                  type='collapse'
                  props={props}
                  deleteClickHandler={deleteClickHandler}
                />
              </RowCollapseOptions>
            )}
          </>
        );
      },
    },
  ];

  const confirmationModalDeleteClickHandler = async () => {
    setIsDeleteLoading(true);

    const deleteResponse = await ProductApi.delete(
      selectedProduct?.id as number
    );

    if (isResponseError(deleteResponse)) {
      toast.error(deleteResponse.message);
      setIsDeleteLoading(false);
      return;
    }

    refreshProducts();

    deleteModal.closeModal();
    toast.success('Successfully delete Product!');
    setIsDeleteLoading(false);
  };

  const searchChangeHandler: ChangeEventHandler<HTMLInputElement> = (e) => {
    updateFilter('search', e.target.value);
  };

  const pageSizeChangeHandler = (val: OptionType | OptionType[] | null) => {
    const newVal = val as OptionType;
    setPageSize(newVal.value as number);
  };

  const updateSortingFilter = useCallback(
    (
      sortName: Exclude<keyof typeof tableFilterState, 'page' | 'pageSize'>,
      sortFilter: ColumnSort | undefined
    ) => {
      if (!sortFilter) {
        updateFilter(sortName, '');
      } else {
        updateFilter(sortName, sortFilter.desc ? 'desc' : 'asc');
      }
    },
    [updateFilter]
  );

  useEffect(() => {
    const nameSortFilter = sorting.find((sortItem) => sortItem.id === 'name');
    const skuSortFilter = sorting.find((sortItem) => sortItem.id === 'sku');
    const brandSortFilter = sorting.find((sortItem) => sortItem.id === 'brand');
    const categorySortFilter = sorting.find(
      (sortItem) => sortItem.id === 'product_category'
    );

    updateSortingFilter('nameSort', nameSortFilter);
    updateSortingFilter('skuSort', skuSortFilter);
    updateSortingFilter('brandSort', brandSortFilter);
    updateSortingFilter('categorySort', categorySortFilter);
  }, [sorting, updateSortingFilter]);

  return (
    <>
      <div className='w-full p-0 sm:p-4'>
        <div className='flex flex-col gap-2 mb-4'>
          <div className='w-full flex flex-col sm:flex-row justify-between items-end sm:items-center gap-2'>
            <div className='w-full flex flex-row'>
              <RequirePermission permissions='lti.master.products.create'>
                <Button
                  href='/master-data/product/add'
                  variant='outline'
                  className='w-full sm:w-fit'
                  color='primary'
                >
                  <Icon icon='ic:round-plus' width={24} height={24} />
                  Tambah
                </Button>
              </RequirePermission>
            </div>
            <DebouncedTextInput
              name='search'
              placeholder='Cari Produk'
              value={tableFilterState.search}
              onChange={searchChangeHandler}
              className={{ wrapper: 'sm:max-w-3xs' }}
            />
          </div>
          <div className='flex flex-row justify-end'>
            <SelectInput
              label='Baris'
              options={ROWS_OPTIONS}
              value={{
                label: String(tableFilterState.pageSize),
                value: tableFilterState.pageSize,
              }}
              onChange={pageSizeChangeHandler}
              className={{ wrapper: 'max-w-28' }}
            />
          </div>
        </div>
        <Table<Product>
          data={isResponseSuccess(products) ? products?.data : []}
          columns={productsColumns}
          pageSize={tableFilterState.pageSize}
          page={isResponseSuccess(products) ? products?.meta?.page : 0}
          totalItems={
            isResponseSuccess(products) ? products?.meta?.total_results : 0
          }
          onPageChange={setPage}
          isLoading={isLoading}
          sorting={sorting}
          setSorting={setSorting}
          className={{
            containerClassName: cn({
              'mb-20':
                isResponseSuccess(products) && products?.data?.length === 0,
            }),
            tableWrapperClassName: 'overflow-x-auto min-h-full!',
            tableClassName: 'font-inter w-full table-auto min-h-full!',
            headerRowClassName: 'border-b border-b-gray-200',
            headerColumnClassName:
              'px-6 py-3 text-xs font-semibold text-gray-500 last:flex last:flex-row last:justify-end',
            bodyRowClassName: 'border-b border-b-gray-200',
            bodyColumnClassName:
              'px-6 py-3 last:flex last:flex-row last:justify-end',
          }}
        />
      </div>
      <ConfirmationModal
        ref={deleteModal.ref}
        type='error'
        text={`Apakah anda yakin ingin menghapus data Produk ini (${selectedProduct?.name})?`}
        secondaryButton={{
          text: 'Tidak',
        }}
        primaryButton={{
          text: 'Ya',
          color: 'error',
          isLoading: isDeleteLoading,
          onClick: confirmationModalDeleteClickHandler,
        }}
      />
    </>
  );
};

export default ProductsTable;
