import { UAParser } from 'ua-parser-js';
import {
  IconCalendar,
  IconDeviceDesktop,
  IconDeviceMobile,
  IconTimelineEvent,
  IconUserShield,
  IconUsersGroup,
} from '@material-hu/icons/tabler';

import { type ListItemProps } from '@material-hu/components/design-system/List/components/ListItem';

import useFormatDate from 'src/hooks/useFormatDate';
import { ActivityPlatform, type SecurityActivity } from 'src/types/insights';
import { type User } from 'src/types/user';
import { insertIf } from 'src/utils/arrayUtils';
import { useLokaliseTranslation } from 'src/utils/i18n';

import {
  ACTIVITY_PLATFORM_T_KEYS,
  ACTIVITY_TYPE_T_KEYS,
  ROLE_ACTIVITY_TYPES,
} from '../components/ActivityRecord/constants';
import {
  getRoleStatusCopetinKey,
  translateMemberAssignmentType,
  translateRoleDimension,
  translateRoleStatus,
} from '../components/ActivityRecord/roleEvents';
import {
  getActivitySourceLabel,
  getUserStatusColor,
  getUserStatusLabelKey,
} from '../components/ActivityRecord/utils';

type ActivityDetailItem = {
  cardTitle: string;
  items: ListItemProps[];
};

const useActivityDetailItems = (
  activity: SecurityActivity,
): ActivityDetailItem[] => {
  const { t } = useLokaliseTranslation('settings');
  const { formatDate } = useFormatDate();

  const { user, actor, timestamp, type, platform, agent, source, metadata } =
    activity;

  const isAppActivity = platform === ActivityPlatform.APP;
  const isAdminActivity = platform === ActivityPlatform.ADMIN;

  const { browser, os } = UAParser(agent);

  const generateUserItem = (
    user: User | null,
    copetin?: string,
  ): ListItemProps | null =>
    user && {
      text: {
        title: `${user.firstName} ${user.lastName}`,
        description:
          user.email && user.email !== user.employeeInternalId
            ? `${user.employeeInternalId} • ${user.email}`
            : user.employeeInternalId,
        withEllipsis: true,
        overflow: 'tooltip',
        copetin: copetin,
      },
      avatar: {
        text: `${user.firstName[0]}${user.lastName[0]}`.toUpperCase(),
      },
      sidePill: {
        label: t(getUserStatusLabelKey(user)),
        type: getUserStatusColor(user),
        size: 'small',
      },
      slotProps: {
        avatar: {
          sx: {
            backgroundColor: theme =>
              theme.palette.new.background.layout.tertiary,
          },
        },
      },
    };

  const isRoleEvent = ROLE_ACTIVITY_TYPES.includes(type);
  const isUserActor = actor && user && actor.id === user.id;

  return [
    {
      cardTitle: t('security.activity_record_tab.name'),
      items: (isRoleEvent
        ? [
            generateUserItem(
              actor,
              t('security.activity_record_tab.performed_by'),
            ),
          ]
        : [
            ...insertIf(
              !isUserActor,
              generateUserItem(
                actor,
                t('security.activity_record_tab.origin_user'),
              ),
            ),
            generateUserItem(
              user,
              !isUserActor
                ? t('security.activity_record_tab.destination_user')
                : undefined,
            ),
          ]
      ).filter(Boolean) as ListItemProps[],
    },
    {
      cardTitle: t('security.activity_record_tab.date_time'),
      items: [
        {
          text: {
            title: formatDate(new Date(timestamp)),
            description: formatDate(new Date(timestamp), 'HH:mm aaa'),
          },
          avatar: { Icon: IconCalendar },
        },
      ],
    },
    {
      cardTitle: t('security.activity_record_tab.event_type'),
      items: [
        {
          text: {
            title: t(ACTIVITY_TYPE_T_KEYS[type] || type),
          },
          avatar: { Icon: IconTimelineEvent },
        },
      ],
    },
    {
      cardTitle: t('security.activity_record_tab.platform_type'),
      items: [
        {
          text: {
            title: platform
              ? t(ACTIVITY_PLATFORM_T_KEYS[platform] || platform)
              : '-',
            description: source
              ? getActivitySourceLabel(activity, t)
              : undefined,
          },
          avatar: { Icon: isAdminActivity ? IconUserShield : IconUsersGroup },
        },
      ],
    },
    ...insertIf(!!agent, {
      cardTitle: t('security.activity_record_tab.device_browser'),
      items: [
        {
          text: {
            title: isAppActivity ? agent : `${os.name} ${os.version}`,
            description: isAppActivity
              ? ''
              : `${browser.name} ${browser.version}`,
          },
          avatar: {
            Icon: isAppActivity ? IconDeviceMobile : IconDeviceDesktop,
          },
        },
      ],
    }),
    ...insertIf(isRoleEvent, {
      cardTitle: t('security.activity_record_tab.role_detail.title'),
      items: [
        ...insertIf(!!metadata?.roleName, {
          text: {
            copetin: t('security.activity_record_tab.role_detail.role_name'),
            title: metadata?.roleName ?? '',
          },
        }),
        ...insertIf(!!metadata?.status, {
          text: {
            copetin: t(getRoleStatusCopetinKey(type)),
            title: metadata?.status
              ? translateRoleStatus(metadata.status, t)
              : '',
          },
        }),
        ...insertIf(!!metadata?.dimension, {
          text: {
            copetin: t(
              'security.activity_record_tab.role_detail.changed_dimension',
            ),
            title: metadata?.dimension
              ? translateRoleDimension(metadata.dimension, t)
              : '',
          },
        }),
        ...insertIf(typeof metadata?.memberCount === 'number', {
          text: {
            copetin: t(
              'security.activity_record_tab.role_detail.members_count',
            ),
            title: String(metadata?.memberCount ?? ''),
          },
        }),
        ...insertIf(typeof metadata?.permissionCount === 'number', {
          text: {
            copetin: t(
              'security.activity_record_tab.role_detail.permissions_count',
            ),
            title: String(metadata?.permissionCount ?? ''),
          },
        }),
        ...insertIf(!!metadata?.memberAssignmentType, {
          text: {
            copetin: t(
              'security.activity_record_tab.role_detail.assignment_type',
            ),
            title: metadata?.memberAssignmentType
              ? translateMemberAssignmentType(metadata.memberAssignmentType, t)
              : '',
          },
        }),
      ],
    }),
  ];
};

export default useActivityDetailItems;