/*
 * SUDescriptor.java
 */

package org.openesb.components.camelse.common.deployment;

import org.openesb.components.camelse.common.RuntimeHelper;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.jbi.management.DeploymentException;
import javax.xml.namespace.QName;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

/**
 * This interface represent the service unit descriptor (jbi.xml) model. This will be used in
 * ServiceUnit implementation to find the services provided and consumed by this service unit.
 * {@link SUDescriptorFactory#getSUDescriptor} method reads the jbi.xml in the service unit to
 * to the implementation of this interface.
 *
 * @see SUDescriptorFactory
 * @see Consumes
 * @see Provides
 * @see ServiceUnit
 *
 * @author chikkala
 */
public interface SUDescriptor {
    
    Collection<Provides> getProvidedServices();
    
    Collection<Consumes> getConsumedServices();
    
    boolean isForBindingComponent();
    
    /**
     * base interface that models the service information described in the service unit descriptor for
     * consumed services and provided services.
     */
    public interface Service {
        /**
         * Getter for property interfaceQName.
         * @return Value of property interfaceQName.
         */
        QName getInterface();
        /**
         * Getter for property serviceName.
         * @return Value of property serviceName.
         */
        QName getServiceName();
        /**
         * Getter for property endpointName.
         * @return Value of property endpointName.
         */
        String getEndpointName();
    }
    /**
     * marker interface that represents the provided services in the service unit
     */
    public interface Provides extends Service {
    }
    /**
     * this interface represents the consumed service information in the su descriptor.
     */
    public interface Consumes extends Service {
        
        public final static String STANDARD_LINK = "standard";
        public final static String SOFT_LINK = "soft";
        public final static String HARD_LINK = "hard";
        /**
         * Getter for property linkType.
         * @return Value of property linkType.
         */
        String getLinkType();
    }
    /**
     * This is a factory class that can build the Service Unit Descriptor model from the jbi.xml
     */
    public static class SUDescriptorFactory {
        
        protected final static String JBI_TAG_NAME = "services";
        protected final static String SERVICES_TAG_NAME = "services";
        protected final static String BC_TAG_NAME = "binding-component";
        protected final static String PROVIDES_TAG_NAME = "provides";
        protected final static String CONSUMES_TAG_NAME = "consumes";
        protected final static String INTERFACE_TAG_NAME = "interface-name";
        protected final static String SERVICE_TAG_NAME = "service-name";
        protected final static String ENDPOINT_TAG_NAME = "endpoint-name";
        protected final static String LINK_TYPE_TAG_NAME = "link-type";
        /**
         * method that builds the Service unit descriptor model from the jbi.xml
         */
        public static SUDescriptor getSUDescriptor(String jbiXmlPath) throws Exception {
            FileReader reader = null;
            try {
                reader = new FileReader(jbiXmlPath);
                SUDescriptor suDesc = getSUDescriptor(reader);
                return suDesc;
            } finally {
                if ( reader != null ) {
                    try {
                        reader.close();
                    } catch (IOException ex) {
                        // ignore
                    }
                }
            }
        }
        /**
         * method that builds the Service unit descriptor model from the jbi.xml
         */
        public static SUDescriptor getSUDescriptor(Reader reader) throws Exception {
            SUDescriptor suDescriptor = null;
            Document suDescDoc = RuntimeHelper.buildDOMDocument(reader);
            Element jbiEl = suDescDoc.getDocumentElement();
            if (JBI_TAG_NAME.equals(jbiEl.getTagName())) {
                throw new DeploymentException("Invalid service unit descriptor : no jbi root element");
            }
            
            NodeList servicesNL = jbiEl.getElementsByTagName(SERVICES_TAG_NAME);
            if (servicesNL != null && servicesNL.getLength() == 1) {
                Element servicesEl = (Element) servicesNL.item(0);
                suDescriptor = SUDescriptorImpl.createSUDescriptor(servicesEl);
            } else {
                throw new DeploymentException("Invalid service unit descriptor : invalid services element");
            }
            
            return suDescriptor;
        }
        
    }
    /**
     * This class implements SUDescriptor
     */
    public static class SUDescriptorImpl implements SUDescriptor {
        
        private List<Consumes> mConsumedList;
        private List<Provides> mProvidedList;
        private boolean mIsForBindingComponent;
        
        protected SUDescriptorImpl(boolean isForBindingComponent) {
            this.mIsForBindingComponent = isForBindingComponent;
            this.mConsumedList = new ArrayList<Consumes>();
            this.mProvidedList = new ArrayList<Provides>();
        }
        
        protected void addProvidedService(Provides provides) {
            this.mProvidedList.add(provides);
        }
        
        protected void addConsumedService(Consumes consumes) {
            this.mConsumedList.add(consumes);
        }
        
        public Collection<Provides> getProvidedServices() {
            // return unmodifiable collection
            return Collections.unmodifiableCollection(this.mProvidedList);
        }
        
        public Collection<Consumes> getConsumedServices() {
            // return unmodifiable collection
            return Collections.unmodifiableCollection(this.mConsumedList);
        }
        
        public boolean isForBindingComponent() {
            return this.mIsForBindingComponent;
        }
        
        protected static SUDescriptor createSUDescriptor(Element servicesEl) throws Exception {
            boolean isForBC = false;
            String bcTagString = servicesEl.getAttribute(SUDescriptorFactory.BC_TAG_NAME);
            isForBC = Boolean.valueOf(bcTagString).booleanValue();
            SUDescriptorImpl suDesc = new SUDescriptorImpl(isForBC);
            // add consumes
            NodeList consumesNL = servicesEl.getElementsByTagName(SUDescriptorFactory.CONSUMES_TAG_NAME);
            for ( int i=0; i < consumesNL.getLength(); ++i) {
                Element consumesEl = (Element) consumesNL.item(i);
                Consumes consumes = ConsumedService.createConsumedService(consumesEl);
                suDesc.addConsumedService(consumes);
            }
            // add provides
            NodeList providesNL = servicesEl.getElementsByTagName(SUDescriptorFactory.PROVIDES_TAG_NAME);
            for ( int i=0; i < providesNL.getLength(); ++i) {
                Element providesEl = (Element) providesNL.item(i);
                Provides provides = ProvidedService.createProvidedService(providesEl);
                suDesc.addProvidedService(provides);
            }
            
            return suDesc;
        }
    }
    /**
     * Base class that implements the Service interface
     */
    public static abstract class AbstractService implements Service {
        
        private QName mInterface;
        private QName mServiceName;
        private String mEndpointName;
        
        private AbstractService() {
        }
        /**
         * Getter for property interfaceQName.
         * @return Value of property interfaceQName.
         */
        public QName getInterface() {
            return this.mInterface;
        }
        
        /**
         * Setter for property interfaceQName.
         * @param interfaceQName New value of property interfaceQName.
         */
        protected void setInterface(QName interfaceQName) {
            this.mInterface = interfaceQName;
        }
        
        /**
         * Getter for property serviceName.
         * @return Value of property serviceName.
         */
        public QName getServiceName() {
            return this.mServiceName;
        }
        
        /**
         * Setter for property serviceName.
         * @param serviceName New value of property serviceName.
         */
        protected void setServiceName(QName serviceName) {
            this.mServiceName = serviceName;
        }
        
        /**
         * Getter for property endpointName.
         * @return Value of property endpointName.
         */
        public String getEndpointName() {
            return this.mEndpointName;
        }
        
        /**
         * Setter for property endpointName.
         * @param endpointName New value of property endpointName.
         */
        protected void setEndpointName(String endpointName) {
            this.mEndpointName = endpointName;
        }
        
    }
    /**
     * This class implements the Provides interface
     */
    public static class ProvidedService
        extends AbstractService
        implements Provides {
        protected ProvidedService(QName interfaceQName, QName serviceName, String endpointName) {
            this.setInterface(interfaceQName);
            this.setServiceName(serviceName);
            this.setEndpointName(endpointName);
        }
        
        @Override
        public String toString() {
            return "Provides :" +
                "\n\t interface-name= " + getInterface() +
                "\n\t service-name= " + getServiceName() +
                "\n\t  endpont-name= " + getEndpointName();
        }
        
        protected static Provides createProvidedService(Element providesEl) throws Exception {
            
            String ifName = providesEl.getAttribute(SUDescriptorFactory.INTERFACE_TAG_NAME);
            String serviceName = providesEl.getAttribute(SUDescriptorFactory.SERVICE_TAG_NAME);
            String endpointName = providesEl.getAttribute(SUDescriptorFactory.ENDPOINT_TAG_NAME);
            if ( ifName == null || serviceName == null || endpointName == null ) {
                throw new Exception("Invalid provides element: missing " + SUDescriptorFactory.INTERFACE_TAG_NAME +
                    " or " + SUDescriptorFactory.SERVICE_TAG_NAME + " or " + SUDescriptorFactory.ENDPOINT_TAG_NAME );
            }
            QName ifQName = RuntimeHelper.resolveAttrQName(ifName, providesEl);
            QName serviceQName = RuntimeHelper.resolveAttrQName(serviceName, providesEl);
            
            return new ProvidedService(ifQName, serviceQName, endpointName);
        }
    }
    /**
     * This class implements the Consumes interface.
     */
    public static class ConsumedService
        extends AbstractService
        implements Consumes {
        private String mLinkType;
        protected ConsumedService(QName interfaceQName,
            QName serviceName,  String endpointName, String linkType) {
            this.setInterface(interfaceQName);
            this.setServiceName(serviceName);
            this.setEndpointName(endpointName);
            this.mLinkType = linkType;
        }
        
        /**
         * Getter for property linkType.
         * @return Value of property linkType.
         */
        public String getLinkType() {
            return this.mLinkType;
        }
        
        @Override
        public String toString() {
            return "Cosumes :" +
                "\n\t interface-name= " + getInterface() +
                "\n\t service-name= " + getServiceName() +
                "\n\t  endpont-name= " + getEndpointName() +
                "\n\t  link-type= " + getLinkType();
        }
        
        protected static Consumes createConsumedService(Element consumesEl) throws Exception {
            
            String ifName = consumesEl.getAttribute(SUDescriptorFactory.INTERFACE_TAG_NAME);
            String serviceName = consumesEl.getAttribute(SUDescriptorFactory.SERVICE_TAG_NAME);
            String endpointName = consumesEl.getAttribute(SUDescriptorFactory.ENDPOINT_TAG_NAME);
            String linkType = consumesEl.getAttribute(SUDescriptorFactory.LINK_TYPE_TAG_NAME);
            if ( linkType == null || linkType.trim().length() == 0 ) {
                linkType = STANDARD_LINK;
            }
            
            if ( ifName == null ) {
                throw new Exception("Invalid consumes element: missing " +
                    SUDescriptorFactory.INTERFACE_TAG_NAME );
            }
            if ( serviceName == null || endpointName == null ) {
                throw new Exception("Invalid consumes element: missing " +
                    SUDescriptorFactory.SERVICE_TAG_NAME + " or "
                    + SUDescriptorFactory.ENDPOINT_TAG_NAME );
            }
            
            QName ifQName = RuntimeHelper.resolveAttrQName(ifName, consumesEl);
            QName serviceQName = null;
            if ( serviceName != null ) {
                serviceQName = RuntimeHelper.resolveAttrQName(serviceName, consumesEl);
            }
            if ( serviceQName != null && endpointName != null && linkType != null ) {
                if (!(STANDARD_LINK.equals(linkType) ||
                    SOFT_LINK.equals(linkType) || HARD_LINK.equals(linkType)) ) {
                    throw new Exception("Invalid consumes attribute value" +
                        SUDescriptorFactory.LINK_TYPE_TAG_NAME + "=" + linkType);
                }
            }
            return new ConsumedService(ifQName, serviceQName, endpointName, linkType);
        }
    }
    
}