"use strict";

/* eslint complexity: "OFF" */
const MethodChain = require("./MethodChain");

const ChainedMapBase = require("./ChainedMapBase");

const dopemerge = require("./deps/dopemerge");

const isFunction = require("./deps/is/function");

const isUndefined = require("./deps/is/undefined");

const isTrue = require("./deps/is/true");

const isMapish = require("./deps/is/mapish");

const ObjectKeys = require("./deps/util/keys");

const constructInit = require("./deps/fp/constructInit");

const EMPTY_OBJ = require("./deps/native/EMPTY_OBJ");

const SHORTHANDS_KEY = require("./deps/meta/SHORTHANDS_KEY");

const ENV_DEVELOPMENT = require("./deps/env/dev");

const ENV_DEBUG = require("./deps/env/debug");

const ON_EXISTING_KEY = 'onExisting';
const ON_VALUE_KEY = 'onValue';
const MERGER_KEY = 'merger';
const MERGER_OPTIONS_KEY = 'opts';
const OBJ_KEY = 'obj';
/**
 * @since 1.0.0
 * @type {Map}
 * @extends {ChainedMapBase}
 * @member MergeChain
 * @memberOf Chainable
 *
 * @types MergeChain
 * @tests MergeChain
 * @see deps/dopemerge
 *
 * {@link https://sourcemaking.com/design_patterns/visitor visitor-pattern}
 *
 * @TODO consider just making this a function,
 *       because 80/20 onValue merger & onExisting
 *       are rarely used & are easily overridable with .merge
 */

let MergeChain = class MergeChain extends ChainedMapBase {
  /**
   * @static
   * @param  {Chainable | ParentType} parent ParentType required, for merging
   * @return {MergeChain} @chainable
   *
   * @example
   *
   *    let map = new Map()
   *    map.set('eh', 1)
   *    map.set('coo', 'oo')
   *
   *    MergeChain.init(map).merge({eh: 2})
   *    console.dir(map)
   *    //=> Map { 'eh' => 2, 'coo' => 'oo' }
   *
   */
  // static init(parent) {
  //   return new MergeChain(parent)
  // }

  /**
   * @inheritdoc
   */
  constructor(parent) {
    super(parent);
    /* prettier-ignore */

    this.extend([ON_EXISTING_KEY, ON_VALUE_KEY, OBJ_KEY]).set(ON_VALUE_KEY, () => true).set(MERGER_KEY, dopemerge);
  }
  /**
   * @desc options for merging with dopemerge
   *       @modifies this.merger | this.opts
   *
   * @memberOf MergeChain
   * @since 1.0.2
   * @param  {Object | Function} opts when object: options for the merger. when function: is the merger
   * @return {MergeChain} @chainable
   * @see dopemerge
   *
   * @example
   *   {
   *     stringToArray: true,
   *     boolToArray: false,
   *     boolAsRight: true,
   *     ignoreTypes: ['null', 'undefined', 'NaN'],
   *     debug: false,
   *   }
   *
   * @example
   *    .merger(require('lodash.mergewith')())
   */


  merger(opts) {
    if (isFunction(opts)) return this.set(MERGER_KEY, opts);else return this.set(MERGER_OPTIONS_KEY, opts);
  } // [v] messes comments on conditional brace style

  /* prettier-ignore */

  /**
   * @desc merges object in, goes through all keys, checks cbs, dopemerges
   *
   * @since 1.0.0
   *
   * @param  {Object} [obj2=undefined] object to merge in, defaults to this.get('obj')
   * @return {MergeChain} @chainable
   *
   * @see ChainedMap
   * @TODO issue here if we extend without shorthands &
   *       we want to merge existing values... :s
   *
   *
   * @example
   *
   *  const chain = new Chain()
   *  chain.merge({canada: {eh: true}})
   *  chain.merge({canada: {arr: [0, {'1': 2}], eh: {again: true}}})
   *  chain.entries()
   *  //=> {canada:{ eh: {again: true}, arr: [0, {'1': 2}] }}
   *
   */


  merge(obj2) {
    // better uglifying
    const parent = this.parent;

    const get = key => this.get(key);

    const onExisting = get(ON_EXISTING_KEY);
    const onValue = get(ON_VALUE_KEY);
    const opts = get(MERGER_OPTIONS_KEY);
    const obj = obj2 || get(OBJ_KEY);
    const merger = get(MERGER_KEY);
    const shorthands = parent.meta ? parent.meta(SHORTHANDS_KEY) : EMPTY_OBJ;
    const keys = ObjectKeys(obj); // @@debugger

    /* istanbul ignore next: devs */

    if (ENV_DEVELOPMENT) {
      if (!obj) {
        console.log({
          onExisting,
          opts,
          obj,
          merger,
          shorthands,
          keys,
          parent
        });
        throw new Error('must provide an object to merge');
      }
    }
    /**
     * @private
     *
     * since this would be slower
     * if I want to not have a speedy default when using .onExisting
     * should @note to use .extend
     * when using chains without a class & doing .merge (edge-case)
     *
     * @param  {Primitive} key key (shorthands[key] or just key)
     * @param  {*} value obj[key]
     * @return {void}
     *
     * @TODO could use .eq here
     * @TODO if (isMapish(obj)) obj = obj.entries()
     *
     * @example
     *  var obj = {key: 1}
     *
     *  MergeChain.init(obj).merge({key: ['value']})
     *
     *  // goes to this internal scoped function
     *  handleExisting('key', ['value'])
     *  // if there is .onValue or .onExisting, use them, default deepmerge
     *
     *  obj
     *  //=> {key: [1, 'value']}
     *
     */


    const handleExisting = (key, value) => {
      /**
       * @desc when fn is a full method, not an extended shorthand
       * @since 0.5.0
       *
       * @param {Primitive} keyToSet key we chose to set
       * @param {*} valueToSet value we chose to set (merged, existing, new)
       * @return {Parent | Chain | *} .set or [keyToSet] return
       *
       * @example
       *
       *    MergeChain.init(new Chain().extend(['eh']))
       *
       *    //isFunction: true => call parent[keyToSet](valueToSet)
       *    setChosen('eh', 1)
       *    //=> parent
       *    parent.get('eh')
       *    //=> 1
       *
       *    //=>isFunction: false => parent.set(keyToSet, valueToSet)
       *    setChosen('oh', 1)
       *    //=> parent //<- unless .set is overriden
       *    parent.get('oh')
       *    //=> 1
       *
       */
      const setChosen = (keyToSet, valueToSet) => isFunction(parent[key]) ? parent[keyToSet](valueToSet) : parent.set(keyToSet, valueToSet);
      /**
       * check if it's shorthanded
       * -> check if it has a value already
       */


      if (isTrue(parent.has(key))) {
        // get that value
        const existing = parent.get(key);
        /**
         * if we have onExisting, call it
         * else default to dopemerge
         */

        if (isUndefined(onExisting)) {
          /* istanbul ignore next: devs */
          if (ENV_DEBUG) {
            console.log('parent has: no onExisting', {
              existing,
              [key]: value
            });
          }

          setChosen(key, merger(existing, value, opts));
        } else {
          /* istanbul ignore next: devs */
          if (ENV_DEBUG) {
            console.log('parent has: has onExisting', {
              existing,
              onExisting,
              [key]: value
            });
          }
          /**
           * maybe we should not even have `.onExisting`
           * since we can just override merge method...
           * and then client can just use a custom merger...
           *
           * could add and remove subscriber but that's overhead and
           * tricky here, because if we set a value that was just set...
           */


          setChosen(key, onExisting(existing, value, opts));
        }
      } else {
        /* istanbul ignore next: devs */
        if (ENV_DEBUG) {
          console.log('parent does not have', {
            [key]: value
          });
        }

        setChosen(key, value);
      }
    };

    for (let k = 0, len = keys.length; k < len; k++) {
      // key to the current property in the data being merged
      let key = keys[k]; // we have our value, no we can change the key if needed for shorthands

      const value = obj[key]; // @NOTE: when shorthands is an object, key is the method it should call

      if (!isUndefined(shorthands[key]) && shorthands[key] !== key) {
        /* istanbul ignore next: devs */
        if (ENV_DEBUG) {
          console.log('had a shorthand with a diff key than the object (likely @alias)', {
            shorthandMethod: shorthands[key],
            key,
            value
          });
        }

        key = shorthands[key];
      } // method for the key


      const method = parent[key];
      /* istanbul ignore next: sourcemaps trigger istanbul here incorrectly */
      // use onValue when set

      if (!onValue(value, key, this)) {
        /* istanbul ignore next: devs */
        if (ENV_DEBUG) {
          console.log('had onValue, was false, ignored', {
            onValue,
            key,
            value
          });
        }

        continue;
      } // when property itself is a Chainable
      else if (isMapish(method)) {
          /* istanbul ignore next: devs */
          if (ENV_DEBUG) {
            console.log('has method or shorthand');
          }

          parent[key].merge(value);
        } // we have a method or shorthand
        else if (method) {
            /* istanbul ignore next: devs */
            if (ENV_DEBUG) {
              console.log('has method or shorthand', {
                method,
                key,
                value
              });
            }

            handleExisting(key, value);
          } // default to .set on the store
          else {
              /* istanbul ignore next: devs */
              if (ENV_DEBUG) {
                console.log('went to default', {
                  method,
                  key,
                  value
                });
              }

              parent.set(key, value);
            }
    }

    return parent;
  }

};
constructInit(MergeChain);
/**
 * @memberOf MergeChain
 * @method onExisting
 * @since 0.9.0
 * @example
 *
 *    const {Chain, MergeChain} = require('chain-able')
 *
 *    const chain = new Chain().set('str', 'stringy')
 *
 *    MergeChain.init(chain)
 *      .onExisting((a, b) => a + b)
 *      .merge({str: '+'})
 *
 *    chain.get('str')
 *    //=> 'stringy+'
 *
 */

module.exports = MergeChain; // @TODO re-enable this later
// module.exports = new MethodChain(MergeChain.prototype)
//   .methods(['onExisting', 'onValue', 'obj'])
//   .build(MergeChain)