package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;

import java.nio.ByteBuffer;

import fj.data.List;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.IndexTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;

public class IndexJungleTreeEditor implements JungleTreeEditor {
  private final TransactionManager txManager;
  private final TreeNode root;
  private final IndexTreeEditor editor;
  private final TreeOperationLog log;
  private TreeMap<String, TreeMap<String, List<TreeNode>>> index;
  private TreeMap<TreeNode, TreeNode> parentIndex;

  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
    return index;
  }



  public IndexJungleTreeEditor(TreeNode _root, TransactionManager _txManager, IndexTreeEditor treeEditor,
      TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) {
    this(_root, _txManager, treeEditor, new DefaultTreeOperationLog(), index,parentIndex);
  }

  public IndexJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, IndexTreeEditor _editor,
      TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) {
    this.root = newNode;
    this.txManager = _txManager;
    this.editor = _editor;
    this.log = _log;
    this.index = index;
    this.parentIndex = parentIndex;
  }

  
  public Either<Error, IndexJungleTreeEditor> _edit(final NodePath _path, NodeEditor _e, IndexEditor indexEditor) {
    Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> either = editor.edit(root, _path, _e, parentIndex, indexEditor);
    if (either.isA()) {
      return DefaultEither.newA(either.a());
    }

    LoggingNode newLogging = either.b().getA();
    TreeMap<TreeNode,TreeNode> newParentIndex = either.b().getB();
    TreeMap<String,TreeMap<String,List<TreeNode>>> newIndex = either.b().getC();
    OperationLog newLog = newLogging.getOperationLog();
    TreeNode newNode = newLogging.getWrap();

    IterableConverter.Converter<TreeOperation, NodeOperation> converter = new IterableConverter.Converter<TreeOperation, NodeOperation>() {
      @Override
      public TreeOperation conv(NodeOperation _b) {
        return new DefaultTreeOperation(_path, _b);
      }
    };

    Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation, NodeOperation>(newLog, converter);
    DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable, newLog.length());
    TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
    IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, txManager, this.editor,newTreeOpLog, newIndex, newParentIndex);
    return DefaultEither.newB(newIndexTreeEditor);
  }

  @Override
  public Either<Error, JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) {
    AppendChildAt appendChildAt = new AppendChildAt(_pos);
    IndexEditor indexEditor = new DefaultIndexEditor(index);
    Either<Error, IndexJungleTreeEditor> either = _edit(_path, appendChildAt, indexEditor);
    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(either.b());
    return newEither;
  }

  @Override
  public Either<Error, JungleTreeEditor> deleteChildAt(NodePath _path, int _pos) {
    DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
    DeleteChildIndexEditor indexEditor = new DeleteChildIndexEditor(_pos, index);
    Either<Error, IndexJungleTreeEditor> either = _edit(_path, deleteChildAt, indexEditor);
    JungleTreeEditor editor = either.b();
    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
    return newEither;
  }

  @Override
  public Either<Error, JungleTreeEditor> putAttribute(NodePath _path, String _key, ByteBuffer _value) {
    PutAttribute putAttribute = new PutAttribute(_key, _value);
    IndexEditor indexEditor = new DefaultIndexEditor(index);
    Either<Error, IndexJungleTreeEditor> either = _edit(_path, putAttribute, indexEditor);
    JungleTreeEditor editor = either.b();
    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
    return newEither;
  }

  @Override
  public Either<Error, JungleTreeEditor> deleteAttribute(NodePath _path, String _key) {
    DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
    IndexEditor indexEditor = new DefaultIndexEditor(index);
    Either<Error, IndexJungleTreeEditor> either = _edit(_path, deleteAttribute, indexEditor);
    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(either.b());
    return newEither;
  }

  @Override
  public Either<Error, JungleTreeEditor> edit(NodePath _path, NodeEditor _editor) {
    IndexEditor indexEditor = new DefaultIndexEditor(index);
    Either<Error, IndexJungleTreeEditor> either = _edit(_path, _editor, indexEditor);
    JungleTreeEditor editor = either.b();
    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
    return newEither;
  }

  @Override
  public Either<Error, JungleTreeEditor> success() {
    Either<Error, TransactionManager> either = txManager.commit(root, log, index,parentIndex);
    if (either.isA()) {
      return DefaultEither.newA(either.a());
    }

    TransactionManager newTxManager = either.b(); 
    JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, newTxManager, editor, index,parentIndex);

    return DefaultEither.newB(newTreeEditor);
  }

  @Override
  public String getID() {
    return txManager.getUUID();
  }

  @Override
  public String getRevision() {
    return Long.toString(txManager.getRevision());
  }

  @Override
  public TreeNode getRoot() {
    return root;
  }

}