/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 * @create date 2020-11-06 08:54:00
 * @modify date 2021-08-13 10:03:10
 * @desc [description]
 */

export const SPLITCHAR = "/";

const _sentinel = new Object();

/**
 * Function to recurvely get an Attribute of the Object.
 *
 * @export
 * @param {*} _data
 * @param {string} _path
 * @param {*} [_default=_sentinel]
 * @returns {*}
 */
export function rgetattr<T = any>(
  _data: any,
  _path: string,
  _default: any = _sentinel,
  _SPLITCHAR: string = SPLITCHAR
): T | null {
  // Extract the Path
  let _obj = _data;

  if (_path.length > 0) {
    /** Check if there is a Substring available perform the normal method */
    if (_path.indexOf(_SPLITCHAR) !== -1) {
      for (const attr of _path.split(_SPLITCHAR)) {
        /** Access a Map */
        if (_obj instanceof Map) {
          _obj = _obj.get(attr);
        } else {
          /** Array or default Object */
          _obj = _obj[attr];
        }

        if (_obj == null && _default === _sentinel) {
          return null;
        } else if (_obj == null) {
          return _default;
        }
      }
    } else {
      /** Otherwise just return the Element */
      return _obj[_path];
    }
  }
  return _obj;
}

/**
 * Function to Set recursely a Attribute of an Object
 *
 * @author M.Karkowski
 * @export
 * @param {*} _data The Object, where the data should be stored
 * @param {string} _path The Path of the Attribute. All are seprated by a the splitchar. (Defaults to'.' => For Instance 'a.b.0.a.c')
 * @param {*} _value The Value which should be Stored in the Attribute.
 * @param {string} [_SPLITCHAR=SPLITCHAR] The Splitchar to use. Defaults to "."
 */
export function rsetattr(
  _data: any,
  _path: string,
  _value: any,
  _SPLITCHAR: string = SPLITCHAR
): void {
  let _obj = _data;

  const _ptrs = _path.split(_SPLITCHAR);

  _ptrs.slice(0, -1).forEach(function (attr: string, idx: number) {
    // Adapt the Object by going through a loop
    let _sub = _obj[attr];

    if (_sub === undefined || _sub === null) {
      // _obj is an Array and it doesnt contain the index

      // Extract the Next Element:
      const _next = _ptrs[idx + 1];

      const _next_is_int = isInt(_next);

      if (Array.isArray(_obj)) {
        if (_next_is_int) {
          _obj[attr] = new Array<any>();
        } else {
          _obj[attr] = {};
        }
      } else {
        if (_next_is_int) {
          _obj[attr] = [];
        } else {
          _obj[attr] = {};
        }
      }
      _sub = _obj[attr];
    }

    _obj = _sub;
  });
  _obj[_ptrs[_ptrs.length - 1]] = _value;
}

/**
 * Checks whether the Value is an Integer
 *
 * @export
 * @param {*} value Value to be checked
 * @returns {boolean} Result
 */
export function isInt(value: any): boolean {
  return parseInt(value) === value;
}

/**
 * Checks whether the Value is a Float
 *
 * @export
 * @param {*} value Value to be checked
 * @returns {boolean} Result
 */
export function isFloat(value: any): boolean {
  return !isNaN(Number(value));
}

/**
 * Copys the Object. Creates a Deep-Copy
 * of the Function
 *
 * @export
 * @param {*} value The value which should be copied
 * @returns {*} A Copy of the Value
 */
export function copy<T>(value: T): T {
  // TODO RING
  // const _copy = {};

  // /** Perform a Recursevly Foreach an Set an Attribute. */
  // recursiveForEach(value, '', (path: string, _data: any) => {
  //     rsetattr(_copy, path, _data);
  // });

  // return _copy;
  return JSON.parse(JSON.stringify(value));
}

/**
 * Function Converts a Object to a Map.
 *
 * @export
 * @param {*} _obj The Object which should be converted.
 * @returns {Map<string,any>}
 */
export function objectToMap(_obj: any): Map<string, any> {
  /** Define the Returntype */
  const _ret = new Map<string, any>();

  /** Iterate through all properties of the Object */
  for (const _prop of Object.getOwnPropertyNames(_obj)) {
    /** If isnt a function it could be added */
    if (typeof _obj !== "function") {
      _ret.set(_prop, _obj[_prop]);
    }
  }

  /** Return the Result */
  return _ret;
}

/**
 * Checks whether the Value is an Object
 *
 * @export
 * @param {*} value Data to Test
 * @returns {boolean} Flag showing whether the Presented Data is an Object
 */
export function isObject(value: any): boolean {
  /** Verify whether the value contains some data. */
  if (value) {
    if (typeof value === "object" && !Array.isArray(value)) {
      return Object.keys(value).length > 0;
    }
  }
  return false;
}

/**
 * Checks whether the Value is an Object
 *
 * @export
 * @param {*} value Data to Test
 * @returns {boolean} Flag showing whether the Presented Data is an Object
 */
export function isObjectOrArray(value: any): boolean {
  /** Verify whether the value contains some data. */
  return isObject(value) || Array.isArray(value);
}

/**
 * Flattens an Object to a Map.
 *
 * For Instance:
 *
 *      data = {a : { b : { c : 1, d: "hallo"}}}
 *
 *      // Normal Call
 *      res = flatteObject(data,'')
 *      => res = {"a.b.c":1,"a.b.d":"hallo"}
 *
 *      // With a Selected prefix 'additional.name'
 *      res = flatteObject(data,'additional.name')
 *      => res = {"additional.name.a.b.c":1,"additional.name.a.b.d":"hallo"}
 *
 * @export
 * @param {*} data The Data that should be converted
 * @param {string} [prefix=''] An additional prefix.
 * @returns {Map<string, any>} The flatten Object
 */
export function flattenObject(
  data: any,
  options: {
    prefix?: string,
    splitchar?: string,
    maxDepth?: number,
    onlyPathToSimpleValue?: boolean,
  }
    = {},
): Map<string, any> {

  const _options = Object.assign({
    prefix: "",
    splitchar: SPLITCHAR,
    onlyPathToSimpleValue: false,
    maxDepth: Infinity
  }, options);


  const _ret = new Map<string, any>();

  if (isObject(data) || Array.isArray(data)) {
    recursiveForEach(
      data,
      _options.prefix,
      (path, _data) => {
        _ret.set(path, _data);
      },
      _options.splitchar,
      _options.onlyPathToSimpleValue,
      _options.maxDepth
    );
  }
  return _ret;
}

/**
 * Function, that will iterate over an object. 
 * It will call the callback on every element.
 * 
 *
 * @author M.Karkowski
 * @export
 * @param {*} obj The Object to iterate
 * @param {string} [prefix=""] A prefix for the Path.
 * @param {(
 *     path: string,
 *     data: any,
 *     parent?: string,
 *     level?: number
 *   ) => void} dataCallback Callback, that will be called.
 * @param {string} [_SPLITCHAR=SPLITCHAR] The Splitchar to use, to generate the path
 * @param {boolean} [_callOnlyOnValues=true] A Flag, to start the 
 * @param {*} [_maxDepth=Infinity] Determine the max Depth, after which the Iteration will be stopped.
 * @param {string} [_parent=""] For Recursive call only
 * @param {number} [_level=0] For Recursive call only
 * @return {*}  {*}
 */
export function recursiveForEach(
  obj: any,
  prefix = "",
  dataCallback: (
    path: string,
    data: any,
    parent?: string,
    level?: number
  ) => void,
  _SPLITCHAR: string = SPLITCHAR,
  _callOnlyOnValues = true,
  _maxDepth = Infinity,
  _parent = "",
  _level = 0
): any {

  if (_level > _maxDepth) {
    return;
  }

  // Create an Array with the Keys.
  let keys = Array<string>();


  // Extract the keys of an object, but only if it isnt a 
  // string or function.
  if (typeof obj !== "string" && typeof obj !== "function") {
    keys = Object.getOwnPropertyNames(obj);
    if (Array.isArray(obj)) {
      keys.splice(keys.indexOf("length"), 1);
    }
  }

  let called = false;

  if (!_callOnlyOnValues) {
    // Store the Element !
    dataCallback(prefix, obj, _parent, _level);
    called = true;
  }

  // If there are Keys => It is a List or a Default Object
  if (keys.length > 0) {
    for (const _key of keys) {
      // Define the variable, containing the path
      const _str = prefix === "" ? _key : prefix + _SPLITCHAR + _key;

      if (obj[_key] != null) {
        // Test if there exist a specific function, which will convert the 
        // Object to JSON => if so, we use that function, otherwise we will
        // just proceed.
        if (typeof obj[_key].toJSON === "function") {
          const data = obj[_key].toJSON();
          // Recursive call this function.
          recursiveForEach(
            data,
            _str,
            dataCallback,
            _SPLITCHAR,
            _callOnlyOnValues,
            _maxDepth,
            prefix,
            _level + 1
          );
        } else {
          // Recursive call this function.
          recursiveForEach(
            obj[_key],
            _str,
            dataCallback,
            _SPLITCHAR,
            _callOnlyOnValues,
            _maxDepth,
            prefix,
            _level + 1
          );
        }
      }
    }
  } else if (!called) {
    // Store the Element !
    dataCallback(prefix, obj, prefix, _level);
  }
}

/**
 * Exports the used Types of an Object. The result is the 
 * a Map, where the key represents the path and the value
 * represents the type of the element (stored in the path)
 * 
 * @author M.Karkowski
 * @export
 * @param {*} data The Data to check
 * @param {{
 *   prefix?: string,
 *   splitchar?: string,
 *   maxDepth?: number,
 * }} [options={}]
 * @return {*}  {Map<string, string>} key = path; value = type of element;
 */
export function flattenObjectType(data: any, options: {
  prefix?: string,
  splitchar?: string,
  onlyPathToSimpleValue?: boolean,
  maxDepth?: number,
} = {},): Map<string, string> {

  // Options which will be used
  const _options = Object.assign({
    prefix: "",
    onlyPathToSimpleValue: false,
    splitchar: SPLITCHAR,
    maxDepth: Infinity
  }, options);

  const _ret = new Map<string, string>();

  if (isObject(data)) {
    recursiveForEach(data, _options.prefix, (path, _data) => {
      _ret.set(path, typeof _data);
    }, _options.splitchar, _options.onlyPathToSimpleValue, _options.maxDepth);
  }
  return _ret;
}

/**
 * Deflattens an Dict Based Object. The Object it self is represented 
 * as Map, whereas the Key represents the path.
 *
 *
 * @author M.Karkowski
 * @export
 * @param {Map<string, any>} _flattenObject
 * @return {*}  {*}
 */
export function deflattenObject(_flattenObject: Map<string, any>, options: {
  prefix?: string,
  splitchar?: string,
}): any {

  // Options which will be used
  const _options = Object.assign({
    prefix: "",
    splitchar: SPLITCHAR,
  }, options);
  const _ret = {};

  _flattenObject.forEach((_val: any, _key: string) => {
    // if there is a prefix, remove it:
    if (_options.prefix !== "") {
      _key = _key.slice(_options.prefix.length);
    }
    rsetattr(_ret, _key, _val, _options.splitchar);
  });

  return _ret;
}

/**
 * Function for deeply assigning
 *
 * @export
 * @param {*} target
 * @param {*} source
 * @returns
 */
export function deepAssign(target: any, source: any) {
  const flattend = flattenObject(source);

  for (const [path, value] of flattend.entries()) {
    rsetattr(target, path, value);
  }

  return target;
}

/**
 * Function to deeply clone the given object.
 *
 * @author M.Karkowski
 * @export
 * @template T
 * @param {T} obj
 * @return {*}  {T}
 */
export function deepClone<T>(obj: T): T {
  switch (typeof obj) {
    case "object": {
      const clone: any = Object.assign({}, obj);
      Object.keys(clone).forEach(
        (key) =>
        (clone[key] =
          typeof obj[key] === "object" ? deepClone(obj[key]) : obj[key])
      );
      return (Array.isArray(obj) && obj.length
        ? (clone.length = obj.length) && Array.from(clone)
        : Array.isArray(obj)
          ? Array.from(obj)
          : clone) as T;
    }
    default: {
      return obj;
    }

  }

}

// export const deepEqual: (a: any, b: any) => boolean = require('deep-equal');

/**
 * Function to adapt the Object and only return a specific amount of elements.
 * @param obj The Object itself
 * @param properties a list of properties/pathes to keep
 */
export function keepPropertiesOfObject(
  obj: any,
  properties: { [index: string]: () => any }
): any {
  if (isObject(obj)) {
    const ret: any = {};

    const defaultObj = { error: true };

    // Iterate over the Properties, get the content of the path, clone it an put it to the
    // provided path
    Object.getOwnPropertyNames(properties).map((path) => {
      const value = rgetattr(obj, path, defaultObj);
      rsetattr(
        ret,
        path,
        value !== defaultObj
          ? typeof value === "object"
            ? deepClone(value)
            : value
          : properties[path]()
      );
    });

    // Return the Object
    return ret;
  }

  // Wrong Datatype provided.
  throw TypeError("Function can only create Objects");
}