/*
 * Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
package com.sun.hotspot.igv.data;

import at.ssw.visualizer.model.bc.Bytecodes;
import at.ssw.visualizer.model.cfg.BasicBlock;
import at.ssw.visualizer.model.cfg.ControlFlowGraph;
import at.ssw.visualizer.model.nc.NativeMethod;
import java.util.*;

/**
 *
 * @author Thomas Wuerthinger
 */
public class InputGraph extends Properties.Entity implements FolderElement, ControlFlowGraph {

    private Map<Integer, InputNode> nodes;
    private Set<InputEdge> edges;
    private Folder parent;
    private Group parentGroup;
    private Map<String, InputBlock> blocks;
    private Set<InputBlockEdge> blockEdges;
    private Map<Integer, InputBlock> nodeToBlock;

    public InputGraph(String name) {
        setName(name);
        nodes = new LinkedHashMap<>();
        edges = new LinkedHashSet<>();
        blocks = new LinkedHashMap<>();
        blockEdges = new LinkedHashSet<>();
        nodeToBlock = new LinkedHashMap<>();
    }
    
    @Override
    public void setParent(Folder parent) {
        this.parent = parent;
        if (parent instanceof Group) {
            assert this.parentGroup == null;
            this.parentGroup = (Group) parent;
        }
    }

    public InputBlockEdge addBlockEdge(InputBlock left, InputBlock right) {
        InputBlockEdge edge = new InputBlockEdge(left, right);
        blockEdges.add(edge);
        left.addSuccessor(right);
        return edge;
    }
    
    public List<InputNode> findRootNodes() {
        List<InputNode> result = new ArrayList<>();
        Set<Integer> nonRoot = new HashSet<>();
        for(InputEdge curEdges : getEdges()) {
            nonRoot.add(curEdges.getTo());
        }
        
        for(InputNode node : getNodes()) {
            if(!nonRoot.contains(node.getId())) {
                result.add(node);
            }
        }
        
        return result;
    }
    
    public Map<InputNode, List<InputEdge>> findAllOutgoingEdges() {
        
        Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
        for(InputNode n : this.getNodes()) {
            result.put(n, new ArrayList<InputEdge>());
        }
        
        for(InputEdge e : this.edges) {
            int from = e.getFrom();
            InputNode fromNode = this.getNode(from);
            List<InputEdge> fromList = result.get(fromNode);
            assert fromList != null;
            fromList.add(e);
        }
        
        for(InputNode n : this.getNodes()) {
            List<InputEdge> list = result.get(n);
            Collections.sort(list, InputEdge.OUTGOING_COMPARATOR);
        }
        
        return result;
    }
    
    public Map<InputNode, List<InputEdge>> findAllIngoingEdges() {
        
        Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
        for(InputNode n : this.getNodes()) {
            result.put(n, new ArrayList<InputEdge>());
        }
        
        for(InputEdge e : this.edges) {
            int to = e.getTo();
            InputNode toNode = this.getNode(to);
            List<InputEdge> toList = result.get(toNode);
            assert toList != null;
            toList.add(e);
        }
        
        for(InputNode n : this.getNodes()) {
            List<InputEdge> list = result.get(n);
            Collections.sort(list, InputEdge.INGOING_COMPARATOR);
        }
        
        return result;
    }
    
    public List<InputEdge> findOutgoingEdges(InputNode n) {
        List<InputEdge> result = new ArrayList<>();
        
        for(InputEdge e : this.edges) {
            if(e.getFrom() == n.getId()) {
                result.add(e);
            }
        }
        
        Collections.sort(result, InputEdge.OUTGOING_COMPARATOR);
        
        return result;
    }

    public void clearBlocks() {
        blocks.clear();
        nodeToBlock.clear();
    }
    
    public void setEdge(int fromIndex, int toIndex, int from, int to) {
        assert fromIndex == ((char)fromIndex) : "Downcast must be safe";
        assert toIndex == ((char)toIndex) : "Downcast must be safe";
        
        InputEdge edge = new InputEdge((char)fromIndex, (char)toIndex, from, to);
        if(!this.getEdges().contains(edge)) {
            this.addEdge(edge);
        }
    }

    public void ensureNodesInBlocks() {
        InputBlock noBlock = null;
        Set<InputNode> scheduledNodes = new HashSet<>();

        for (InputBlock b : getBlocks()) {
            for (InputNode n : b.getNodes()) {
                assert !scheduledNodes.contains(n);
                scheduledNodes.add(n);
            }
        }

        for (InputNode n : this.getNodes()) {
            assert nodes.get(n.getId()) == n;
            if (!scheduledNodes.contains(n)) {
                if (noBlock == null) {
                    noBlock = this.addBlock("(no block)");
                }
                noBlock.addNode(n.getId());
            }
            assert this.getBlock(n) != null;
        }
    }

    public void setBlock(InputNode node, InputBlock block) {
        nodeToBlock.put(node.getId(), block);
    }

    public InputBlock getBlock(int nodeId) {
        return nodeToBlock.get(nodeId);
    }

    public InputBlock getBlock(InputNode node) {
        assert nodes.containsKey(node.getId());
        assert nodes.get(node.getId()).equals(node);
        return getBlock(node.getId());
    }

    public InputGraph getNext() {
        return parentGroup.getNext(this);
    }

    public InputGraph getPrev() {
        return parentGroup.getPrev(this);
    }

    private void setName(String name) {
        this.getProperties().setProperty("name", name);
    }

    @Override
    public String getName() {
        return getProperties().get("name");
    }

    public Collection<InputNode> getNodes() {
        return Collections.unmodifiableCollection(nodes.values());
    }

    public Set<Integer> getNodesAsSet() {
        return Collections.unmodifiableSet(nodes.keySet());
    }

    public Collection<InputBlock> getBlocks() {
        return Collections.unmodifiableCollection(blocks.values());
    }

    public void addNode(InputNode node) {
        nodes.put(node.getId(), node);
    }

    public InputNode getNode(int id) {
        return nodes.get(id);
    }

    public InputNode removeNode(int index) {
        return nodes.remove(index);
    }

    public Collection<InputEdge> getEdges() {
        return Collections.unmodifiableSet(edges);
    }

    public void removeEdge(InputEdge c) {
        boolean removed = edges.remove(c);
        assert removed;
    }

    public void addEdge(InputEdge c) {
        // Be tolerant with duplicated edges.
        if (!edges.contains(c)) {
            edges.add(c);
        }
    }

    public Group getGroup() {
        return parentGroup;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Graph ").append(getName()).append(" ").append(getProperties().toString()).append("\n");
        for (InputNode n : nodes.values()) {
            sb.append(n.toString());
            sb.append("\n");
        }

        for (InputEdge c : edges) {
            sb.append(c.toString());
            sb.append("\n");
        }

        for (InputBlock b : getBlocks()) {
            sb.append(b.toString());
            sb.append("\n");
        }

        return sb.toString();
    }

    public InputBlock addBlock(String name) {
        final InputBlock b = new InputBlock(this, name);
        blocks.put(b.getName(), b);
        return b;
    }

    public InputBlock getBlock(String s) {
        return blocks.get(s);
    }

    public Collection<InputBlockEdge> getBlockEdges() {
        return Collections.unmodifiableSet(blockEdges);
    }

    @Override
    public Folder getParent() {
        return parent;
    }

    @Override
    public List<BasicBlock> getBasicBlocks() {
        return new ArrayList<BasicBlock>(blocks.values());
    }

    @Override
    public BasicBlock getBasicBlockByName(String name) {
        return blocks.get(name);
    }

    @Override
    public Bytecodes getBytecodes() {
        // TODO(tw): no bytecodes
        return null;
    }

    @Override
    public NativeMethod getNativeMethod() {
        // TODO(tw): No native method.
        return null;
    }

    @Override
    public boolean hasState() {
        // TODO(tw): implement
        return false;
    }

    @Override
    public boolean hasHir() {
        // TODO(tw): Implement
        return false;
    }

    @Override
    public boolean hasLir() {
        // TODO(tw): Implement
        return false;
    }
}