export default class DataConverter {
  /**
   * dataObject의 key property가 일치하는 value를 return한다.
   *
   * @static
   * @public
   * @return
   * @param data dataObject
   * @param key
   * @param value
   */
  static convertData(data: object, key: string, value: string | number) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData[key] === value
    );
  }

  /**
   * dataObject의 id propterty가 일치하는 value의 description return한다.
   *
   * @static
   * @public
   * @return string
   * @param data dataObject
   * @param text
   */
  static convertDescriptionById(data: object, text: string | undefined) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData.id === text
    )?.description;
  }

  /**
   * dataObject에서 인자로 넘긴 index와 동일한 index를 가진 data의 description을 return한다.
   *
   * @static
   * @public
   * @return description in dataObject
   * @param data dataObject
   * @param index index in dataObject
   */
  static convertDescriptionByIndex(data: object, index?: number) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData.index === index
    )?.description;
  }

  /**
   * dataObject의 text propterty가 일치하는 value의 description return
   *
   * @static
   * @public
   * @return description in dataObject
   * @param data dataObject
   * @param text
   */
  static convertDescriptionByText(data: object, text: string | undefined) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData.text === text
    )?.description;
  }

  /**
   * title의 첫번째 알파벳을 대문자로 바꾸어 주고 대문자로 시작하는 단어가 여러 개일 경우 각 단어 사이에 공백을 추가해 return한다.
   * happyHoliday -> Happy Holiday
   *
   * @static
   * @public
   * @return string
   * @param title
   */
  static convertFirstAlphabetUpperCase(title: string) {
    const splitTitle = title.split("");
    let upperCaseCount = 0;

    splitTitle.forEach((item, index) => {
      if (item.toUpperCase() === item) {
        upperCaseCount++;

        if (upperCaseCount > 0) {
          splitTitle[index - 1] = title[index - 1] + " ";
        }
      }

      if (index === 0) {
        splitTitle[0] = item.toUpperCase();
      }
    });

    return splitTitle.join("");
  }

  /**
   * dataObject에서 description으로 넘긴 인자값과 동일한 description을 가진 data의 index를 return한다.
   *
   * @static
   * @public
   * @return description in dataObject
   * @param data
   * @param description
   */
  static convertIndexByDescription(data: object, description?: string) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData.description === description
    )?.index;
  }

  /**
   * dataObject에서 text 인자값과 동일한 text를 가진 data의 index를 return한다.
   *
   * @static
   * @public
   * @return description in dataObject
   * @param data
   * @param text
   */
  static convertIndexByText(data: object, text: string) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData.text === text
    )?.index;
  }

  /**
   * data의 key가 type인 index를 return한다.
   *
   * @public
   * @return description in dataObject
   * @param data dataObject
   * @param type 찾으려고 하는 index의 value
   * @param key data의 property
   */
  static convertIndexByTextAndDescription(
    data: object,
    type: string | number | undefined,
    key: string
  ) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    return Object.values(copiedData).find(
      (copiedData) => copiedData[`${key}`] === type
    )?.index;
  }

  /**
   * dataObject의 text와 인자로 넘겨진 text가 일치할 때 index를 return한다.
   *
   * @static
   * @public
   * @return description in dataObject
   * @param object
   * @param text
   */
  static convertTextByIndex(object: object, text?: string) {
    const copiedType: object = JSON.parse(JSON.stringify(object));

    return Object.values(copiedType).find(
      (copiedType) => copiedType.text === text
    )?.index;
  }

  /**
   * dataObject에서 property가 value인 것들을 리스트로 만들고 sliceIndexNumber만큼 slice해서 return
   *
   * @static
   * @public
   * @return array
   * @param data dataObject
   * @param value porperty 이름
   * @param sliceIndexNumber slice할 index
   */
  static getArrayByObject(
    data: object,
    value: string,
    sliceIndexNumber: number
  ) {
    const copiedData: object = JSON.parse(JSON.stringify(data));

    const array = Object.values(copiedData).map((item) => {
      return item[`${value}`];
    });

    return array.slice(sliceIndexNumber);
  }

  /**
   * "e", "E", "+", "-", "."가 입력되면 이벤트를 취소한다.
   *
   * @static
   * @public
   * @return
   * @param event key event
   */
  static preventString(event: any) {
    return (
      ["e", "E", "+", "-", "."].includes(event.key) && event.preventDefault()
    );
  }

  /**
   * evChargerTypeList에서 key property중 value의 값을 가진 data의 description들을 array로 만든 후 ', '를 붙여 연결 시키고 return한다.
   *
   * @static
   * @public
   * @return string
   * @param evChargerTypeList
   * @param constantData
   * @param key
   */
  static setListToString(
    evChargerTypeList: number[],
    constantData: object,
    key: string
  ) {
    return evChargerTypeList
      ?.map(
        (value) =>
          DataConverter.convertData(constantData, key, value)?.description
      )
      .join(", ");
  }
}