import React, { createContext } from 'react';
import { Content } from '@patternfly/react-core';

export const TEXT_FILTER = 'hostname_or_id';
export const TEXTUAL_CHIP = 'textual';
export const TAG_CHIP = 'tags';
export const STALE_CHIP = 'staleness';
export const REGISTERED_CHIP = 'registered_with';
export const OS_CHIP = 'operating_system';
export const RHCD_FILTER_KEY = 'rhc_client_id';
export const UPDATE_METHOD_KEY = 'system_update_method';
export const SYSTEM_TYPE_KEY = 'system_type';
export const WORKLOAD_FILTER_KEY = 'workloads';
export const LAST_SEEN_CHIP = 'last_seen';
export const HOST_GROUP_CHIP = 'group_name'; // use the same naming as for the back end parameter
//REPORTERS
export const REPORTER_PUPTOO = 'puptoo';
export const REPORTER_RHSM_CONDUIT = 'rhsm-conduit';
export const REPORTER_RHSM_PROFILE_BRIDGE = 'rhsm-system-profile-bridge';
//APP NAMES
export const APP_NAME_VULNERABILITY = 'vulnerabilities';
export const APP_NAME_ADVISOR = 'advisor';
export const APP_NAME_PATCH = 'patch';
// HOST_TYPE
export const TYPE_CONVENTIONAL = '=conventional';
export const TYPE_EDGE = '=edge';
export const TYPE_BOOTC = '=bootc';

export const INVENTORY_TOTAL_FETCH_URL_SERVER = '/api/inventory/v1/hosts';
export const INVENTORY_TOTAL_FETCH_EDGE_PARAMS =
  '?filter[system_profile][host_type]=edge&page=1&per_page=1';
export const INVENTORY_TOTAL_FETCH_CONVENTIONAL_PARAMS = '?page=1&per_page=1';
export const INVENTORY_PACKAGE_BASED_SYSTEMS = `?${SYSTEM_TYPE_KEY}${TYPE_CONVENTIONAL}`;
export const INVENTORY_IMAGE_BASED_SYSTEMS = `?${SYSTEM_TYPE_KEY}${TYPE_BOOTC}&${SYSTEM_TYPE_KEY}${TYPE_EDGE}`;
export const INVENTORY_FETCH_BOOTC = `?${SYSTEM_TYPE_KEY}${TYPE_BOOTC}`;
export const INVENTORY_FETCH_EDGE = `?${SYSTEM_TYPE_KEY}${TYPE_EDGE}`;

export function subtractDate(days) {
  const date = new Date();
  date.setDate(date.getDate() - days);
  return date.toISOString();
}

export const staleness = [
  { label: 'Fresh', value: 'fresh' },
  { label: 'Stale', value: 'stale' },
  { label: 'Stale warning', value: 'stale_warning' },
];

export const currentDate = new Date().toISOString();
export const lastSeenFilterItems = [
  {
    value: 'last24',
    label: 'Within the last 24 hours',
  },
  {
    value: '24more',
    label: 'More than 1 day ago',
  },
  {
    value: '7more',
    label: 'More than 7 days ago',
  },
  {
    value: '15more',
    label: 'More than 15 days ago',
  },
  {
    value: '30more',
    label: 'More than 30 days ago',
  },
  {
    value: 'custom',
    label: 'Custom',
  },
];
export const lastSeenDefaults = {
  last24: {
    lastCheckInStart: subtractDate(1),
    lastCheckInEnd: currentDate,
  },
  '24more': {
    lastCheckInEnd: subtractDate(1),
  },
  '7more': {
    lastCheckInEnd: subtractDate(7),
  },
  '15more': {
    lastCheckInEnd: subtractDate(15),
  },
  '30more': {
    lastCheckInEnd: subtractDate(30),
  },
  custom: {},
};
export const registered = [
  {
    label: 'insights-client',
    value: 'puptoo',
    idName: 'Insights Client ID',
    idValue: 'insights_id',
  },
  {
    label: 'subscription-manager',
    value: 'rhsm-conduit',
    idName: 'Subscription Manager ID',
    idValue: 'subscription_manager_id',
  },
  {
    label: 'Satellite',
    value: 'satellite',
    idName: 'Satellite ID',
    idValue: 'satellite_id',
  },
  {
    label: 'Discovery',
    value: 'discovery',
    idName: 'Discovery ID',
    idValue: 'discovery_id',
  },
  { label: 'insights-client not connected', value: '!puptoo' },
];
export const InventoryContext = createContext({});

export const rhcdOptions = [
  { label: 'Active', value: 'not_nil' },
  { label: 'Inactive', value: 'nil' },
];

const initUpdateMethodOptions = [
  { label: 'yum', value: 'yum' },
  { label: 'dnf', value: 'dnf' },
  { label: 'rpm-ostree', value: 'rpm-ostree' },
];

export const updateMethodOptions = initUpdateMethodOptions;

export const systemTypeOptions = [
  {
    label: 'Package-based system',
    value: 'conventional',
    packageBasedValues: ['conventional'],
  },
  {
    label: 'Image-based system',
    value: 'bootc',
    imageBasedValues: ['bootc', 'edge'],
  },
];

export const workloadOptions = [
  { label: 'Ansible Automation Platform', value: 'ansible' },
  { label: 'CrowdStrike', value: 'crowdstrike' },
  { label: 'IBM DB2', value: 'ibm_db2' },
  { label: 'InterSystems', value: 'intersystems' },
  { label: 'Microsoft SQL', value: 'mssql' },
  { label: 'Oracle DB', value: 'oracle_db' },
  { label: 'RHEL AI', value: 'rhel_ai' },
  { label: 'SAP', value: 'sap' },
];

/** Maps workload filter keys to system_profile.workloads.* API filter shapes (presence). */
export const WORKLOAD_API_MAP = {
  sap: { is: 'not_nil' },
  ansible: { is: 'not_nil' },
  mssql: { is: 'not_nil' },
  crowdstrike: { is: 'not_nil' },
  ibm_db2: { is: 'not_nil' },
  oracle_db: { is: 'not_nil' },
  intersystems: { is: 'not_nil' },
  rhel_ai: { is: 'not_nil' },
};

export function filterToGroup(filter = [], valuesKey = 'values') {
  return filter.reduce(
    (accGroup, group) => ({
      ...accGroup,
      [group.key]: group[valuesKey].reduce(
        (acc, curr) => ({
          ...acc,
          [curr.key]: {
            isSelected: true,
            group: curr.group,
            item: {
              meta: {
                tag: {
                  key: curr.tagKey,
                  value: curr.value,
                },
              },
            },
          },
        }),
        {},
      ),
    }),
    {},
  );
}

export const arrayToSelection = (selected) =>
  selected.reduce(
    (acc, { cells: [key, value, namespace] }) => ({
      ...acc,
      [namespace]: {
        ...acc[namespace?.title || namespace],
        [`${key?.title || key}=${value?.title || value}`]: {
          isSelected: true,
          group: {
            value: namespace?.title || namespace,
            label: namespace?.title || namespace,
          },
          item: {
            tagKey: key?.title || key,
            tagValue: value?.title || value,
            value: `${key?.title || key}=${value?.title || value}`,
            id: `${key?.title || key}-${value?.title || value}`,
            meta: {
              tag: { key: key?.title || key, value: value?.title || value },
            },
          },
        },
      },
    }),
    {},
  );

export function reduceFilters(filters = []) {
  return filters.reduce(
    (acc, oneFilter) => {
      if (oneFilter.value === TEXT_FILTER) {
        return { ...acc, textFilter: oneFilter.filter };
      } else if ('tagFilters' in oneFilter) {
        return {
          ...acc,
          tagFilters: filterToGroup(oneFilter.tagFilters),
        };
      }

      const foundKey = [
        'staleFilter',
        'registeredWithFilter',
        'osFilter',
        'rhcdFilter',
        'updateMethodFilter',
        'lastSeenFilter',
        'hostGroupFilter',
        '',
        'systemTypeFilter',
        'workloadFilter',
      ].find((item) => Object.keys(oneFilter).includes(item));

      return {
        ...acc,
        ...(foundKey && { [foundKey]: oneFilter[foundKey] }),
      };
    },
    {
      textFilter: '',
      tagFilters: {},
    },
  );
}

export const reloadWrapper = (event, callback) => {
  return {
    ...event,
    payload: event.payload.then((data) => {
      callback();
      return data;
    }),
  };
};

export const isEmpty = (check) => !check || check?.length === 0;

export const generateFilter = (
  status,
  source,
  tagsFilter,
  filterbyName,
  operatingSystem,
  rhcdFilter,
  updateMethodFilter,
  hostGroupFilter,
  lastSeenFilter,
  systemTypeFilter,
  workloadFilter,
) =>
  [
    !isEmpty(status) && {
      staleFilter: Array.isArray(status) ? status : [status],
    },
    !isEmpty(tagsFilter) && {
      tagFilters: Array.isArray(tagsFilter) ? tagsFilter : [tagsFilter],
    },
    !isEmpty(source) && {
      registeredWithFilter: Array.isArray(source) ? source : [source],
    },
    !isEmpty(filterbyName) && {
      value: 'hostname_or_id',
      filter: Array.isArray(filterbyName) ? filterbyName[0] : filterbyName,
    },
    (!isEmpty(status) || !isEmpty(tagsFilter) || !isEmpty(filterbyName)) &&
      isEmpty(source) && {
        registeredWithFilter: [],
      },
    (!isEmpty(source) || !isEmpty(tagsFilter) || !isEmpty(filterbyName)) &&
      isEmpty(status) && {
        staleFilter: [],
      },
    !isEmpty(operatingSystem) &&
      Object.keys(operatingSystem).length && {
        osFilter: operatingSystem,
      },
    !isEmpty(rhcdFilter) && {
      rhcdFilter: Array.isArray(rhcdFilter) ? rhcdFilter : [rhcdFilter],
    },
    !isEmpty(lastSeenFilter) && {
      lastSeenFilter: Array.isArray(lastSeenFilter)
        ? { mark: lastSeenFilter[0], ...lastSeenDefaults[lastSeenFilter[0]] }
        : [lastSeenFilter],
    },
    !isEmpty(updateMethodFilter) && {
      updateMethodFilter: Array.isArray(updateMethodFilter)
        ? updateMethodFilter
        : [updateMethodFilter],
    },
    !isEmpty(hostGroupFilter) && {
      hostGroupFilter: Array.isArray(hostGroupFilter)
        ? hostGroupFilter
        : [hostGroupFilter],
    },
    !isEmpty(systemTypeFilter) && {
      systemTypeFilter: Array.isArray(systemTypeFilter)
        ? systemTypeFilter
        : [systemTypeFilter],
    },
    !isEmpty(workloadFilter) && {
      workloadFilter: Array.isArray(workloadFilter)
        ? workloadFilter
        : [workloadFilter],
    },
  ].filter(Boolean);

export const allStaleFilters = ['fresh', 'stale', 'stale_warning'];

export const systemTypeContent = {
  imageLabel: 'Image-based',
  packageLabel: 'Package-based',
  imageContent: (
    <Content>
      <Content component="p">
        Image mode for Red Hat Enterprise Linux and Immutable (OSTree) are
        version-controlled deployment models that support atomic updates and
        rollbacks.
      </Content>
      <Content component="p">
        Image mode delivers the OS as a container image, while Immutable
        (OSTree) manages it as a versioned file system tree – both providing
        consistency and reliability similar to containerized applications.
      </Content>
    </Content>
  ),
  packageContent: (
    <Content>
      <Content component="p">
        Package-based deployment is a familiar Red Hat Enterprise Linux (RHEL)
        experience across any footprint where the OS is assembled and updated
        from rpm packages. This is traditionally how RHEL is deployed and will
        remain the preferred method for many.
      </Content>
    </Content>
  ),
};