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.Query;
import jp.ac.u_ryukyu.ie.cr.jungle.query.traverser.nodeiterator.DefaultNodeIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.query.traverser.nodeiterator.RedBlackTreeNodeIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.Index;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;

import java.util.Iterator;


public class RedBlackTreeInterfaceTraverser implements InterfaceTraverser {
    private TreeNode root;

    public RedBlackTreeInterfaceTraverser(TreeNode root) {
        this.root = root;
    }

    @Override
    public Index getIndex() {
        return null; //使わない 赤黒木は自身がIndexなので、特別なIndexは無い
    }

    @Override
    public ParentIndex getParentIndex() {
        return null; // 上に同じ、回転処理で構造が変わるため、自身の木構造でデータを表現しない、つまり親を知る必要はない
    }

    @Override
    public void createIndex() { // 上に同じ Indexを張る必要はない
    }

    @Override
    public void updateIndex(List<TreeNode> editedNodeList) { //上に同じ

    }

    @Override
    public void updateIndex(TreeNode subTreeRoot) { //上に同じ

    }

    @Override
    public Iterator<TreeNode> find(Query query) { //balanceKeyを使わない場合全探索なのでDefaultInterfaceTraverserと変わらない
        Iterator<TreeNode> 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() {
            }

        };
    }

    @Override
    public Iterator<TreeNode> find(Query query, String key, String searchValue) {
        Iterator<TreeNode> nodeIterator = new RedBlackTreeNodeIterator(root,key,searchValue);
        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() {
            }

        };
    }

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