import { validate } from 'uuid';
import moment from 'moment';
import { keyBy } from 'lodash';
import { formatTime } from '@/utils/date';

import { ClientFormilyData, ServerFormilyData, FormilyData, FormilyType } from './interface';

/**
 * 将模板数据(后端)转换为前端所需数据
 * @param infos
 */
export function transformFormilyServerData(
  infos: ServerFormilyData[],
  internal: boolean = false
): ClientFormilyData[] {
  return infos.map((item) => ({
    ...item,
    required: !!item.required,
    internal
  }));
}

/**
 * 将模板数据(前端)转换为后端所需数据
 * @param infos
 */
export function transformFormilyClientData(fields: ClientFormilyData[]): ServerFormilyData[] {
  return fields.map((item) => {
    const info: ServerFormilyData = {
      id: item.id,
      type: item.type,
      name: item.name,
      required: item.required ? 1 : 0
    };

    if (item.type === 'multiSelects' || item.type === 'selects') {
      info.options = item.options;
    }

    return info;
  });
}

/**
 * 获取表单项的值
 * @param type
 * @param value
 */
export function getFormilyItemValue(type: FormilyType, value: any) {
  let result: FormilyData['value'] = undefined;

  if (!value) return undefined;

  result = value;

  if (type === 'dates') {
    // 接口要求是时间戳
    result = moment(value).valueOf();
  }

  if (type === 'dateBetweens' && Array.isArray(value) && value.length === 2) {
    result = value.map((item: moment.Moment) => moment(item).valueOf());
  }

  if (type === 'videos') {
    if (Array.isArray(result)) {
      result = result.map((item) => ({
        uid: item.uid,
        url: item.url,
        name: item.name,
        type: item.type
      }));
    } else {
      result = [];
    }
  }

  return result;
}

export function getFieldClientValue(type: FormilyType, value: any) {
  if (type === 'inputs' || type === 'selects') {
    return value || undefined;
  }

  if (type === 'multiSelects') {
    return value || [];
  }

  if (type === 'dates') {
    return value ? moment(+value) : undefined;
  }

  if (type === 'dateBetweens') {
    return value && value.length === 2 ? value.map((item: string) => moment(+item)) : undefined;
  }

  return value;
}

/**
 * 获取非Formily表单项的Key
 * @param data
 */
export function getFormilyKeys(data: Record<string, any> = {}): string[] {
  return Object.keys(data).filter((item) => validate(item));
}

/**
 * 获取Formily模板的值
 * @param data
 * @param temps 表单配置模板
 */
export function getFormilyData(
  data: Record<string, any> = {},
  temps: FormilyData[] = []
): FormilyData[] {
  return temps.map((item) => {
    const info: FormilyData = {
      id: item.id,
      type: item.type,
      name: item.name,
      required: item.required ? 1 : 0
    };

    if (item.type === 'multiSelects' || item.type === 'selects') {
      info.options = item.options;
    }

    item.type && (info.value = getFormilyItemValue(item.type, data[item.id]));

    return info;
  });
}

export function getFormDataByFormilyData(temps: FormilyData[] = []): Record<string, any> {
  const result: Record<string, any> = {};
  temps
    .filter((item) => item)
    .forEach((item) => {
      result[item.id] = getFieldClientValue(item.type, item.value);
    });
  return result;
}

export function getValueByName(name: string, data: any) {
  // const { type, options, value } = data;
  const dataKeyByName = keyBy(data, 'name');
  const currentData = dataKeyByName[name];

  if (currentData) {
    const { type, options, value } = currentData;
    if (type === 'inputs') {
      return value;
    }

    if (type === 'numberInputs') {
      return value;
    }

    if (type === 'locations') {
      return value;
    }

    if (type === 'videos') {
      return value;
    }

    if (type === 'multiInputs') {
      return value;
    }

    if (type === 'selects') {
      const opt = options?.find((item: any) => item.id === value);

      return opt?.name;
    }

    if (type === 'multiSelects') {
      let names: string[] = [];
      options.forEach((item: any) => {
        if (Array.isArray(value) && value.includes(item.id)) {
          names.push(item.name);
        }
      });
      return names.join(',');
    }

    if (type === 'dates') {
      return Number(value) ? moment(Number(value)).format('YYYY-MM-DD HH:mm:ss') : '';
    }

    if (type === 'dateBetweens') {
      if (Array.isArray(value) && value.length) {
        const startDate = value[0].split(' ');
        const endDate = value[1].split(' ');
        return `${formatTime(Number(startDate[0]))}~${formatTime(Number(endDate[0]))}`;
      } else {
        return Number(value) ? formatTime(Number(value)) : '';
      }
    }
  }
}