import { useCallback, useRef } from 'react';

import { useDrawerV2 } from '@material-hu/hooks/useDrawerV2';
import { useModal } from '@material-hu/hooks/useModal';

import HuDialog from '@material-hu/components/design-system/Dialog';

import useSegmentationGroups from 'src/hooks/queryHooks/useSegmentationGroups';
import { useLokaliseTranslation } from 'src/utils/i18n';

import { newDefaultConditionLineValues } from 'src/components/Audience/CriteriaSelectionDrawers/hugo/SegmentationSelectionDrawer/constants';
import { type NewSegmentationCondition } from 'src/components/Audience/queries';

import { type AssignSegmentationConditionType } from '../types';
import { segmentationConditionToConditionLines } from '../utils';

import useSegmentationCriteriaDrawerContent from './useSegmentationCriteriaDrawerContent';

export type SegmentationSummaryCardPropsFromHook = {
  onEdit: () => void;
  onDelete: () => void;
};

export type UseSegmentationSelectionProps = {
  onConfirm: (condition: AssignSegmentationConditionType) => void;
  onDelete: (condition: AssignSegmentationConditionType) => void;
  setEditingConditionId: (id: string | null) => void;
  disabled: boolean;
};

export type ShowSegmentationSelectionDrawerArgs = {
  value?: { conditions: NewSegmentationCondition[] };
  disabled?: boolean;
};

const SEGMENTATION_SELECTION_FORM_ID = 'segmentation-selection-drawer';

const useSegmentationSelection = ({
  onConfirm,
  onDelete,
  setEditingConditionId,
  disabled: modalActionDisabled,
}: UseSegmentationSelectionProps) => {
  const { t } = useLokaliseTranslation('audience');
  const segmentationGroupsQuery = useSegmentationGroups();
  const conditionToDeleteRef = useRef<AssignSegmentationConditionType | null>(
    null,
  );

  const handleSegmentationSelectionDrawerConfirm = useCallback(
    async (condition: AssignSegmentationConditionType) => {
      onConfirm(condition);
    },
    [onConfirm],
  );

  const {
    drawer: segmentationSelectionDrawer,
    closeDrawer: closeSegmentationSelectionDrawer,
    showDrawer: showSegmentationSelectionDrawerBase,
  } = useDrawerV2<{
    value: { conditions: NewSegmentationCondition[] };
    disabled?: boolean;
  }>(args =>
    // biome-ignore lint/correctness/useHookAtTopLevel: we need to use the hook at the top level to avoid lint errors
    useSegmentationCriteriaDrawerContent({
      ...args,
      onConfirm: handleSegmentationSelectionDrawerConfirm,
      formId: SEGMENTATION_SELECTION_FORM_ID,
      value: args.value ?? { conditions: [newDefaultConditionLineValues] },
      disabled: args.disabled ?? modalActionDisabled,
    }),
  );

  const showSegmentationSelectionDrawer = useCallback(
    (args?: ShowSegmentationSelectionDrawerArgs) => {
      showSegmentationSelectionDrawerBase({
        value: args?.value,
        disabled: args?.disabled,
      });
    },
    [showSegmentationSelectionDrawerBase],
  );

  const {
    modal: confirmDeleteSegmentationSelectionModal,
    showModal: showConfirmDeleteSegmentationSelectionModal,
    closeModal: closeConfirmDeleteSegmentationSelectionModal,
  } = useModal(
    HuDialog,
    { maxWidth: 'sm' },
    {
      title: t('delete_individual_users_title'),
      textBody: t('delete_individual_users_description'),
      primaryButtonProps: {
        children: t('general:delete'),
        onClick: () => {
          const condition = conditionToDeleteRef.current;
          if (condition) onDelete(condition);
          conditionToDeleteRef.current = null;
          closeConfirmDeleteSegmentationSelectionModal();
        },
      },
      secondaryButtonProps: {
        children: t('general:cancel'),
        onClick: () => {
          conditionToDeleteRef.current = null;
          closeConfirmDeleteSegmentationSelectionModal();
        },
      },
    },
  );

  const getSegmentationSummaryCardProps = useCallback(
    (
      condition: AssignSegmentationConditionType & { id?: string },
      disabled: boolean,
    ): SegmentationSummaryCardPropsFromHook => ({
      onEdit: () => {
        setEditingConditionId(condition.id ?? null);
        const groups = segmentationGroupsQuery.data ?? [];
        const conditionLines = segmentationConditionToConditionLines(
          condition,
          groups,
        );
        showSegmentationSelectionDrawer({
          disabled,
          value: {
            conditions:
              conditionLines.length > 0
                ? conditionLines
                : [newDefaultConditionLineValues],
          },
        });
      },
      onDelete: () => {
        if (disabled) return;
        conditionToDeleteRef.current = condition;
        showConfirmDeleteSegmentationSelectionModal();
      },
    }),
    [
      segmentationGroupsQuery.data,
      setEditingConditionId,
      showSegmentationSelectionDrawer,
      showConfirmDeleteSegmentationSelectionModal,
    ],
  );

  return {
    segmentationSelectionDrawer,
    confirmDeleteSegmentationSelectionModal,
    closeSegmentationSelectionDrawer,
    showSegmentationSelectionDrawer,
    getSegmentationSummaryCardProps,
  };
};

export default useSegmentationSelection;