/// <summary>
 /// Represents simple binary expressions which involve identifier on left and literal on the right
 /// </summary>
 /// <param name="i1"></param>
 /// <param name="o"></param>
 /// <param name="i2"></param>
 internal BinExprNode(IdentNode i1, Operator o, LiteralNode i2)
     : base(i1.Name + o.Name + i2.Name, o.Guid)
 {
     op = o;
     left = i1;
     right = i2;
 }

        // TODO: Deprecate
        private static IdentifierNode CreateTempIdentifierNode(Node node)
        {
            uint tguid = GraphCompiler.GetTempGUID(node.Guid);
            string tempName = GraphToDSCompiler.kw.tempPrefix + tguid;

            return new IdentifierNode(tempName);
        }

 //
 // TODO Jun: Deprecate the overloaded constructors.
 // All assignment nodes must be instantiated with this constructor
 public Assignment(Node left, Node right)
     : base("", left.Guid)
 {
     Optr = ProtoCore.DSASM.Operator.assign;
     base.Name = ProtoCore.Utils.CoreUtils.GetOperatorString(Optr);
     this.left = left;
     this.right = right;
 }

 private static Boolean IsNotVisited(Node node, Dictionary<Node, int> nodeStateMap)
 {
     if (!nodeStateMap.ContainsKey(node))
     {
         return true;
     }
     int state = nodeStateMap[node];
     return NOT_VISTITED == state;
 }

 static List<Node> DFS(Node node, AST statementList)
 {
     List<Node> sotedNodes = new List<Node>();
     Dictionary<Node, int> nodeStateMap = new Dictionary<Node, int>();
     if (IsNotVisited(node, nodeStateMap))
     {
         DFSVisit(node, nodeStateMap, sotedNodes, statementList);
     }
     return sotedNodes;
 }

 public static List<int> GetKeysFromValue(Dictionary<int, Node> dict, Node node)
 {
     List<int> ks = new List<int>();
     foreach (int k in dict.Keys)
     {
         if (dict[k].Equals(node))
         {
             ks.Add(k);
         }
     }
     return ks;
 }

 static void DFSVisit(Node node, Dictionary<Node, int> nodeStateMap, List<Node> list)
 {
     nodeStateMap.Add(node, VISITING);
     List<Node> nodes = node.GetChildren();
     IEnumerable iter = nodes;
     foreach (Node nodeI in iter)
     {
         if (IsNotVisited(nodeI, nodeStateMap))
             DFSVisit(nodeI, nodeStateMap, list);
     }
     nodeStateMap[node] = VISITED;
     list.Add(node);
 }

 public void AddEdge(Node from, Node to, int inputIndex, int fromIndex)
 {
     from.AddChild(to, inputIndex, fromIndex);
     to.AddParent(from);
     List<Node> cycle = CheckForCycle.CreatesCycle(to);
     if (cycle != null)
     {
         // remove edge which introduced cycle
         //    RemoveEdge( from, to );
         String msg = "Edge between '" + from.Name + "' and '" + to.Name + "' introduces a cycle in the graph";
         GraphCompilationStatus.HandleError(new HasCycleException(msg, cycle)) ;
     }
 }

        private static void BuildBlockToBlockStatement(Node node, Node nodeI, AST statementList)
        {
            if (node.children.Count > 1)
            {
                statementList.AddNode(node);
            }
            else
            {
                string content = string.Empty;
                Block block = nodeI as Block;
                Validity.Assert(block != null);
                Assignment a1 = null;
                Node n1 = statementList.GetNode(node.Guid);
                if (n1 is Assignment)
                {
                    a1 = n1 as Assignment;

                    //
                    // Comment Jun:
                    // This condition basically checks if the single line codeblock is either a full expression or a single ident
                    // For now, in order to check for single ident, we check if the LHS if empty
                    // This needs refinement
                    bool isSingleIdent = string.IsNullOrEmpty((((Block)node).LHS));
                    if (isSingleIdent)
                    {
                        // This single line codeblock is a single identifier
                        a1.right.Name = block.LHS != "" ? block.LHS : block.Name.Replace(";", "").Trim();
                        content = a1.ToScript();
                    }
                    else
                    {
                        // This single line codeblock is a full expression
                        content = ((Block)node).Name;
                    }

                    // Comment Jun: Create a new block that represents the new contents
                    Block block2 = new Block(content, node.Guid);
                    int index = statementList.nodeList.IndexOf(a1);
                    statementList.RemoveNode(a1);

                    statementList.nodeList.Insert(index, block2);
                    statementList.nodeMap.Add(block2.Guid, block2);

                    // Comment Jun: Reflect the new changes to the original block
                    (node as Block).SetData(block2.LHS, content);
                }
            }
        }

        /*public HashSet<uint> GetNames()
        {
            HashSet<uint> nameSet = new HashSet<uint>(nodeMap.Keys);
            return nameSet;
        }
        */
        /// <summary>
        /// Adds a new node to the nodemap given its name and guid if it is not present in the graph.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="guid"></param>
        /// <returns></returns>
        public Node AddNode(string name, uint guid)
        {
            Node newNode = null;

            if (nodeMap.ContainsKey(guid))
            {
                newNode = (Node)nodeMap[guid];
            }
            else
            {
                newNode = new Node(name, guid);
                nodeMap.Add(guid, newNode);
                nodeList.Add(newNode);
            }
            return newNode;
        }

 public static List<Node> CreatesCycle(Node node, Dictionary<Node, int> nodeStateMap)
 {
     List<Node> cycleStack = new List<Node>();
     Boolean hasCycle = DFSVisit( node, nodeStateMap,cycleStack);
     if ( hasCycle )
     {
         // we have a situation like: [c, a, b, c, f, g, h].
         // Node which introduced  the cycle is at the first position in the list
         // We have to find second occurence of this node and use its position in the list
         // for getting the sublist of vertex labels of cycle paricipants
         // So in our case we are seraching for [c, a, b, c]
         //string name = cycleStack[0].Name;
         int pos = cycleStack.IndexOf(cycleStack[0],0);
         List<Node> cycle = new List<Node>(pos + 1);
         for(int i=0;i<pos+1;i++)
             cycle.Add(cycleStack[i]);
         cycle.Reverse();
         return cycle;
     }
     return null;
 }

 /// <summary>
 /// Returns false if a depth-first search of Graph yields no back edges.
 /// If back edges found then return true and update cycleStack.
 /// </summary>
 /// <param name="node"></param>
 /// <param name="nodeStateMap"></param>
 /// <param name="cycleStack"></param>
 /// <returns></returns>
 public static Boolean DFSVisit(Node node, Dictionary<Node, int> nodeStateMap, List<Node> cycleStack)
 {
     cycleStack.Add(node);
     nodeStateMap.Add(node, visiting);
     List<Node> nodes = node.GetChildren();
     IEnumerable iter = nodes;
     foreach (Node nodeI in iter)
     {
         if (IsNotVisited(nodeI, nodeStateMap))
         {
             if (DFSVisit(nodeI, nodeStateMap, cycleStack)) return true;
         }
         else if (IsVisiting(nodeI, nodeStateMap))
         {
             cycleStack.Insert(0,node);
             return true;
         }
     }
     nodeStateMap[node] = visited;
     cycleStack.RemoveAt(0);
     return false;
 }

        private static void BuildBlockToIdentStatement(Node node, Node nodeIdent, AST statementList)
        {
            Validity.Assert(node is Block);

            if (node.children.Count > 1)
            {
                statementList.AddNode(node);
            }
            else
            {
                IdentNode identNode = nodeIdent as IdentNode;
                Validity.Assert(null != identNode);

                Block block = node as Block;

                string lhs = string.Empty;
                string content = string.Empty;
                bool isSingleIdent = string.IsNullOrEmpty(block.LHS);
                if (isSingleIdent)
                {
                    lhs = block.TrimName();
                }
                else
                {
                    lhs = block.LHS;
                }

                // Create the cnontents of the new block. 
                content = lhs + '=' + identNode.Name;

                // Comment Jun: Remove the current codeblock first
                // Codeblock removal is guid dependent
                Node nodeToRemove = statementList.GetNode(node.Guid);
                int index = statementList.nodeList.IndexOf(nodeToRemove);
                statementList.RemoveNode(nodeToRemove);

                // Comment Jun: Create a new block using the current guid
                // This new codeblock represents the new contents
                Block block2 = new Block(content, node.Guid);
                statementList.nodeList.Insert(index, block2);
                statementList.nodeMap.Add(block2.Guid, block2);
                statementList.AddNode(block2);


                // Comment Jun: Reflect the new changes to the original block
                (node as Block).SetData(block2.LHS, content);
            }
        }

        private static void BuildIdentToOperatorStatement(Node node, AST statementList, Node nodeI)
        {
            Assignment a2 = (Assignment)statementList.GetNode(nodeI.Guid);
            Assignment a = new Assignment((IdentNode)node, (IdentNode)a2.left);
            if (statementList.nodeMap.ContainsKey(a.Guid))
            {
                Node nodeToRemove = statementList.GetNode(a.Guid);
                int index = statementList.nodeList.IndexOf(nodeToRemove);
                statementList.RemoveNode(nodeToRemove);

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
                statementList.AddNode(a);
        }

        private static void BuildIdentToIdentStatement(Node node, Node nodeI, AST statementList)
        {
            Assignment a = new Assignment((IdentNode)node, (IdentNode)nodeI);
            if (statementList.nodeMap.ContainsKey(node.Guid))
            {
                Node nodeToRemove = statementList.GetNode(a.Guid);
                int index = statementList.nodeList.IndexOf(nodeToRemove);
                statementList.RemoveNode(nodeToRemove);

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
                statementList.AddNode(a);
        }

        private static int BuildFuncToIdentStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
        {
            Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
            IdentNode identNode = nodeI as IdentNode;
            Validity.Assert(null != identNode);

            List<int> keys = GetKeysFromValue(nodeDic, nodeI);
            FunctionCall f = ((FunctionCall)a1.right);
            if (keys.Count > 1)
            {
                do
                {
                    f.parameters[keys[j]] = identNode;
                    j++;
                } while (j < keys.Count);
            }
            else
            {
                f.parameters[keys[j]] = identNode;
            }
            j = 0;
            return j;
        }

        private static int BuildIdentToCodeBlockIdentStatement(Node node, Node nodeI, List<Node> nodes, AST statementList, int j)
        {
            Block block = nodeI as Block;
            Validity.Assert(block != null);

            // Comment Jun: Check if the codeblock is a single ident
            string lhs = block.LHS;
            if (string.IsNullOrEmpty(lhs))
            {
                lhs = block.TrimName();
            }

            Assignment a = new Assignment((IdentNode)node, new IdentNode(lhs, block.Guid));
            if (statementList.nodeMap.ContainsKey(a.Guid))
            {
                int index = statementList.nodeList.IndexOf(statementList.GetNode(a.Guid));
                statementList.RemoveNode(statementList.GetNode(a.Guid));

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
            {
                statementList.AddNode(a);
            }
                
            return ++j;
        }

 private static int BuildFuncToBlockStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
 {
     Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
     Block block = nodeI as Block;
     List<int> keys = GetKeysFromValue(nodeDic, nodeI);
     FunctionCall f = ((FunctionCall)a1.right);
     if (keys.Count > 1)
     {
         do
         {
             f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid); 
             j++;
         } while (j < keys.Count);
     }
     else
     {
         f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid);
     }
     j = 0;
     return j;
 }

 /// <summary>
 /// Remove the edge connecting the input of this note to output of the specified node
 /// Also call RemoveEdgeTo on node
 /// </summary>
 public void RemoveParent(Node node)
 {
     parents.Remove(node);
 }

 private static int BuildOperatorToOperatorStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
 {
     Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
     Assignment a2 = (Assignment)statementList.GetNode(nodeI.Guid);
     List<int> keys = GetKeysFromValue(nodeDic, nodeI);
     if (keys.Count > 1)
     {
         if (keys[j] == 0)
         {
             ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2) ++j;
         }
         else
         {
             ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2) ++j;
         }
     }
     else
     {
         if (keys[0] == 0)
         {
             ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2) ++j;
         }
         else
         {
             ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2) ++j;
         }
     }
     return j;
 }