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

import jp.ac.u_ryukyu.ie.cr.jungle.store.NulIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
import jp.ac.u_ryukyu.ie.cr.jungle.query.PathNodeIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.query.Query;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.IndexCreater;
import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;

import java.util.Iterator;
import java.util.Optional;

public class InterfaceTraverser {

    TreeNode root;
    TreeMap<String, TreeMap<String, List<TreeNode>>> indexList;
    ParentIndex parentIndex;
    boolean parentUpdateFlag;
    boolean useIndex;

    public InterfaceTraverser(TreeNode root, boolean indexFlag) {
        this(root, new TreeMap<>(), new ParentIndex(), indexFlag);
    }

    public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
                              ParentIndex parentIndex, boolean useIndex) {
        this.root = root;
        this.indexList = index;
        this.parentIndex = parentIndex;
        if (parentIndex.isEmpty())
            parentUpdateFlag = true;
        else
            parentUpdateFlag = false;
        this.useIndex = useIndex;
    }

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

    public void commit() {
        parentUpdateFlag = false;
    }

    public ParentIndex getParentIndex() {
        return parentIndex;
    }

    public void createIndex() {
        // long t1 = System.currentTimeMillis();
        IndexCreater creater = new IndexCreater(root);
        // long t2 = System.currentTimeMillis();
        // System.out.println("createIndex time = " + (t2 - t1));
        indexList = creater.getIndex();
        parentIndex = creater.getParentIndex();
    }

    /**
     * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う
     *
     * @param query
     * @param subTree
     * @param key
     * @param searchValue
     * @return
     */
    // public Iterator<TreeNode> findInSubTree(final Query query, TreeNode
    // subTree, String key, String searchValue) {
    // /*
    // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
    // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
    // */
    // Iterator<TreeNode> nodeIterator = index.get(key, searchValue);
    // if (nodeIterator.hasNext() && useIndex) {
    //
    // // ここでNode以下にあるか調べる
    // List<TreeNode> filteredList = List.nil();
    //
    // for (;nodeIterator.hasNext();) {
    // TreeNode targetNode = nodeIterator.next();
    // TreeNode parent = targetNode;
    // while (parent != null) {
    // parent = parentIndex.get(parent);
    // if (parent.equals(subTree))
    // filteredList = filteredList.cons(targetNode);
    // }
    // }
    //
    // return filteredList.iterator();
    //
    // } else {
    // final PathNodeIterator itNode = new PathNodeIterator(subTree);
    // return new Iterator<TreeNode>() {
    //
    // private TreeNode matchNode = nextmatch(itNode);
    //
    // private TreeNode nextmatch(PathNodeIterator itNode) {
    //
    // for (; itNode.hasNext();) {
    // TreeNode targetNode = itNode.next();
    // if (query.condition(targetNode))
    // return targetNode;
    // }
    // return null;
    // }
    //
    // @Override
    // public boolean hasNext() {
    // if (matchNode == null) {
    // return false;
    // }
    // return true;
    // }
    //
    // @Override
    // public TreeNode next() {
    // TreeNode currentNode = matchNode;
    // matchNode = nextmatch(itNode);
    // return currentNode;
    // }
    //
    // @Override
    // public void remove() {
    // }
    //
    // };
    // }
    // }

    /**
     * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する
     */
    // public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode
    // subTree, String key) {
    // /*
    // * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
    // * そのKeyを保有するNodeとNodeのPathを取得する
    // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
    // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
    // */
    // Iterator<TreeNode> NodeIterator = index.getAll(key);
    // if (NodeIterator != null && useIndex) {
    // List<TreeNode> filteredList = List.nil();
    // for (; NodeIterator.hasNext();) {
    // TreeNode targetNode = NodeIterator.next();
    // TreeNode parent = targetNode;
    // while (parent != null) {
    // parent = parentIndex.get(parent);
    // if (parent.equals(subTree))
    // filteredList = filteredList.cons(targetNode);
    // }
    // }
    // return filteredList.iterator();
    //
    // } else {
    //
    // final PathNodeIterator itNode = new PathNodeIterator(subTree);
    // return new Iterator<TreeNode>() {
    //
    // private TreeNode matchPair = nextmatch(itNode);
    //
    // private TreeNode nextmatch(PathNodeIterator itNode) {
    //
    // for (; itNode.hasNext();) {
    // TreeNode targetNode = itNode.next();
    // if (query.condition(targetNode))
    // return targetNode;
    // }
    // return null;
    // }
    //
    // @Override
    // public boolean hasNext() {
    // if (matchPair == null) {
    // return false;
    // }
    // return true;
    // }
    //
    // @Override
    // public TreeNode next() {
    // TreeNode currentNode = matchPair;
    // matchPair = nextmatch(itNode);
    // return currentNode;
    // }
    //
    // @Override
    // public void remove() {
    // }
    //
    // };
    // }
    // }
    private TreeNode nextmatch(TreeNode node, Query query) {
        if (query.condition(node))
            return node;
        return null;
    }


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

        Iterator<TreeNode> nodeIterator;
        if (key != null && searchValue != null && useIndex) {
            nodeIterator = get(key, searchValue);
            ;
        } else {
            nodeIterator = new PathNodeIterator(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);
                }
                return currentPair;
            }

            @Override
            public void remove() {
            }

        };
    }

    // public Iterator<TreeNode> findAll(final Query query, final String key) {
    //
    // Iterator<TreeNode> nodeList = index.getAll(key);
    // if (nodeList != null && useIndex) {
    //
    // return nodeList;
    //
    // } else {
    //
    // final PathNodeIterator itNode = new PathNodeIterator(node);
    // return new Iterator<TreeNode>() {
    //
    // private TreeNode matchNode = nextmatch(itNode);
    //
    // private TreeNode nextmatch(PathNodeIterator itNode) {
    //
    // for (; itNode.hasNext();) {
    // TreeNode targetNode = itNode.next();
    // String value = targetNode.getAttributes().getString(key);
    // if (useIndex) {
    // if (value != null)
    // index = index.set(key, value, targetNode);
    // }
    // if (parentUpdateFlag);
    // // parentIndex = parentIndex.set(targetNode);
    // if (query.condition(targetNode))
    // return targetNode;
    // }
    // if (useIndex || parentUpdateFlag)
    // commit();
    // return null;
    // }
    //
    // @Override
    // public boolean hasNext() {
    // if (matchNode == null) {
    // return false;
    // }
    // return true;
    // }
    //
    // @Override
    // public TreeNode next() {
    // TreeNode currentPair = matchNode;
    // matchNode = nextmatch(itNode);
    // return currentPair;
    // }
    //
    // @Override
    // public void remove() {
    // }
    //
    // };
    // }
    // }

    public Iterator<TreeNode> get(String key, String value) {
        Optional<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
        if (!indexOp.isPresent())
            return null;

        Optional<List<TreeNode>> nodeListOp = indexOp.get().get(value);
        if (!nodeListOp.isPresent())
            return new NulIterator<TreeNode>();

        return nodeListOp.get().iterator();
    }
}