/**
 * @deprecated — Hugo has a full parallel audience sub-system at
 * `@material-hu/components/composed-components/audience/`.
 * Hugo equivalent: absorbed into audience hooks (`useCriteriaDrawer`, `useSegmentationCriteriaDrawer`).
 */
import { createContext, useCallback, useContext, useState } from 'react';

import { Criteria } from 'src/types/audience';

export type CriteriaContextValue = {
  criteriaSelected: Criteria[];
  addCriteriaSelected: (param) => void;
  deleteCriteriaSelected: (param) => void;
  updateCriteriaSelected: (param) => void;
  setCriteriaSelected: (param: Criteria[], shouldDirty?: boolean) => void;
  setTemplateId: (param: number) => void;
  templateId: number | null;
  creatingTemplate: boolean;
  setCreatingTemplate: (param: boolean) => void;
  criteriaSelectedDirty: boolean;
};

const CriteriaContext = createContext<CriteriaContextValue>({
  criteriaSelected: null,
  addCriteriaSelected: () => null,
  deleteCriteriaSelected: () => null,
  updateCriteriaSelected: () => null,
  setCriteriaSelected: () => null,
  setTemplateId: () => null,
  templateId: null,
  creatingTemplate: null,
  setCreatingTemplate: () => null,
  criteriaSelectedDirty: false,
});

export const CriteriaProvider = ({ children }) => {
  const [criteriaSelected, setCriteriaSelected] = useState<Criteria[]>([]);
  const [templateId, setTemplateId] = useState<number>();
  const [creatingTemplate, setCreatingTemplate] = useState<boolean>();
  const [criteriaSelectedDirty, setCriteriaSelectedDirty] = useState(false);

  const setCriteriaSelectedAndDirty = (
    newCriteria: Parameters<typeof setCriteriaSelected>[0],
    shouldDirty = true,
  ) => {
    setCriteriaSelected(newCriteria);
    shouldDirty && setCriteriaSelectedDirty(true);
  };

  const addCriteriaSelected = useCallback((criteriaSelectedParam: Criteria) => {
    setCriteriaSelectedAndDirty(prev => [...prev, criteriaSelectedParam]);
  }, []);

  const deleteCriteriaSelected = useCallback(
    (criteriaSelectedParam: Criteria) => {
      setCriteriaSelectedAndDirty(prev =>
        prev.filter(cr => cr.id !== criteriaSelectedParam.id),
      );
    },
    [],
  );

  const updateCriteriaSelected = useCallback(
    (criteriaSelectedParam: Criteria) => {
      setCriteriaSelectedAndDirty(prev =>
        prev.map(c =>
          c.id === criteriaSelectedParam.id ? criteriaSelectedParam : c,
        ),
      );
    },
    [],
  );

  return (
    <CriteriaContext.Provider
      value={{
        criteriaSelected,
        addCriteriaSelected,
        deleteCriteriaSelected,
        updateCriteriaSelected,
        setCriteriaSelected: setCriteriaSelectedAndDirty,
        setTemplateId,
        templateId,
        creatingTemplate,
        setCreatingTemplate,
        criteriaSelectedDirty,
      }}
    >
      {children}
    </CriteriaContext.Provider>
  );
};

export const useCriteria = () => useContext(CriteriaContext);

export const CriteriaConsumer = CriteriaContext.Consumer;

export default CriteriaProvider;