import { useCallback, useMemo } from 'react';

import {
  IconLockOpen,
  IconUserCancel,
  IconUserPlus,
  IconUserX,
} from '@material-hu/icons/tabler';

import { type TaskFocusExtraAction } from '@material-hu/components/design-system/Header/TaskFocus/types';
import { useDialogLayer } from '@material-hu/components/layers/Dialogs';
import { useDrawerLayer } from '@material-hu/components/layers/Drawers';

import { useRequiredAuth } from 'src/contexts/JWTContext';
import useHuGoTheme from 'src/hooks/useHuGoTheme';
import {
  getUserGrants,
  type UserGrant,
} from 'src/pages/dashboard/Users/grants';
import DeleteConfirmModal from 'src/pages/dashboard/Users/List/components/DeleteConfirmModal/DeleteConfirmModal';
import RestorePasswordDrawer from 'src/pages/dashboard/Users/List/components/RestorePasswordDrawer';
import useBosses from 'src/pages/dashboard/Users/List/hooks/useBosses';
import { useActivateUserDrawer } from 'src/pages/dashboard/Users/UserEdit/components/GeneralTab/hooks/useActivateUserDrawer';
import { useDeactivateUserDrawer } from 'src/pages/dashboard/Users/UserEdit/components/GeneralTab/hooks/useDeactivateUserDrawer';
import { type User, UserStatus } from 'src/types/user';
import { insertIf } from 'src/utils/arrayUtils';
import { useLokaliseTranslation } from 'src/utils/i18n';

export const DELETE_CONFIRM_DIALOG_ID = 'delete-confirm-dialog';
export const RESTORE_PASSWORD_DRAWER_ID = 'restore-password-drawer';

export type UserActionSource = 'users_home' | 'user_profile';

type Props = {
  user: User | null;
  grants: UserGrant[];
  source?: UserActionSource;
};

const useUserActions = ({ user, grants, source }: Props) => {
  const { t } = useLokaliseTranslation('users');
  const HuGoThemeProvider = useHuGoTheme();
  const { user: currentUser, instance } = useRequiredAuth();
  const { openDialog, closeDialog } = useDialogLayer();
  const { openDrawer } = useDrawerLayer();
  const { userBoss, hasSubordinates, isBossesReady } = useBosses({ user });
  const { openActivateUser, activateUserDrawer } = useActivateUserDrawer({
    user: user as User,
  });
  const { openDeactivateUser, deactivateUserDrawer } = useDeactivateUserDrawer({
    user: user as User,
    userBoss,
    hasSubordinates,
    source,
  });
  const showDeleteConfirmModal = useCallback(() => {
    openDialog(
      {
        content: (
          <DeleteConfirmModal
            user={user as User}
            userBoss={userBoss as User}
            currentUser={currentUser}
            hasSubordinates={hasSubordinates}
            instanceId={instance?.id}
            source={source}
            onClose={() => closeDialog(DELETE_CONFIRM_DIALOG_ID)}
          />
        ),
      },
      DELETE_CONFIRM_DIALOG_ID,
    );
  }, [
    user,
    userBoss,
    currentUser,
    hasSubordinates,
    instance?.id,
    source,
    openDialog,
    closeDialog,
  ]);

  const openRestorePasswordDrawer = useCallback(() => {
    if (!user) return;
    openDrawer(
      {
        content: (
          <RestorePasswordDrawer
            userEmail={user.email ?? ''}
            instanceId={instance.id}
            currentUserId={currentUser.id}
            employeeInternalId={user.employeeInternalId ?? ''}
            userId={user.id}
            source={source}
          />
        ),
      },
      RESTORE_PASSWORD_DRAWER_ID,
    );
  }, [
    openDrawer,
    user?.email,
    user?.id,
    user?.employeeInternalId,
    currentUser?.id,
    instance.id,
    source,
  ]);

  const getMenuOptions = useCallback(
    (rowUser?: User, rowGrants?: UserGrant[]) => {
      const targetUser = rowUser ?? user;
      const targetGrants = rowGrants ?? grants;
      if (!targetUser) {
        return [];
      }
      const isSameRowUser = targetUser.id === currentUser.id;
      const isDeactivatedRow = targetUser.status === UserStatus.DEACTIVATED;
      const {
        canChangeUserStatus: canChange,
        canDeleteUser: canDelete,
        canResetPassword: canReset,
      } = getUserGrants(targetGrants);
      return [
        ...insertIf(canReset, {
          key: 'restore-password' as const,
          title: t('restore_password'),
          Icon: IconLockOpen,
          onClick: () => openRestorePasswordDrawer(),
        }),
        ...insertIf(!isSameRowUser && canChange, {
          key: 'change-status' as const,
          title: t(isDeactivatedRow ? 'activate_user' : 'deactivate_user'),
          Icon: isDeactivatedRow ? IconUserPlus : IconUserCancel,
          onClick: () =>
            isDeactivatedRow ? openActivateUser() : openDeactivateUser(),
        }),
        ...insertIf(!isSameRowUser && canDelete, {
          key: 'delete' as const,
          title: t('delete_user'),
          Icon: IconUserX,
          onClick: () => showDeleteConfirmModal(),
        }),
      ];
    },
    [
      user,
      grants,
      currentUser.id,
      t,
      openRestorePasswordDrawer,
      openActivateUser,
      openDeactivateUser,
      showDeleteConfirmModal,
    ],
  );

  const actions: TaskFocusExtraAction[] = useMemo(
    () =>
      getMenuOptions().map(({ key, title, Icon, onClick }) => ({
        key,
        title,
        avatar: { Icon },
        onClick,
      })),
    [getMenuOptions],
  );

  const modals = (
    <>
      <HuGoThemeProvider>
        {activateUserDrawer}
        {isBossesReady ? deactivateUserDrawer : null}
      </HuGoThemeProvider>
    </>
  );

  return { actions, modals, getMenuOptions };
};

export default useUserActions;