import { VM } from "vm2";

import { Offset } from "./offset";
import { RawOffsetValue } from "./interfaces/rawOffset";
import { ConvertedOffsetValue } from "./interfaces/convertOffset";
import { ValidationFailedError } from "./utils/erros";
import { reverse } from "dns";

export const applyConversion = (
  offset: Offset,
  rawOffsetValue: RawOffsetValue,
): ConvertedOffsetValue => {
  if (!offset.convert) {
    return rawOffsetValue;
  }

  if (offset.hasMapping) {
    if (offset.isMappingInvalid) {
      return "INVALID_MAPPING_FUNCTION";
    }

    return offset.mappingFunction(rawOffsetValue);
  } else {
    // tslint:disable-next-line:no-eval
    if (offset.isInvalidConvertExpression) {
      return "UNSUPPORTED_CONVERSION_EXPRESSION";
    }

    return new VM().run(replaceOffsetExpressionValue(offset, rawOffsetValue));
  }
};

export const applyReverseConversion = (
  offset: Offset,
  convertedOffsetValue: ConvertedOffsetValue,
): RawOffsetValue => {
  if (!offset.convert || !offset.reverseConvert) {
    return convertedOffsetValue;
  }

  if (offset.isInvalidReverseConvertExpression) {
    throw new ValidationFailedError("Invalid reverse convert expression");
  }

  return new VM().run(
    replaceOffsetExpressionValue(offset, convertedOffsetValue, true),
  );
};

export const replaceOffsetExpressionValue = (
  offset: Offset,
  rawOffsetValue: RawOffsetValue,
  reverse: boolean = false,
): string => {
  if (!reverse)
    return offset.convert.replace(
      new RegExp(/{VAL}/g),
      Array.isArray(rawOffsetValue)
        ? `${JSON.stringify(rawOffsetValue)}`
        : typeof rawOffsetValue === "string"
        ? `'${rawOffsetValue}'`
        : rawOffsetValue.toString(),
    );
  else
    return offset.reverseConvert.replace(
      new RegExp(/{VAL}/g),
      Array.isArray(rawOffsetValue)
        ? `${JSON.stringify(rawOffsetValue)}`
        : typeof rawOffsetValue === "string"
        ? `'${rawOffsetValue}'`
        : rawOffsetValue.toString(),
    );
};