/*
 * 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 java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.HashMap;
import java.util.List;
import java.util.Set;

/**
 *
 * @author Thomas Wuerthinger
 */
public class InputGraph extends Properties.Entity {

    private HashMap<Integer, InputNode> nodes;
    private ArrayList<InputEdge> edges;
    private Group parent;
    private HashMap<String, InputBlock> blocks;
    private HashMap<Integer, InputBlock> nodeToBlock;
    private boolean isDifferenceGraph;

    public InputGraph(Group parent) {
        this(parent, null);
    }

    public InputGraph(Group parent, InputGraph last) {
        this(parent, last, "");
    }

    private void clearBlocks() {
        blocks.clear();
        nodeToBlock.clear();
    }

    public InputGraph(Group parent, InputGraph last, String name) {
        this.parent = parent;
        setName(name);
        nodes = new HashMap<Integer, InputNode>();
        edges = new ArrayList<InputEdge>();
        blocks = new HashMap<String, InputBlock>();
        nodeToBlock = new HashMap<Integer, InputBlock>();
        if (last != null) {

            for (InputNode n : last.getNodes()) {
                addNode(n);
            }

            for (InputEdge c : last.getEdges()) {
                addEdge(c);
            }
        }
    }

    public void schedule(Collection<InputBlock> newBlocks) {
        clearBlocks();
        InputBlock noBlock = new InputBlock(this, "no block");
        Set<InputNode> scheduledNodes = new HashSet<InputNode>();

        for (InputBlock b : newBlocks) {
            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)) {
                noBlock.addNode(n.getId());
            }
        }

        if (noBlock.getNodes().size() != 0) {
            newBlocks.add(noBlock);
        }
        for (InputBlock b : newBlocks) {
            addBlock(b);
        }

        for (InputNode n : this.getNodes()) {
            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) {
        return getBlock(node.getId());
    }

    public InputGraph getNext() {
        List<InputGraph> list = parent.getGraphs();
        if (!list.contains(this)) {
            return null;
        }
        int index = list.indexOf(this);
        if (index == list.size() - 1) {
            return null;
        } else {
            return list.get(index + 1);
        }
    }

    public InputGraph getPrev() {
        List<InputGraph> list = parent.getGraphs();
        if (!list.contains(this)) {
            return null;
        }
        int index = list.indexOf(this);
        if (index == 0) {
            return null;
        } else {
            return list.get(index - 1);
        }
    }

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

    public String getAbsoluteName() {
        String result = getName();
        if (this.parent != null) {
            result = parent.getName() + ": " + result;
        }
        return result;
    }

    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.unmodifiableList(edges);
    }

    public void removeEdge(InputEdge c) {
        assert edges.contains(c);
        edges.remove(c);
        assert !edges.contains(c);
    }

    public void addEdge(InputEdge c) {
        assert !edges.contains(c);
        edges.add(c);
        assert edges.contains(c);
    }

    public Group getGroup() {
        return parent;
    }

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

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

    public void addBlock(InputBlock b) {
        blocks.put(b.getName(), b);
        for (InputNode n : b.getNodes()) {
            this.nodeToBlock.put(n.getId(), b);
        }
    }

    public void resolveBlockLinks() {
        for (InputBlock b : blocks.values()) {
            b.resolveBlockLinks();
        }
    }

    public void setName(String s) {
        getProperties().setProperty("name", s);
    }

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

    public boolean isDifferenceGraph() {
        return this.isDifferenceGraph;
    }

    public void setIsDifferenceGraph(boolean b) {
        isDifferenceGraph = b;
    }
}