/*
 * The contents of this file are subject to the terms 
 * of the Common Development and Distribution License 
 * (the License).  You may not use this file except in
 * compliance with the License.
 * 
 * You can obtain a copy of the license at 
 * https://glassfish.dev.java.net/public/CDDLv1.0.html or
 * glassfish/bootstrap/legal/CDDLv1.0.txt.
 * See the License for the specific language governing 
 * permissions and limitations under the License.
 * 
 * When distributing Covered Code, include this CDDL 
 * Header Notice in each file and include the License file 
 * at glassfish/bootstrap/legal/CDDLv1.0.txt.  
 * If applicable, add the following below the CDDL Header, 
 * with the fields enclosed by brackets [] replaced by
 * you own identifying information: 
 * "Portions Copyrighted [year] [name of copyright owner]"
 * 
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 */
package com.sun.enterprise.deployment.backend;

import com.sun.enterprise.deployment.Application;
import com.sun.enterprise.deployment.ApplicationClientDescriptor;
import com.sun.enterprise.deployment.deploy.shared.AbstractArchive;
import com.sun.enterprise.deployment.deploy.shared.FileArchive;
import com.sun.enterprise.deployment.deploy.shared.OutputJarArchive;
import com.sun.enterprise.deployment.interfaces.ClientJarMaker;
import com.sun.enterprise.deployment.interfaces.DeploymentImplConstants;
import com.sun.enterprise.deployment.RootDeploymentDescriptor;
import com.sun.enterprise.deployment.util.ModuleDescriptor;
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.enterprise.util.io.FileUtils;
import com.sun.enterprise.util.zip.ZipItem;

import java.io.File;
import java.util.Collection;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.Properties;
import java.util.Set;

/**
 * This thread subclass is responsible for creating the client jar
 * file.
 *
 * @author Jerome Dochez
 */
public class ClientJarMakerThread extends Thread {

    private DeploymentRequest request;
    private File clientJar;
    private ZipItem[] clientStubs;
    private String clientJarChoice = null;
    
    private static StringManager localStrings = StringManager.getManager( Deployer.class );
    
    /** Creates a new instance of ClientJarMakerThread */
    public ClientJarMakerThread(DeploymentRequest request, File clientJar, 
                                ZipItem[] clientStubs, 
                                String clientJarChoice) {
        this.request = request;
        this.clientJar = clientJar;
        this.clientStubs = clientStubs;
        this.clientJarChoice = clientJarChoice;
    }
    
    public void run() {
        // first thing to do is to register ourselves in the 
        // client jar maker registry
        ClientJarMakerRegistry registry = ClientJarMakerRegistry.getInstance();
        
        String moduleID = request.getName();
        registry.register(moduleID, this);
        
        // now we build the client jar file 
        try {
            createClientJar(request, clientJar, clientStubs, clientJarChoice);
        } catch(IASDeploymentException e) {
            // unfortunetely, we cannot provide failures feedback to the client
            // at this point, but we certainly need to log it.
            DeploymentLogger.get().log(Level.SEVERE, 
                localStrings.getString("enterprise.deployment.error_creating_client_jar", 
                    e.getLocalizedMessage()) ,e);
        
        } finally {
            
            // we are done, unregister ouselves from the registry
            registry.unregister(moduleID);
        }
        
        // friendly log
        DeploymentLogger.get().fine("Created client jar file for " + moduleID + " at " + clientJar.getAbsolutePath());
        
    }
   
    /**
     * this method is called from the thread to create the client jar or 
     * synchronously from the Deployer 
     */
    public static final void createClientJar(
        DeploymentRequest request, File clientJar, ZipItem[] clientStubs, 
        String clientJarChoice) throws IASDeploymentException {
        try {         
            // client jar naming convension is <app-name>Client.jar
            OutputJarArchive target = new OutputJarArchive();
            target.create(clientJar.getAbsolutePath());
            
            RootDeploymentDescriptor descriptor;
            if (request.getDescriptor().isVirtual()) {
                descriptor = request.getDescriptor().getStandaloneBundleDescriptor();
            } else {
                descriptor = request.getDescriptor();
            }
            
            AbstractArchive source = new FileArchive();
            ((FileArchive) source).open(request.getDeployedDirectory().getAbsolutePath());
            PEDeploymentFactoryImpl pe = new PEDeploymentFactoryImpl();
            Properties props = getPropertiesForClientJarMaker(
                CLIENT_JAR_CHOICES.getClientJarChoice(clientJarChoice),
                request, descriptor);
            ClientJarMaker jarMaker = pe.getClientJarMaker(props);

            // copy xml files from generated directory archive to original 
            // directory archive so the created client jar contain 
            // processed xml files.
            if (FileUtils.safeIsDirectory(
                request.getGeneratedXMLDirectory())) {
                AbstractArchive source2 = new FileArchive();
                ((FileArchive) source2).open(
                    request.getGeneratedXMLDirectory().getAbsolutePath());
                jarMaker.create(descriptor, source, source2, target, clientStubs,
                    null);
                source2.close();
            } else {
                jarMaker.create(descriptor, source, target, clientStubs,null);
            }
            source.close();
            target.close();
        } catch(Exception e) {
            IASDeploymentException newE = new IASDeploymentException();
            newE.initCause(e);
            throw newE;
        }
    }

    private static Properties getPropertiesForClientJarMaker(
        CLIENT_JAR_CHOICES choice,
        DeploymentRequest request, RootDeploymentDescriptor descriptor) {
      
        boolean qualify = qualifyModuleClientFormat(request,descriptor);

        Properties props = null;
        Boolean propertySetting = choice.useModuleClientJarMaker(qualify);

        if (propertySetting != null) {
            props = new Properties();
            props.setProperty(
                DeploymentImplConstants.USE_MODULE_CLIENT_JAR_MAKER, 
                propertySetting.toString());
        }
        return props;
    }

    /**
     * This method determines if the generated appclient jar should be in
     * the standalone appclient module format. There are 3 cases to create
     * the simpler version of the generated appclient:
     * 1) deployed module is a standalone appclient/ejb
     * 2) deployed module is an ear containing 0 or 1 appclient jar
     * 3) deployed module does not contain appclient that uses persistence unit
     */
    private static boolean qualifyModuleClientFormat
        (DeploymentRequest request, RootDeploymentDescriptor descriptor) {

        // create appclient format for standalone appclient module
        if (request.getDescriptor().isVirtual()) {
            return true;
        }

        Application app = Application.class.cast(descriptor);
        Set appClients = app.getApplicationClientDescriptors();
        if (appClients != null) {
    
            // create ear format of appclient if there are more than
            // one appclients in the ear file
            if (appClients.size() > 1) {
                return false;
            }

            if (!appClients.isEmpty()) {
                ApplicationClientDescriptor ac = 
                ApplicationClientDescriptor.class.cast(appClients.iterator().next());

                // checks to see if this appclient has entries for
                // message-destination-ref.  if so, use ear format
                Set msgDestRefs = ac.getMessageDestinationReferenceDescriptors();
                if (msgDestRefs != null && !msgDestRefs.isEmpty()) {
                    return false;
                }

                // checks to see if this appclient depends on a PU.
                // if so, use ear format
                Set entityMgrFacRefs = ac.getEntityManagerFactoryReferenceDescriptors();
                if (entityMgrFacRefs != null && !entityMgrFacRefs.isEmpty()) {
                    return false;
                }
            }
        }

        for (Iterator modules = app.getModules(); modules.hasNext();) {
            ModuleDescriptor md = ModuleDescriptor.class.cast(modules.next());

            // checks to see if any of the sub modules uses altDD
            // if so, use the application package format.  we could
            // also choose to override the original dd with the altDD,
            // but that might get very confusing when someone is trying
            // to debug.
            if (md.getAlternateDescriptor() != null) {
                return false;
            }
        }

        return true;
    }

    private static enum CLIENT_JAR_CHOICES {

        //original implementation, for comparing behavior regression
        USE_ORIGINAL_MAKER {
        public Boolean useModuleClientJarMaker(boolean qualify) {
            return null;}},

        //transitional default option. only turn on the generation of the
        //appclient module format
        USE_TRANSITION_MAKER {
        public Boolean useModuleClientJarMaker(boolean qualify) {
            return qualify == true ? Boolean.TRUE : null;}},

        //alternative default option. generate appclient module format
        //or the ear module format accordingly
        USE_COMBO_MAKER {
        public Boolean useModuleClientJarMaker(boolean qualify) {
            return new Boolean(qualify);}},

        //current default. generate only the ear module format, i.e. no 
        //optimization on certain deployed ear
        USE_EAR_MAKER {
        public Boolean useModuleClientJarMaker(boolean qualify) {
            return Boolean.FALSE;}};
       
        public abstract Boolean useModuleClientJarMaker(boolean qualify);
       
        public static CLIENT_JAR_CHOICES DEFAULT_CHOICE = USE_EAR_MAKER;
       
        public static CLIENT_JAR_CHOICES getClientJarChoice(String choice) {
            try {
                if (choice == null) {
                    return DEFAULT_CHOICE;
                }
                return valueOf(choice);
            } catch (IllegalArgumentException iae) {
                return DEFAULT_CHOICE;
            }
        }
    }
}
