import { message, Modal } from 'antd';
import _ from 'lodash';
import { filterTreeByIds } from '../utils';
import { tree2FlatArray } from '../utils/array';

/** 创建权限取消拦截器 */
export const createCancelInterceptor = (option: {
  checked: boolean;
  formatMessage: (o: { id: string }) => string;
  trigger: () => boolean;
  request: () => Promise<any>;
  refresh?: () => void;
}) => {
  const { checked, formatMessage, trigger, request, refresh } = option;
  return new Promise<boolean>((resolve) => {
    // 选中不拦截
    if (checked) {
      resolve(false);
      return;
    }
    // 取消选中则触发判断
    if (trigger()) {
      Modal.confirm({
        title: formatMessage({ id: 'component.ApplyDetail.detail.cancel.tips' }),
        async onOk() {
          try {
            await request();
            refresh?.();
            message.success(formatMessage({ id: 'component.ApplyDetail.detail.cancel.success' }));
            resolve(false);
          } catch (e) {
            resolve(true);
          }
        },
        onCancel() {
          resolve(true);
        },
      });
    } else {
      resolve(false);
    }
  });
};

/** 格式化过期时间 */
export const formatExpiredAt = (at: number) => {
  return at === 0 ? 0 : Math.round((at - Date.now() / 1000) / 60 / 60 / 24);
};

/** 数据扁平化 */
export const dealTreeData = (data: any[]) => {
  const arrTree: any[] = [];
  data?.forEach((ele: any) => {
    arrTree.push(ele);
    if (ele?.children?.length) {
      arrTree.push(...dealTreeData(ele.children));
    }
  });
  return arrTree;
};

export const mergeAndDedupeArrays = (baseArr: any[] = [], initialArr: any[] = []) => {
  const merged = new Map();
  initialArr.forEach((item) => {
    if (item?.id !== undefined) {
      merged.set(item.id, item);
    }
  });
  baseArr.forEach((item) => {
    if (item?.id !== undefined) {
      merged.set(item.id, item);
    }
  });
  return Array.from(merged.values());
};

// 合并flags对象（处理dataxxx属性）
export const mergeFlagsObjects = (
  baseFlags: Record<string, { data: any[] }>,
  initialFlags: Record<string, { data: any[] }>,
) => {
  const result = { ...initialFlags };
  Object.entries(baseFlags).forEach(([key, value]) => {
    if (key.startsWith('data')) {
      if (!result[key]) {
        result[key] = { data: [] };
      }
      result[key] = {
        ...value,
        data: mergeAndDedupeArrays(
          value?.data || [],
          initialFlags?.[key]?.data?.filter((item) => item.isDefaultCheck) || [],
        ),
      };
    } else {
      result[key] = value;
    }
  });
  return result;
};

export const bindFilter = (item: any, useType?: string) => {
  // 运营端不进行已绑定过滤
  if (useType == 'operation') return false;
  return item.isBind && (!item.expiredAt || item.expiredAt * 1000 >= new Date().getTime());
};

export const formatFlagList = (flagListData: any[], initFlags: any, useType?: string) => {
  if (useType !== 'multiple' || _.isEmpty(flagListData)) return flagListData;
  const flags: any[] = [];
  for (const [key, value] of _.entries<{ data?: any[] }>(initFlags || {})) {
    const optionIds = value?.data?.map((v: any) => Number(v.id)) || [];
    if (optionIds.length > 0) {
      const flagId = Number(key.match(/\d+/));
      if (!flagId) continue;
      const flagData = flagListData?.find((v: any) => v.id === flagId);
      const filterOptionList = filterTreeByIds(flagData?.optionList, optionIds);
      flags.push({ ...flagData, optionList: filterOptionList });
    }
  }
  return flags;
};

export const formatOptionFullList = (
  flagList: any[],
  oldFlagList: any[],
  useType?: string,
  selectFlagIds?: string[],
  defaultExpirationTime?: number,
) => {
  const oldIds = oldFlagList?.map((v) => v.id) ?? [];
  const res =
    flagList?.reduce((pre, cur) => {
      const { id: flagId, optionList } = cur ?? {};
      if (oldIds.includes(flagId)) return pre;

      if (Array.isArray(selectFlagIds) && selectFlagIds.length > 0) {
        const flat = tree2FlatArray(optionList ?? []);
        const defs = selectFlagIds
          .filter((id) => flat.some((sv: any) => Number(sv.id) === Number(id)))
          .map((id) => ({
            id: String(id),
            expiredAt: defaultExpirationTime ? defaultExpirationTime / 60 / 60 / 24 : undefined,
          }));
        pre[`data${flagId}`] = { data: defs };
      } else {
        pre[`data${flagId}`] = { data: [] };
      }
      return pre;
    }, {}) ?? {};

  const oldOptionTree = _.flatten(oldFlagList?.map((v) => v.optionTree) ?? []);
  const list = dealTreeData(oldOptionTree)
    .filter((v) => bindFilter(v, useType))
    .map((v) => ({ ...v, expiredAt: formatExpiredAt(v.expiredAt) }));

  return list.reduce((pre, cur) => {
    const key = `data${cur.flagId}`;
    if (Array.isArray(pre[key]?.data)) {
      pre[key].data.push(cur);
    } else {
      pre[key] = { data: [cur] };
    }
    return pre;
  }, res);
};

export const formatOptionEmptyList = (flagList: any[]) => {
  const list = _.map(flagList, (v) => v.id);
  const res = {};
  list.forEach((id) => {
    const key = `data${id}`;
    if (!res[key]) res[key] = { data: [] };
  });
  return res;
};

export const formatFeatureFullList = (featureTree: any[], useType?: string) => {
  return dealTreeData(featureTree)
    ?.filter((v: any) => bindFilter(v, useType))
    .map((v: any) => ({ ...v, expiredAt: formatExpiredAt(v.expiredAt) }));
};

export const formatOptionList = (oldFlagList: any[], useType?: string) => {
  if (!Array.isArray(oldFlagList)) return [];
  return _.map(
    dealTreeData(_.flatten(_.map(oldFlagList, (v) => v.optionTree)))?.filter((v: any) =>
      bindFilter(v, useType),
    ),
    (v) => `${v.id}`,
  );
};

export const formatMergedVal = (baseValues: any, initialValues: any) => {
  const {
    flags: initFlags,
    roles: initRoles,
    features: initFeatures,
    policies: initPolicies,
    cities: initCities,
  } = initialValues || {};
  const { features, policies, roles, cities, flags } = baseValues || {};
  return {
    ...baseValues,
    ...initialValues,
    features: {
      data: mergeAndDedupeArrays(
        features?.data,
        initFeatures?.data?.filter((v: any) => v.isDefaultCheck) || [],
      ),
    },
    policies: {
      data: mergeAndDedupeArrays(
        policies?.data,
        initPolicies?.data?.filter((v: any) => v.isDefaultCheck) || [],
      ),
    },
    roles: {
      data: mergeAndDedupeArrays(
        roles?.data,
        initRoles?.data?.filter((v: any) => v.isDefaultCheck) || [],
      ),
    },
    cities: {
      data: mergeAndDedupeArrays(
        cities?.data,
        initCities?.data?.filter((v: any) => v.isDefaultCheck) || [],
      ),
    },
    flags: mergeFlagsObjects(flags, initFlags),
  };
};

export const filterFeatureCityIds = (ids: any[], oldIds: any[]) => {
  return (
    ids?.filter((v: any) => {
      return !oldIds?.some((sv: any) => String(sv.featureId) === String(v.featureId));
    }) || []
  );
};