/* An actor that modifies record tokens.
 * 
 * Copyright (c) 2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-08-26 21:01:58 +0000 (Wed, 26 Aug 2015) $' 
 * '$Revision: 33647 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */
package org.kepler.actor;

import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import ptolemy.actor.TypedAtomicActor;
import ptolemy.actor.TypedIOPort;
import ptolemy.data.RecordToken;
import ptolemy.data.Token;
import ptolemy.data.expr.Parameter;
import ptolemy.data.expr.StringParameter;
import ptolemy.data.type.BaseType;
import ptolemy.data.type.MonotonicFunction;
import ptolemy.data.type.RecordType;
import ptolemy.data.type.Type;
import ptolemy.graph.Inequality;
import ptolemy.graph.InequalityTerm;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.Attribute;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.SingletonAttribute;

/**
 * An actor that modifies the contents of record tokens. The token to
 * be modified is read in the <i>input</i> port. The <i>path</i> parameter
 * specifies the path within the input record token to modify. The format
 * of the path starts with <code>root</code> and contains the name of each
 * nested label within the record token. For example, if the input record
 * is <code>{a={b={c=1}}}</code>, the path to the <code>c</code> field is
 * is <code>root.a.b.c</code>. The <i>value</i> input specifies a token
 * to add or replace at the specified path in the input token.
 * <p> This actor supports the following operations:
 * <ul>
 * <li>add<p>The token in <i>value</i> is added to the input token at the
 * path described by <i>path</i>.
 * </li>
 * <li>extract<p>The part of the input token described by the <i>path</i> is
 * output.
 * </li>
 * <li>remove<p>The part of input token described by the <i>path</i>
 * is removed.</p>
 * </li>
 * <li>replace<p>The part of the input token described by the <i>path</i>
 * is replaced with the contents read from <i>value</i>.</p>
 * </li>
 * </ul>
 * 
 * @author Philippe Huynh, Daniel Crawl
 * @version $Id: RecordOperation.java 33647 2015-08-26 21:01:58Z crawl $
 * 
 */
public class RecordOperation extends TypedAtomicActor {

    public RecordOperation(CompositeEntity container, String name)
            throws NameDuplicationException, IllegalActionException {
        super(container, name);

        path = new StringParameter(this, "path");
        path.setExpression("root");

        input = new TypedIOPort(this, "input", true, false);
        new SingletonAttribute(input, "_showName");

        value = new TypedIOPort(this, "value", true, false);
        new SingletonAttribute(value, "_showName");

        output = new TypedIOPort(this, "output", false, true);
        new SingletonAttribute(output, "_showName");

        operation = new StringParameter(this, "operation");
        operation.addChoice("add");
        operation.addChoice("extract");
        operation.addChoice("remove");
        operation.addChoice("replace");
        operation.setExpression(_operationValue);
    }

    @Override
    public void attributeChanged(Attribute attribute) throws IllegalActionException {
        if (attribute == operation) {
            String valueStr = operation.getExpression();

            if (valueStr.equals("add") ||
                    valueStr.equals("extract") ||
                    valueStr.equals("remove") ||
                    valueStr.equals("replace")) {
                _operationValue = valueStr;
            } else {
                throw new IllegalActionException(this, "Unknown type of updateChoice: " + value);
            }
        } else {
            super.attributeChanged(attribute);
        }
    }

    @Override
    public void fire() throws IllegalActionException {
        
        super.fire();
        String recPathValue = path.getExpression();
        RecordToken recInValue = (RecordToken) input.get(0);
        RecordToken recValue = null;

        // System.out.println("input
        // record:"+recInValue+":path:"+recPathValue+":choice:"+_updateChoiceValue);

        if(value.numberOfSources() > 0) {
            Token token = value.get(0);
            if (_operationValue.equals("add") || _operationValue.equals("replace")) {
                recValue = (RecordToken) token;
            }
        }
        
        SimpleEntry<String, Token> rootse =
                new SimpleEntry<String, Token>("root", RecordToken.NIL);
        TreeNode<SimpleEntry<String, Token>> root =
                new TreeNode<SimpleEntry<String, Token>>(rootse);
        _createTree(recInValue, root);
        if(_debugging) {
            _printTree(root);
        }

        // Searching the concerned node
        String[] pathArray = recPathValue.split("\\.");
        TreeNode<SimpleEntry<String, Token>> targetNode = root;
        for (int i = 0; i < pathArray.length; i++) {
            // System.out.println("path:"+ pathArray[i]);
            final String refEntry = pathArray[i];
            Comparable<SimpleEntry<String, Token>> searchKey = new Comparable<SimpleEntry<String, Token>>() {
                @Override
                public int compareTo(SimpleEntry<String, Token> treeData) {
                    if (treeData == null) {
                        return 1;
                    }
                    return treeData.getKey().compareTo(refEntry);
                }
            };
            targetNode = targetNode.findTreeNode(searchKey);
            if (targetNode == null) {
                throw new IllegalActionException(this, "Search path is incorrect!");
            } else {
                // System.out.println("targetNode:"+targetNode.data.getKey());
            }
        }
        // remove option
        if (_operationValue.equals("remove")) {
            targetNode.parent.delete(targetNode);
        }
        // add option
        else if (_operationValue.equals("add")) {
            if (targetNode.isLeaf()) {
                throw new IllegalActionException(this, "Search path is incorrect!, try with an upper level path");
            } else {
                _createTree(recValue, targetNode);
            }
        }
        // replace option
        else if (_operationValue.equals("replace")) {
            if (!(recPathValue.equals("root"))) {
                TreeNode<SimpleEntry<String, Token>> parentNode = targetNode.parent;
                targetNode.parent.delete(targetNode);
                _createTree(recValue, parentNode);
            } else {
                root = new TreeNode<SimpleEntry<String, Token>>(rootse);
                _createTree(recValue, root);
            }
        }
        // extract option
        else if (_operationValue.equals("extract")) {
            if (targetNode.isLeaf()) {
                String[] labels = new String[1];
                Token[] values = new Token[1];
                labels[0] = targetNode.data.getKey();
                values[0] = targetNode.data.getValue();
                RecordToken newToken = new RecordToken(labels, values);
                targetNode.data.setValue(newToken);
            }
            root = targetNode;
            root.parent = null;
        }

        // printTree(root);
        _createRecord(root);
        // System.out.println("final record:"+root.data.getValue());
        // RecordReviserFunction A=new RecordReviserFunction();
        // System.out.println("MinimalOutputTerm:"+A.getValue());
        output.send(0, (RecordToken) root.data.getValue());
    }
    
    @Override
    public void preinitialize() throws IllegalActionException {
        super.preinitialize();

        // if operation is add or replace, make sure portValue is connected.
        if (_operationValue.equals("add") || _operationValue.equals("replace")) {
            if (value.numberOfSources() == 0) {
                throw new IllegalActionException(this,
                        "Input port portValue must be connected for add or replace operations.");
            }
        }

    }

    ///////////////////////////////////////////////////////////////////
    //// public fields ////

    /** The record token to operate on. */
    public TypedIOPort input;

    /** The value to add or replace in the input. */
    public TypedIOPort value;

    /** The resulting record token. */
    public TypedIOPort output;

    /** The path to operate on. */
    public Parameter path;

    /**
     * The operation to perform: add, extract, remove, or replace. <b>NOTE:</b>
     * Do not change while the workflow is executing.
     */
    public Parameter operation;

    ///////////////////////////////////////////////////////////////////
    //// protected methods ////

    /** Return custom type constraints specified by the RecordOperationFunction
     *  class.
     */
    @Override
    protected Set<Inequality> _customTypeConstraints() {
        Set<Inequality> result = new HashSet<Inequality>();
        result.add(new Inequality(new RecordOperationFunction(), output.getTypeTerm()));
        return result;
    }

    /** Returns null since we define custom type constraints. */
    @Override
    protected Set<Inequality> _defaultTypeConstraints() {
        return null;
    }

    ///////////////////////////////////////////////////////////////////
    //// private methods ////

    private void _createTree(RecordToken rec, TreeNode<SimpleEntry<String, Token>> node) {
        for (String name : rec.labelSet()) {
            Token token = rec.get(name);
            if (token instanceof RecordToken) {
                TreeNode<SimpleEntry<String, Token>> child = node
                        .addChild(new SimpleEntry<String, Token>(name, RecordToken.NIL));
                _createTree((RecordToken) token, child);
            } else {
                node.addChild(new SimpleEntry<String, Token>(name, token));
            }
        }
    }

    private void _createRecord(TreeNode<SimpleEntry<String, Token>> tempRoot) throws IllegalActionException {

        if (tempRoot.isLeaf()) {
            return;
        }
        List<TreeNode<SimpleEntry<String, Token>>> listOfLeaf = new ArrayList<TreeNode<SimpleEntry<String, Token>>>();

        for (TreeNode<SimpleEntry<String, Token>> node : tempRoot) {
            if (node.isLeaf()) {
                listOfLeaf.add(node);
            }
            // System.out.println("loop
            // leaf:"+node.data.getKey()+":"+node.data.getValue());
        }
        // System.out.println("number of leaf:"+listOfLeaf.size());

        for (TreeNode<SimpleEntry<String, Token>> next : listOfLeaf) {
            String[] labels = { next.data.getKey() };
            Token[] values = { next.data.getValue() };
            RecordToken token = new RecordToken(labels, values);
            // System.out.println(token+"parent:"+next.parent.data.getValue());
            if (next.parent.data.getValue() == RecordToken.NIL) {
                next.parent.data.setValue(token);
                // System.out.println("NIL");
            } else {
                next.parent.data.setValue(RecordToken.merge((RecordToken) next.parent.data.getValue(), token));
                // System.out.println("MERGE:"+next.parent.data.getValue());
            }
            next.parent.delete(next);
        }
        _createRecord(tempRoot);
    }
    
    private void _printTree(TreeNode<SimpleEntry<String, Token>> treeRoot) {

        for (TreeNode<SimpleEntry<String, Token>> node : treeRoot) {
            String indent = _createIndent(node.getLevel());
            _debug(indent + node.data.getKey() + " " + node.data.getValue());
        }
    }
    
    private String _createIndent(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("Level" + i + ":  ");
        }
        return sb.toString();
    }

    /** A class to set the port types. */
    private class RecordOperationFunction extends MonotonicFunction {

        private void _createTypeTree(RecordType rec, TreeNode<SimpleEntry<String, Type>> node) {
            for (String name : (Set<String>) (rec.labelSet())) {
                Type type = rec.get(name);
                if (type instanceof RecordType) {
                    TreeNode<SimpleEntry<String, Type>> child = node
                            .addChild(new SimpleEntry<String, Type>(name, RecordType.EMPTY_RECORD));
                    _createTypeTree((RecordType) type, child);
                } else {
                    node.addChild(new SimpleEntry<String, Type>(name, type));
                }
            }
        }

        private void _createTypeRecord(TreeNode<SimpleEntry<String, Type>> tempRoot) throws IllegalActionException {

            if (tempRoot.isLeaf()) {
                return;
            }
            List<TreeNode<SimpleEntry<String, Type>>> listOfLeaf = new ArrayList<TreeNode<SimpleEntry<String, Type>>>();

            for (TreeNode<SimpleEntry<String, Type>> node : tempRoot) {
                if (node.isLeaf()) {
                    listOfLeaf.add(node);
                }
                // System.out.println("loop
                // leaf:"+node.data.getKey()+":"+node.data.getValue());
            }
            // System.out.println("number of leaf:"+listOfLeaf.size());
            for (TreeNode<SimpleEntry<String, Type>> next : listOfLeaf) {
                String[] labels = { next.data.getKey() };
                Type[] values = { next.data.getValue() };
                RecordType type = new RecordType(labels, values);
                // System.out.println(token+"parent:"+next.parent.data.getValue());
                if (next.parent.data.getValue() == RecordType.EMPTY_RECORD) {
                    next.parent.data.setValue(type);
                    // System.out.println("NIL");
                } else {
                    // System.out.println("MERGE");
                    next.parent.data.setValue(_mergeTypeRecord((RecordType) next.parent.data.getValue(), type));
                }
                next.parent.delete(next);
            }
            _createTypeRecord(tempRoot);
        }

        private RecordType _mergeTypeRecord(RecordType a, RecordType b) {

            Map<String, Type> fields = new HashMap<String, Type>();

            for (String label : (Set<String>) a.labelSet()) {
                fields.put(label, a.get(label));
            }
            for (String label : (Set<String>) b.labelSet()) {
                fields.put(label, b.get(label));
            }
            return new RecordType(fields.keySet().toArray(new String[fields.size()]),
                    fields.values().toArray(new Type[fields.size()]));
        }

        /*
         * private void _printTypeTree(TreeNode<SimpleEntry<String,Type>>
         * treeRoot) {
         * 
         * for (TreeNode<SimpleEntry<String,Type>> node : treeRoot) { String
         * indent = _createIndent(node.getLevel()); System.out.println(indent +
         * node.data.getKey()+" "+ node.data.getValue()); } }
         */

        /**
         * Return the function result.
         * 
         * @return A Type.
         */
        @Override
        public Object getValue() throws IllegalActionException {

            String recPathValue = path.getExpression();
            RecordType recInType;
            RecordType recValue = null;

            if (!(input.getType() instanceof RecordType)) {
                return BaseType.UNKNOWN;
            }
            recInType = (RecordType) input.getType();

            if (_operationValue.equals("add") || _operationValue.equals("replace")) {
                if (!(value.getType() instanceof RecordType)) {
                    return BaseType.UNKNOWN;
                }
                recValue = (RecordType) value.getType();
            }

            SimpleEntry<String, Type> rootse = new SimpleEntry<String, Type>("root", RecordType.EMPTY_RECORD);
            TreeNode<SimpleEntry<String, Type>> root = new TreeNode<SimpleEntry<String, Type>>(rootse);
            _createTypeTree(recInType, root);
            // _printTypeTree(root);

            // Searching the concerned node
            String[] pathArray = recPathValue.split("\\.");
            TreeNode<SimpleEntry<String, Type>> targetNode = root;
            // TreeNode<SimpleEntry<String,Type>> targetNodeold;
            for (int i = 0; i < pathArray.length; i++) {
                // targetNodeold = targetNode;
                // System.out.println("path:"+ pathArray[i]);
                final String refEntry = pathArray[i];
                Comparable<SimpleEntry<String, Type>> searchKey = new Comparable<SimpleEntry<String, Type>>() {
                    @Override
                    public int compareTo(SimpleEntry<String, Type> treeData) {
                        if (treeData == null) {
                            return 1;
                        }
                        return treeData.getKey().compareTo(refEntry);
                        // boolean nodeOk =
                        // (treeData.getKey()).equals(refEntry);
                        // return nodeOk ? 0 : 1;
                    }
                };
                targetNode = targetNode.findTreeNode(searchKey);
                if (targetNode == null) {
                    // _printTypeTree(targetNodeold);
                    throw new IllegalActionException(RecordOperation.this, "Search path is incorrect!");
                } else {
                    // System.out.println("targetNode:"+
                    // targetNode.data.getKey()+":"+targetNode.data.getValue());
                }
            }
            // remove option
            if (_operationValue.equals("remove")) {
                targetNode.parent.delete(targetNode);
            }
            // add option
            else if (_operationValue.equals("add")) {
                if (targetNode.isLeaf()) {
                    throw new IllegalActionException(RecordOperation.this,
                            "Search path is incorrect!, try with an upper level path");
                } else {
                    _createTypeTree(recValue, targetNode);
                }
            }
            // replace option
            else if (_operationValue.equals("replace")) {
                if (!(recPathValue.equals("root"))) {
                    TreeNode<SimpleEntry<String, Type>> parentNode = targetNode.parent;
                    targetNode.parent.delete(targetNode);
                    _createTypeTree(recValue, parentNode);
                } else {
                    root = new TreeNode<SimpleEntry<String, Type>>(rootse);
                    _createTypeTree(recValue, root);
                }
            }
            // extract option
            else if (_operationValue.equals("extract")) {
                if (targetNode.isLeaf()) {
                    String[] labels = { targetNode.data.getKey() };
                    Type[] values = { targetNode.data.getValue() };
                    RecordType type = new RecordType(labels, values);
                    targetNode.data.setValue(type);
                }
                root = targetNode;
                root.parent = null;
            }

            // _printTypeTree(root);
            _createTypeRecord(root);
            // System.out.println("final type:"+root.data.getValue());
            return root.data.getValue();
        }

        /**
         * Return all the InequalityTerms for all input ports in an array.
         * 
         * @return An array of InequalityTerm.
         */
        @Override
        public InequalityTerm[] getVariables() {
            Iterator<TypedIOPort> inputPorts = inputPortList().iterator();
            LinkedList<InequalityTerm> result = new LinkedList<InequalityTerm>();
            while (inputPorts.hasNext()) {
                TypedIOPort port = inputPorts.next();
                InequalityTerm term = port.getTypeTerm();
                if (term.isSettable()) {
                    result.add(term);
                }
            }
            return result.toArray(new InequalityTerm[0]);
        }
    }

    /** A class for trees.
     * 
     *  This appears to be from:
     *  https://code.google.com/p/yet-another-tree-structure/source/browse/trunk/src/com/tree/?r=32
     *  
     *  Released under an Apache 2.0 license.
     *  
     */
    private static class TreeNodeIter<T> implements Iterator<TreeNode<T>> {

        enum ProcessStages {
            ProcessParent, ProcessChildCurNode, ProcessChildSubNode
        }

        private TreeNode<T> treeNode;

        public TreeNodeIter(TreeNode<T> treeNode) {
            this.treeNode = treeNode;
            this.doNext = ProcessStages.ProcessParent;
            this.childrenCurNodeIter = treeNode.children.iterator();
        }

        private ProcessStages doNext;
        private TreeNode<T> next;
        private Iterator<TreeNode<T>> childrenCurNodeIter;
        private Iterator<TreeNode<T>> childrenSubNodeIter;

        @Override
        public boolean hasNext() {

            if (this.doNext == ProcessStages.ProcessParent) {
                this.next = this.treeNode;
                this.doNext = ProcessStages.ProcessChildCurNode;
                return true;
            }

            if (this.doNext == ProcessStages.ProcessChildCurNode) {
                if (childrenCurNodeIter.hasNext()) {
                    TreeNode<T> childDirect = childrenCurNodeIter.next();
                    childrenSubNodeIter = childDirect.iterator();
                    this.doNext = ProcessStages.ProcessChildSubNode;
                    return hasNext();
                }

                else {
                    this.doNext = null;
                    return false;
                }
            }

            if (this.doNext == ProcessStages.ProcessChildSubNode) {
                if (childrenSubNodeIter.hasNext()) {
                    this.next = childrenSubNodeIter.next();
                    return true;
                } else {
                    this.next = null;
                    this.doNext = ProcessStages.ProcessChildCurNode;
                    return hasNext();
                }
            }

            return false;
        }

        @Override
        public TreeNode<T> next() {
            return this.next;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    /** A class for trees.
     * 
     *  This appears to be from:
     *  https://code.google.com/p/yet-another-tree-structure/source/browse/trunk/src/com/tree/?r=32
     *  
     *  Released under an Apache 2.0 license.
     *  
     */
    private static class TreeNode<T> implements Iterable<TreeNode<T>> {

        public T data;
        public TreeNode<T> parent;
        public List<TreeNode<T>> children;

        public boolean isRoot() {
            return parent == null;
        }

        public boolean isLeaf() {
            return children.size() == 0;
        }

        private List<TreeNode<T>> elementsIndex;

        public TreeNode(T data) {
            this.data = data;
            this.children = new LinkedList<TreeNode<T>>();
            this.elementsIndex = new LinkedList<TreeNode<T>>();
            this.elementsIndex.add(this);
        }

        public TreeNode<T> addChild(T child) {
            TreeNode<T> childNode = new TreeNode<T>(child);
            childNode.parent = this;
            this.children.add(childNode);
            this.registerChildForSearch(childNode);
            return childNode;
        }

        public int getLevel() {
            if (this.isRoot())
                return 0;
            else
                return parent.getLevel() + 1;
        }

        /*
         * public int treeSize() { return elementsIndex.size(); }
         * 
         * public void printList() { for (TreeNode<T> element :
         * this.elementsIndex) { T elData = element.data;
         * System.out.println("data:"+elData); } }
         */

        private void registerChildForSearch(TreeNode<T> node) {
            elementsIndex.add(node);
            if (parent != null)
                parent.registerChildForSearch(node);
        }

        public TreeNode<T> findTreeNode(Comparable<T> cmp) {
            for (TreeNode<T> element : this.elementsIndex) {
                T elData = element.data;
                if (cmp.compareTo(elData) == 0)
                    return element;
            }

            return null;
        }

        @Override
        public String toString() {
            return data != null ? data.toString() : "[data null]";
        }

        @Override
        public Iterator<TreeNode<T>> iterator() {
            TreeNodeIter<T> iter = new TreeNodeIter<T>(this);
            return iter;
        }

        public void delete(TreeNode<T> node) {
            children.remove(node);
            // not enough for the elementsIndex;
            elementsIndex.remove(node);
            if (parent != null)
                parent.delete(node);
        }
    }
    
    ///////////////////////////////////////////////////////////////////
    //// private fields ////

    /** The operation to perform. */
    private String _operationValue = "remove";

}