/// <reference path="immutability-helper.d.ts"/>

import * as update from 'immutability-helper';
import { newContext } from 'immutability-helper';

namespace TestObjectUpdate {
  update({}, {
    foo: {
      bar: { $set: 'baz' }
    }
  });
}

namespace TestArrayUpdate {
  update([], {
    foo: {
      bar: { $set: 'baz' }
    }
  });
}

namespace TestExtend {
  update.extend('$command', (specValue, originalValue) => originalValue);
}

namespace TestNewContext {
  update.newContext().extend('$command', (specValue, originalValue) => originalValue);
  newContext().extend('$command', (specValue, originalValue) => originalValue);

  // This shouldn't compile, but we can't test negatives.
  // newContext().newContext();

/**
 * Ensures that `state` has a series of nested objects matching the keys defined
 * in `path`.
 *
 * If any are missing, they will be built. The original `state` and its children
 * are **not** mutated.
 */
export default function ensurePath(value:{}, path:string[]):{} {
  if (!_.every(path, _.isString)) {
    throw new TypeError(`fillPath can only construct objects. Please pass string keys for the path.`);
  }

  // Fill in all missing keys along the path.
  let node:{} = value;
  for (let i = 0; i < path.length; i++) {
    let key = path[i];
    if (_.isUndefined(node[key])) {
      let missing    = _.reduce(path.slice(i).reverse(),    (s, k) => ({[k]: s}), {});
      let expression = _.reduce(path.slice(0, i).reverse(), (s, k) => ({[k]: s}), {$merge: missing});
      value = update(value, expression);
      break;
    }

    node = node[key];
  }

  return value;
}

  /**
   * Toggle the complete state of an item by.
   *
   * Will call updateItem function to update complete state of this item.
   */
  public toggleComplete(item: ITodoItem): Promise<ITodoItem[]> {
    // Create a new Item in which the PercentComplete value has been changed.
    const newItem: ITodoItem = update(item, {
      isComplete: { $set: item.isComplete === true ? false : true }
    });

    return new Promise<ITodoItem[]>((resolve, reject) => {
      const index: number =
        findIndex(
          this.items,
          (current: ITodoItem) => current.id === newItem.id
        );
      if (index !== -1) {
        this.items[index] = newItem;
        this.items = this.items.slice(0);
        resolve(this.items);
      } else {
        reject(new Error(`Item to update doesn't exist.`));
      }
    });
  }

/**
 * Similar to react-addons-update, except that it will ensure that any keys
 * leading up to the update expression are created (rather than throwing).
 *
 * For example:
 *
 *   deepUpdate(value, ['entities', 'currentUser'], {$set: {id: 'abc123'}});
 *
 */
function deepUpdate(value:{}, path:string[], spec:{}):{} {
  value = ensurePath(value, path);
  let expression = _.reduce([...path].reverse(), (s, k) => ({[k]: s}), spec);

  return update(value, expression);
}