package jp.ac.u_ryukyu.ie.cr.jungle.query.traverser;

import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
import jp.ac.u_ryukyu.ie.cr.jungle.query.traverser.nodeiterator.DefaultNodeIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.query.Query;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.Index;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.IndexCreater;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.IndexUpdater;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;

import java.util.Iterator;

public class DefaultInterfaceTraverser implements InterfaceTraverser {

    private TreeNode root;
    private Index index;
    private ParentIndex parentIndex;
    private boolean useIndex;

    public DefaultInterfaceTraverser(TreeNode root, boolean indexFlag) {
        this(root, new Index(), new ParentIndex(), indexFlag);
    }

    public DefaultInterfaceTraverser(TreeNode root, Index index, ParentIndex parentIndex, boolean useIndex) {
        this.root = root;
        this.index = index;
        this.parentIndex = parentIndex;
        this.useIndex = useIndex;
    }

    @Override
    public Index getIndex() {
        return index;
    }


    @Override
    public ParentIndex getParentIndex() {
        return parentIndex;
    }

    @Override
    public void createIndex() {
        IndexCreater creater = new IndexCreater(root);
        index = creater.getIndex();
        parentIndex = creater.getParentIndex();
    }

    @Override
    public void updateIndex(List<TreeNode> editedNodeList) {
        IndexUpdater indexUpdater = new IndexUpdater(root, index, parentIndex);
        Pair<Index, ParentIndex> p = indexUpdater.update(editedNodeList);
        index = p.left();
        parentIndex = p.right();
    }

    /**
     * 差分Treeで使う 差分Treeは一度作った木は変更しないのでIndexの中身を削除する必要はない
     * なのでputだけで良い
     */
    @Override
    public void updateIndex(TreeNode subTreeRoot) {
        IndexUpdater indexUpdater = new IndexUpdater(subTreeRoot, index, parentIndex);
        Pair<Index, ParentIndex> p = indexUpdater.update();
        index = p.left();
        parentIndex = p.right();
    }

    /**
     * public void updateIndex(List<TreeNode> editedNodeList,TreeNode subTreeNode) {
     * IndexUpdater indexUpdater = new IndexUpdater(subTreeNode,index,parentIndex);
     * Pair<Index,ParentIndex> p = indexUpdater.update(editedNodeList);
     * index = p.left();
     * parentIndex = p.right();
     * }
     **/

    private TreeNode nextmatch(TreeNode node, Query query) {
        if (query.condition(node))
            return node;
        return null;
    }

    @Override
    public Iterator<TreeNode> find(final Query query) {
        return find(query, null, null);
    }

    @Override
    public Iterator<TreeNode> find(final Query query, final String key, String searchValue) {

        Iterator<TreeNode> nodeIterator;
        if (key != null && searchValue != null && useIndex) {
            nodeIterator = index.get(key, searchValue);
            ;
        } else {
            nodeIterator = new DefaultNodeIterator(root);
        }

        TreeNode firstMatchNode = null;
        for (; nodeIterator.hasNext(); ) {
            firstMatchNode = nextmatch(nodeIterator.next(), query);
            if (firstMatchNode != null)
                break;
        }

        final TreeNode finalFirstMatchNode = firstMatchNode;

        return new Iterator<TreeNode>() {

            TreeNode matchNode = finalFirstMatchNode;

            @Override
            public boolean hasNext() {
                if (matchNode == null) {
                    return false;
                }
                return true;
            }

            @Override
            public TreeNode next() {
                TreeNode currentPair = matchNode;
                for (; nodeIterator.hasNext(); ) {
                    matchNode = nextmatch(nodeIterator.next(), query);
                    if (matchNode != null)
                        return currentPair;
                }
                matchNode = null;
                return currentPair;
            }

            @Override
            public void remove() {
            }

        };
    }
}