import DateFormatter from "../date/date-formatter";
import DataConverter from "./data-converter";
import { SEOUL_REGION_TELEPHONE_NUMBER } from "../common/constants";
import { chargingPowerListData } from "../common/data/csms/charging-price/charging-power-list.data";
import { reportTypeData } from "../common/data/chungguk-admin/report/list/report-type.data";
import { reportStatusData } from "../common/data/chungguk-admin/report/list/report-status.data";

export default class DataFormatter {
  /**
   * 숫자가 아니면 삭제되며 숫자가 주어지면 2자리-3자리-4자리 혹은 3자리-4자리-4자리로 format해 return한다.
   *
   * "01011112222" -> "010-1111-2222"
   * "021234567" -> "02-123-4567"
   *
   * @static
   * @public
   * @return string
   * @param number
   */
  static addHyphenToNumber(number: string) {
    return number
      .replace(/[^0-9]/g, "")
      .replace(/^(\d{2,3})(\d{3,4})(\d{4})$/, "$1-$2-$3");
  }

  /**
   * value의 값이 존재하면 그대로 보여주고 없을 경우 "-"를 return한다.
   *
   * null -> "-"
   * "hello" -> "hello"
   *
   * @static
   * @public
   * @return string
   * @param value
   */
  static checkDataEmptyValue(value?: string | null): string {
    return !value || "" === value ? "-" : value;
  }

  /**
   * value가 0이거나 값이 없으면 return "-", 1 이상이면 value를 return한다.
   *
   * null -> "-"
   * 0 -> "-"
   * 5 -> 5
   *
   * @static
   * @public
   * @return "-" or value
   * @param value
   */
  static checkEmptyAndZeroValue(value: number): number | string {
    return !value || 0 === value ? "-" : value;
  }

  /**
   * value가 null이나 undefined일 경우 "-" return, 아닐경우 value를 return한다.
   *
   * null -> "-"
   * undefined -> "-"
   * "hello" -> "hello"
   *
   * @static
   * @public
   * @return '-' or value
   * @param value
   */
  static checkNullAndUndefinedValue(value: any) {
    return null === value || undefined === value ? "-" : value;
  }

  /**
   * value가 null이나 return, 아닐경우 value를 return한다.
   *
   * null -> "-"
   * undefined -> undefined
   * "hello" -> "hello"
   *
   * @static
   * @public
   * @return "-" or value
   * @param value
   */
  static checkNullValue(value: any) {
    return null !== value ? value : "-";
  }

  /**
   * link에 html a tag를 넣어 return한다.
   *
   * @static
   * @public
   * @return html tag
   * @param link string url
   */
  static checkValidLink(link: string) {
    const linkRegex = /^(https?:\/\/)?(\w)+(\.\w+)+$/g;

    return linkRegex.test(link)
      ? `<a href="http://${link.replace(
          /^https?:\/\//,
          ""
        )}" target="_blank">${link}</a>`
      : link;
  }

  /**
   * 인자로 두 수를 넣으면 ~kW이상 ~kW 미만으로 convert해 return한다.
   * 400.01 이상일 경우 ~KW이상
   * 두 인자가 같을 경우 ~kW 로 표현된다.
   *
   * 100,100 -> 100kW
   * 500, 400.01 -> 400.01이상
   * 30, 100 -> 7kW 이상 100kW 미만
   *
   * @static
   * @public
   * @return 400초과면 400kW 이상, 400 이하이면 ~kW 이상 kW미만으로 표현
   * @param from
   * @param to
   */
  static convertChargingPowerValueToRangeString(from: number, to: number) {
    const fromValue = DataFormatter.findPowerValue("from", from);
    const toValue = DataFormatter.findPowerValue("to", to);

    if (from === to) {
      return `${fromValue}kW`;
    } else if (400.01 === to) {
      return `${fromValue}kW 이상`;
    } else {
      return `${fromValue}kW 이상 ${toValue}kW 미만`;
    }
  }

  /**
   * value의 값이 null이면 null return, 아니면 value를 return한다.
   *
   * null -> null
   * "hello" -> "hello"
   * 2 -> 2
   *
   * @static
   * @public
   * @return null or value
   * @param value
   */
  static convertEmptyValueToNull(value: string | number | undefined | null) {
    return null !== value ? value : null;
  }

  /**
   * value의 값이 null이 아니면 unit을 붙여주고 존재하지 않을 경우 return "-"
   *
   * null, "원" -> "-"
   * 300, "원" -> "300원"
   *
   * @static
   * @public
   * @return value + unit or "-"
   * @param value
   * @param unit 단위
   */
  static convertEmptyValueToNullAndInsertUnit(
    value: number | null,
    unit: string
  ) {
    return null === value ? "-" : value + unit;
  }

  /**
   * 전화번호 input값 02로 시작할 경우 2자리-4자리-4자리 그 외에 경우에는 3자리-4자리-4자리로 format해 fieldName의 field에 set한다.
   *
   * "0101234-4567" , "phoneNumber" -> "010-1234-4567" phoneNumber 필드에 set
   * "021234567", "phoneNumber" -> "02-123-4567"를 phoneNumber 필드에 set
   *
   * @static
   * @public
   * @return 02-1111-2222 or 010-1111-2222
   * @param value
   * @param setFieldValue form의 setFiledValue
   * @param fieldName form의 fieldName
   */
  static convertPhoneNumberBetweenDashBarInForm(
    value: string,
    setFieldValue: (field: string, value: any) => void,
    fieldName: string
  ) {
    setFieldValue(
      fieldName,
      value
        .replace(/[^0-9]/g, "")
        .replace(
          12 === value.length && value.startsWith(SEOUL_REGION_TELEPHONE_NUMBER)
            ? /^(\d{0,2})(\d{0,4})(\d{0,4})$/g
            : /^(\d{2,3})(\d{3,4})(\d{4})$/g,
          "$1-$2-$3"
        )
        .replace(/(\-{1,2})$/g, "")
    );
  }

  /**
   * type으로 from이 주어지면 power보다 큰 값을 찾아 그 앞의 값은 반환하며 to가 주어지면 주어진 power보다 작은 값을 찾아 그 뒤의 값을 return한다.
   *
   * "from", chargingPowerListData[11] -> chargingPowerListData[11]
   * "to", chargingPowerListData[11] -> chargingPowerListData[10]
   * "to", chargingPowerListData[0] - 1 -> chargingPowerListData[0]
   * "from", 500 -> chargingPowerListData[chargingPowerListData.length - 1]
   *
   * @static
   * @public
   * @return power
   * @param type from: 주어진 power보다 큰 값을 찾아 그 앞의 값으로 변환.
   *             to: 주어진 power보다 작은 값을 찾아 그 뒤의 값으로 변환.
   * @param power
   */
  static convertPowerData(type: "from" | "to", power: number): number {
    const powerListLength = chargingPowerListData.length;

    if ("from" === type) {
      for (let i = 0; i < powerListLength; i++) {
        if (power < chargingPowerListData[i]) {
          return chargingPowerListData[i - 1];
        }
      }
      return chargingPowerListData[powerListLength - 1];
    } else {
      for (let i = powerListLength - 1; i > 0; i--) {
        if (power > chargingPowerListData[i]) {
          return chargingPowerListData[i];
        }
      }
      return chargingPowerListData[0];
    }
  }

  /**
   * type에 따라 주어진 power보다 작거나 같은값 혹은 크거나 같은 값 중 가장 작은값, 가장 큰 값을 return한다.
   *
   * "to", 90 -> 100
   * "from", 90 -> 50
   *
   * @static
   * @public
   * @return
   * @param type from: chargingPowerListData에서 주어진 power보다 작거나 같은 값 중 가장 큰 값.
   *             to: chargingPowerListData에서 주어진 power보다 크거나 같은 값 중 가장 작은 값.
   * @param power
   */
  static findPowerValue(type: "from" | "to", power: number) {
    const powerListLength = chargingPowerListData.length;
    let powerValue;

    if ("from" === type) {
      powerValue = chargingPowerListData[0];
      for (let i = 0; i < powerListLength - 2; i += 2) {
        if (power >= chargingPowerListData[i]) {
          powerValue = chargingPowerListData[i];
        }
      }
    } else if ("to" === type) {
      powerValue = chargingPowerListData[powerListLength - 2];
      for (let i = powerListLength - 2; i >= 0; i -= 2) {
        if (power <= chargingPowerListData[i]) {
          powerValue = chargingPowerListData[i];
        }
      }
    }

    return powerValue;
  }

  /**
   * value에 3자리마다 ,를 넣고 뒤에 unit을 붙인다. showZero에 따라 0을 보여줄지 정하고 value가 undefined거나 null일 때 showZero가 false면 "-"를 return한다.
   *
   * 20000, "원", true -> "20,000원"
   * undefined, "원", false -> "-"
   *
   * @static
   * @public
   * @return string
   * @param value
   * @param unit string
   * @param showZero boolean
   */
  static formatCommaValue(
    value: number | null | undefined,
    unit: string,
    showZero: boolean
  ): string {
    return null === value || undefined === value
      ? showZero
        ? "0" + unit
        : "-"
      : value.toLocaleString("ko-KR") + unit;
  }

  /**
   * null이나 undefined를 넘기면 "-" return, number를 넘기면 3자리 마다 , 추가해 return한다.
   *
   * null -> "-"
   * undefined -> "-"
   * 3000 -> "3,000"
   *
   * @static
   * @public
   * @return string
   * @param value
   */
  static formatCommaValueNoUnit(value: number | null | undefined): string {
    return null === value || undefined === value
      ? "-"
      : value.toLocaleString("ko-KR");
  }

  /**
   * 아우토크립트.멋진회사 -> 아우토크립트(멋진회사) convert하는 함수
   *
   * @static
   * @public
   * @return '.'이 포함되면 .이후는 ()안에 포함.
   * @param name 운영기관 이름
   */
  static formatOperatingInstitutionName(name: string) {
    if (!name) return name;

    const [primary, secondary] = name.split(".");
    return `${primary}${secondary ? `(${secondary})` : ""}`;
  }

  /**
   * 아우토크립트(멋진회사) -> 아우토크립트.멋진회사 convert하는 함수
   *
   * @static
   * @public
   * @return ()안에 포함된 이름을 '.'을 뒤에 붙임.
   * @param name 운영기관 이름
   */
  static parseOperatingInstitutionName(name: string) {
    if (!name) return name;

    const [primary, secondary] = name.replace(")", "").split("(");
    return `${primary}${secondary ? `.${secondary}` : ""}`;
  }

  /**
   * 인자로 넘긴 array가 length가 있으면 filterList에 array의 value, isAll은 false를 넣어 return하고 빈 배열이면 그 배열을 다시 return한다.
   *
   * { filterList: [{ value: "kkkk" }] } -> { filterList: ["kkkk"], isAll: false }
   * { filterList: [] } -> { filterList: [] }
   *
   * @static
   * @public
   * @return filterList, isAll을 포함한 object
   * @param arr filterList: {value: string}[]
   */
  static parseValueList(arr: any) {
    if (0 === arr.filterList.length) return arr;
    return {
      filterList: arr.filterList.map((item: any) => item.value),
      isAll: false,
    };
  }

  /**
   * 주차 요금을 입력해 주세요 질문에 들어온 대답을 분/원으로 format해 return한다.
   *
   *  [{ question: "주차 요금을 입력해 주세요", answer: "기본요금 : 5/1000" },]
   *   -> [{ answer: ["기본요금 :\n5분\n / \n1,000원"], question: "주차 요금을 입력해 주세요" },]
   *  [{ question: "주차 요금을 입력해 주세요", answer: "기본요금 : 120/1000" },] -> [{ answer: ["기본요금 :\n2시간\n / \n1,000원"], question: "주차 요금을 입력해 주세요",}]
   *
   * @static
   * @public
   * @return string
   * @param list
   */
  static convertChargePriceList(list: any) {
    const convertedReportQnaList: Array<string> = [];
    let hasChargePriceList = false;

    const reportContent = list?.filter((item: any) => {
      if ("주차 요금을 입력해 주세요" === item.question) {
        hasChargePriceList = true;

        const splitAnswer = item.answer.split("/");
        const chargePrice =
          Number(splitAnswer[1]).toLocaleString("ko-KR") + "원";
        let hourAndMinute: any = Number(splitAnswer[0].slice(6));
        const chargeName = splitAnswer[0].slice(0, 6);

        if (hourAndMinute > 60) {
          hourAndMinute =
            chargeName + "\n" + Math.floor(hourAndMinute / 60) + "시간";
        } else {
          hourAndMinute = chargeName + "\n" + hourAndMinute + "분";
        }

        convertedReportQnaList.push(hourAndMinute + "\n / \n" + chargePrice);
      } else {
        return item;
      }
    });

    return hasChargePriceList
      ? [
          ...reportContent,
          {
            question: "주차 요금을 입력해 주세요",
            answer: convertedReportQnaList,
          },
        ]
      : reportContent;
  }

  /**
   * 제보에 대한 정보가 인자로 주어지면 그 정보를 convert해 return한다.
   *
   *  "반영 여부", true -> "반영"
   *  "승인 상태", 1 -> "승인 완료"
   *  "제보 일시", "2024-01-03T05:39:14.230Z" -> "2024-01-03 14:39:14"
   *  "최종 업데이트", "2024-01-03T05:39:14.230Z" -> "2024-01-03 14:39:14"
   *  "담당자", 3905 -> "계정(3905)"
   *  "제보 구분", true -> "자동 반영 제보"
   *  "제보 수집 항목", 2 -> "주차 요금"
   *
   * @static
   * @public
   * @return string
   * @param field
   * @param info
   */
  static reportConvertValue(field: string, info: any) {
    if ("반영 여부" === field) {
      return info ? "반영" : "미반영";
    }

    if ("제보 구분" === field) {
      return info ? "자동 반영 제보" : "수동 반영 제보";
    }

    if ("제보 수집 항목" === field) {
      return DataConverter.convertData(reportTypeData, "index", info)
        ?.description;
    }

    if ("승인 상태" === field) {
      return DataConverter.convertData(reportStatusData, "index", info)
        ?.description;
    }

    if ("담당자" === field) {
      return isNaN(info) || info === null
        ? `관리자(${info ? info : "-"})`
        : `계정(${info})`;
    }

    if ("제보 일시" === field || "최종 업데이트" === field) {
      return DateFormatter.noSetKoreanHour(info, "yyyy-MM-dd HH:mm:ss");
    }

    return info;
  }
}