/*
 * Copyright 2008 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */ 
package org.wamblee.system.graph.component;

import java.util.ArrayList;
import java.util.List;

import org.wamblee.general.Pair;
import org.wamblee.system.container.CompositeInterfaceRestriction;
import org.wamblee.system.container.InterfaceRestriction;
import org.wamblee.system.core.Component;
import org.wamblee.system.core.ProvidedInterface;
import org.wamblee.system.core.RequiredInterface;
import org.wamblee.system.graph.DefaultEdge;
import org.wamblee.system.graph.Edge;
import org.wamblee.system.graph.Graph;
import org.wamblee.system.graph.Node;


// TODO info superfluous required interfaces
// TODO check optional external required but mandatory internal.  

public class ComponentGraph extends Graph {
    
    private CompositeInterfaceRestriction _restriction; 

    public ComponentGraph() { 
        _restriction = new CompositeInterfaceRestriction(); 
    }
    
    public void addRestriction(InterfaceRestriction aRestriction) { 
        _restriction.add(aRestriction);
    }
    
    public void addRequiredInterface(RequiredInterface aInterface) { 
        addNode(new ExternalRequiredInterfaceNode(aInterface));
    }
    
    public void addProvidedInterface(ProvidedInterface aInterface) { 
        addNode(new ExternalProvidedInterfaceNode(aInterface));
    }
    
    public void validate() { 
        extend(new RequiredProvidedEdgeFactory());
        accept(new ApplyRestrictionsVisitor(this, _restriction));
        accept(new CheckRequiredProvidedMultiplicityVisitor(this));
        accept(new CheckExternallyRequiredVisitor());
        accept(new CheckExternallyProvidedVisitor(this));
        accept(new CheckStartupDependenciesVisitor(this));
    }
    
    public void link() { 
        accept(new LinkVisitor());
    }
    
    /**
     * Finds a list of mappings of external provided interface to internal provided interface. 
     * 
     * @return List of pairs of external to internal interface. 
     */
    public List<Pair<ProvidedInterface, ProvidedInterface>> findExternalProvidedInterfaceMapping() { 
        List<Pair<ProvidedInterface, ProvidedInterface>> result = 
            new ArrayList<Pair<ProvidedInterface,ProvidedInterface>>(); 
        for (Edge edge: getEdges()) { 
            if ( edge.getFrom() instanceof ExternalProvidedInterfaceNode  && 
                    edge.getTo() instanceof ProvidedInterfaceNode ) { 
                result.add(new Pair<ProvidedInterface,ProvidedInterface>(
                        ((ExternalProvidedInterfaceNode)edge.getFrom()).getProvided(), 
                        ((ProvidedInterfaceNode)edge.getTo()).getProvided()
                        )); 
            }
        }
        return result; 
    }
    
    public void addComponent(Component aComponent) { 
        // Add required interfaces. 
        Node compNode = new ComponentNode(aComponent);
        List<Node> requiredNodes = new ArrayList<Node>();
        for (RequiredInterface required: aComponent.getRequiredInterfaces()) { 
            Node reqNode = new RequiredInterfaceNode(aComponent, required); 
            addNode(reqNode);
            requiredNodes.add(reqNode);
        }
        // Add the component
        addNode(compNode);
     
        // Edges from component to required interface. 
        for (Node reqNode: requiredNodes) { 
            addEdge(new DefaultEdge(compNode, reqNode));
        }
        
        // Add provided interfaces
        List<Node> providedNodes = new ArrayList<Node>();
        for (ProvidedInterface provided: aComponent.getProvidedInterfaces()) { 
            Node provNode = new ProvidedInterfaceNode(aComponent, provided); 
            addNode(provNode);
            providedNodes.add(provNode);
        }
        
        // Edges from provided interface to component
        for (Node provNode: providedNodes) { 
            addEdge(new DefaultEdge(provNode, compNode));
        }
    }
}