/* If-else functional */
export const conditionally =
  <Props, Result>(options: {
    if: (props: Props) => any;
    then: (props: Props) => Result | Result;
    else: (props: Props) => Result | Result;
  }) =>
  (props: Props) => {
    return options.if(props) ? options.then(props) : options.else(props);
  };

  /* Try-catch functional */
  export function tryCatch<Props, Result>({
    tryer,
    catcher,
  }: {
    tryer: (props: Props) => Result;
    catcher: (props: Props, message: string) => Result;
  }) {
    return (props: Props) => {
      try {
        return tryer(props);
      } catch (e) {
        return catcher(props, e.message);
      }
    };
  }

  type Enum = { [s: number]: string };

  /* Check if a key is property of enum */
  export function isEnumKey<T extends Enum>(
    enumSrc: T,
    key: unknown
  ): key is keyof T {
    return Number.isInteger(enumSrc[key as keyof T]);
  }

  /* Check if enum has a given value */
  export function isEnumValue<T extends Enum>(
    enumSrc: T,
    value: unknown
  ): value is T[keyof T] {
    return Number.isInteger(
      enumSrc[enumSrc[value as keyof T] as any as keyof T]
    );
  }

/* Transform enum to list of keys */
export function enumToKeys<T extends Enum>(enumSrc: T): (keyof T)[] {
  return Object.keys(enumSrc).filter((key: keyof T | any) =>
    isEnumKey(enumSrc, key)
  ) as (keyof T)[];
}

/* Transform enum to list of values */
export function enumToValues<T extends Enum>(enumSrc: T): T[keyof T][] {
  return enumToKeys(enumSrc).map((key: keyof T) => enumSrc[key]);
}


/* Transform enum value to its appropriate key */
export function enumValueToKey<T extends Enum>(
  enumSrc: T,
  value: T[keyof T]
): keyof T | undefined {
  return (enumSrc as any)[value];
}

/* Transform enum to entries */
export function enumToEntries<T extends Enum>(enumSrc: T): [keyof T, T[keyof T]][] {
  return enumToValues(enumSrc).map((value: T[keyof T]) => [
    enumValueToKey(enumSrc, value) as keyof T,
    value,
  ]);
}
/* Transform enum to mapped Object */
export function convertEnumToStringEnumObject<T>(enumLike: T) {
  type stringEnum<T> = { [K in T & string]: K }

  return Object.values(enumLike)
    .filter((value) => typeof value === 'string')
    .map((value) => [value, value])
    .reduce(
      (acc, [key, value]) => Object.assign(acc, { [key]: value }),
      {}
    ) as stringEnum<keyof typeof enumLike>
}

/* Create a function that transforms enum value into CSS class */
interface UiClass {
  prefix?: string;
  suffix?: string;
  delimiter?: string;
}

const DEFAULT_CONFIG: UiClass = {
  suffix: "",
  prefix: "",
  delimiter: "-",
};

const uiClassByEnum = (enumSrc: Enum, config: UiClass = {}) => {
  const { suffix, prefix, delimiter } = { ...DEFAULT_CONFIG, ...config };

  return (enumValue: number) => {
    const enumKey = (enumSrc as any)[enumValue]
      .match(/[A-Z][a-z]+/g)
      .join(delimiter)
      .toLowerCase();

    return [prefix, enumKey, suffix].filter(Boolean).join(delimiter);
  };
};
  // Example:
  const asDayOfWeekUiClass = uiClassByEnum(DayOfWeek, {
  prefix: "obv",
  suffix: "element",
  delimiter: "_",
});

console.log(asDayOfWeekUiClass(DayOfWeek.Wednesday)); // obv_wednesday_element

enum RolesEnum {
  Read = 1,
  Write = 2,
  ReadWrite = 3,
}

const asRolesWeekUiClass = uiClassByEnum(RolesEnum, {
  prefix: "ng",
  suffix: "element",
});

console.log(asRolesWeekUiClass(DayOfWeek.Wednesday)); // ng-read-write-element

/* Project the list of objects from an enum */
function fromEnum<T extends Enum, C>(
  enumSrc: T,
  projection: (
    item: [keyof T, T[keyof T]],
    index: number,
    array: [keyof T, T[keyof T]][]
  ) => C,
  skip?: (
    value: [keyof T, T[keyof T]],
    index: number,
    array: [keyof T, T[keyof T]][]
  ) => boolean
) {
  let entries = enumToEntries(enumSrc);

  if (skip) entries = entries.filter(skip);

  return entries.map(projection);
}

// Example:
interface Option<T> {
  label: keyof T;
  value: T[keyof T];
}

const options: Option<typeof DayOfWeek>[] = fromEnum(
  DayOfWeek,
  ([label, value]: [keyof typeof DayOfWeek, DayOfWeek]) => ({
    label,
    value,
  })
);

console.log(options);

/*
[
  { label: 'Monday', value: 1 },
  { label: 'Tuesday', value: 2 },
  { label: 'Wednesday', value: 3 },
  { label: 'Thursday', value: 4 },
  { label: 'Friday', value: 5 },
  { label: 'Saturday', value: 6 },
  { label: 'Sunday', value: 7 }
]
*/


export const roundTo = (number: number, digits = 0): number => {
  let negative = false;
  let n = number;
  if (n < 0) {
    negative = true;
    n *= -1;
  }
  const multiplicator = 10 ** digits;
  n = parseFloat((n * multiplicator).toFixed(11));
  n = +(Math.round(n) / multiplicator).toFixed(2);
  if (negative) {
    n = +(n * -1).toFixed(2);
  }
  return n;
};