/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.openejb.arquillian.common;

import org.apache.openejb.NoSuchApplicationException;
import org.apache.openejb.OpenEJBException;
import org.apache.openejb.UndeployException;
import org.apache.openejb.assembler.Deployer;
import org.apache.openejb.assembler.DeployerEjb;
import org.apache.openejb.assembler.classic.AppInfo;
import org.apache.openejb.assembler.classic.Info;
import org.apache.openejb.assembler.classic.ServletInfo;
import org.apache.openejb.assembler.classic.WebAppInfo;
import org.apache.openejb.loader.Options;
import org.apache.openejb.util.NetworkUtil;
import org.jboss.arquillian.container.spi.client.container.DeployableContainer;
import org.jboss.arquillian.container.spi.client.container.DeploymentException;
import org.jboss.arquillian.container.spi.client.container.LifecycleException;
import org.jboss.arquillian.container.spi.client.deployment.DeploymentDescription;
import org.jboss.arquillian.container.spi.client.protocol.ProtocolDescription;
import org.jboss.arquillian.container.spi.client.protocol.metadata.HTTPContext;
import org.jboss.arquillian.container.spi.client.protocol.metadata.ProtocolMetaData;
import org.jboss.arquillian.container.spi.client.protocol.metadata.Servlet;
import org.jboss.arquillian.core.api.Instance;
import org.jboss.arquillian.core.api.annotation.Inject;
import org.jboss.arquillian.test.spi.TestClass;
import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ArchivePaths;
import org.jboss.shrinkwrap.api.Assignable;
import org.jboss.shrinkwrap.api.asset.StringAsset;
import org.jboss.shrinkwrap.api.exporter.ZipExporter;
import org.jboss.shrinkwrap.descriptor.api.Descriptor;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;

public abstract class TomEEContainer<Configuration extends TomEEConfiguration> implements DeployableContainer<Configuration> {
    protected static final Logger LOGGER = Logger.getLogger(TomEEContainer.class.getName());

    protected Configuration configuration;
    protected Map<String, DeployedApp> moduleIds = new HashMap<String, DeployedApp>();
    private final Options options;

    @Inject
    private Instance<TestClass> testClass;

    @Inject
    protected Instance<DeploymentDescription> deployment;

    private ProtocolDescription defaultProtocol;

    protected TomEEContainer() {
        this.options = new Options(System.getProperties());
    }

    public Configuration getConfiguration() {
        return configuration;
    }

    protected void resetSerialization() {
        if (this.configuration.isUnsafeEjbd() && "-".equals(System.getProperty("tomee.serialization.class.blacklist"))) {
            System.clearProperty("tomee.serialization.class.blacklist");
            Setup.reloadClientSerializationConfig();
        }
    }

    protected boolean isTestable(final Archive<?> archive, final DeploymentDescription deploymentDescription) {
        return deploymentDescription != null
                && deploymentDescription.isArchiveDeployment()
                && (deploymentDescription.getArchive() == archive || deploymentDescription.getTestableArchive() == archive)
                && deploymentDescription.testable();
    }

    protected void handlePrefix() {
        final Prefixes prefixes = configuration.getClass().getAnnotation(Prefixes.class);
        if (prefixes == null) {
            return;
        }

        final Properties systemProperties = System.getProperties();
        ConfigurationOverrides.apply(configuration, systemProperties, prefixes.value());

        setPorts();

        // with multiple containers we don't want it so let the user eb able to skip it
        if (configuration.getExportConfAsSystemProperty()) {
            final ObjectMap map = new ObjectMap(configuration);
            //
            // Export the config back out to properties
            //
            for (final Map.Entry<String, Object> entry : map.entrySet()) {
                for (final String prefix : prefixes.value()) {
                    try {
                        final String property = prefix + "." + entry.getKey();
                        final String value = entry.getValue().toString();

                        LOGGER.log(Level.FINER, String.format("Exporting '%s=%s'", property, value));

                        System.setProperty(property, value);
                    } catch (final Throwable e) {
                        // value cannot be converted to a string
                    }
                }
            }
        }
    }

    @Override
    public void setup(final Configuration configuration) {
        this.configuration = configuration;
        this.defaultProtocol = new ProtocolDescription(configuration.getArquillianProtocol());

        handlePrefix();

        ArquillianUtil.preLoadClassesAsynchronously(configuration.getPreloadClasses());
    }

    protected void addArquillianServlet(final Archive<?> archive, final AppInfo appInfo,
                                      final String archiveName, final HTTPContext httpContext) {
        // Avoids "inconvertible types" error in windows build
        if (archiveName.endsWith(".war")) {
            httpContext.add(new Servlet("ArquillianServletRunnerEE9", "/" + getArchiveNameWithoutExtension(archive)));
        } else if (archiveName.endsWith(".ear") && appInfo.webApps.size() > 0) {
            final String contextRoot = System.getProperty("tomee.arquillian.ear.context", configuration.getWebContextToUseWithEars());
            if (contextRoot != null) {
                httpContext.add(new Servlet("ArquillianServletRunnerEE9", ("/" + contextRoot).replace("//", "/")));
            } else {
                for (final WebAppInfo web : appInfo.webApps) { // normally a single webapp is supported cause of arquillian resolution
                    httpContext.add(new Servlet("ArquillianServletRunnerEE9", ("/" + web.contextRoot).replace("//", "/")));
                }
            }
        } else {
            httpContext.add(new Servlet("ArquillianServletRunnerEE9", "/arquillian-protocol")); // needs another jar to add the fake webapp
        }
    }

    protected void setPorts() {
        //
        // Set ports if they are unspecified
        //
        final Collection<Integer> randomPorts = new ArrayList<Integer>();
        for (final int i : configuration.portsAlreadySet()) { // ensure we don't use already initialized port (fixed ones)
            randomPorts.add(i);
        }

        final ObjectMap map = new ObjectMap(configuration);
        for (final Map.Entry<String, Object> entry : map.entrySet()) {
            if (!entry.getKey().toLowerCase().endsWith("port")) {
                continue;
            }
            try {
                final Object value = entry.getValue();
                int port = new Integer(String.valueOf(value));
                if (port <= 0) {
                    int retry = 0;
                    do { // nextPort can in some case returns twice the same port since it doesn't hold the port
                        if (retry++ == Integer.MAX_VALUE) { // really too much, just some protection over infinite loop
                            break;
                        }

                        // ports already set != random port if some port are forced
                        port = nextPort(configuration.getPortRange(), randomPorts);
                    } while (randomPorts.contains(port));

                    entry.setValue(port);
                    randomPorts.add(port);
                }
            } catch (final NumberFormatException mustNotBeAPortConfig) {
                // no-op
            }
        }
        randomPorts.clear();
    }

    private int nextPort(final String portRange, final Collection<Integer> excluded) {
        if (portRange == null || portRange.isEmpty()) {
            int retry = 10;
            while (retry > 0) {
                final int port = NetworkUtil.getNextAvailablePort();
                if (!excluded.contains(port)) {
                    return port;
                }
                retry--;
            }
            throw new IllegalArgumentException("can't find a port available excluding " + excluded);
        }

        if (!portRange.contains("-")) {
            final int port = Integer.parseInt(portRange.trim());
            return NetworkUtil.getNextAvailablePort(new int[]{port});
        }

        final String[] minMax = portRange.trim().split("-");
        final int min = Integer.parseInt(minMax[0]);
        final int max = Integer.parseInt(minMax[1]);
        return NetworkUtil.getNextAvailablePort(min, max, excluded);
    }

    public abstract void start() throws LifecycleException;

    @Override
    public void stop() throws LifecycleException {
        try {
            final Socket socket = new Socket(configuration.getStopHost(), configuration.getStopPort());
            final OutputStream out = socket.getOutputStream();
            out.write((configuration.getStopCommand() + Character.toString((char) 0)).getBytes());

            waitForShutdown(socket, 10);
        } catch (final Exception e) {
            throw new LifecycleException("Unable to stop TomEE", e);
        } finally {
            if (this.configuration.isUnsafeEjbd() && "-".equals(System.getProperty("tomee.serialization.class.blacklist"))) {
                System.clearProperty("tomee.serialization.class.blacklist");
            }
        }
    }

    protected void waitForShutdown(final Socket socket, int tries) {
        try {
            final OutputStream out = socket.getOutputStream();
            out.close();
        } catch (final Exception e) {
            if (tries > 2) {
                Threads.sleep(2000);

                waitForShutdown(socket, --tries);
            }
        } finally {
            if (socket != null && !socket.isClosed()) {
                try {
                    socket.close();
                } catch (final IOException ignored) {
                    // no-op
                }
            }
        }
    }

    @Override
    public ProtocolDescription getDefaultProtocol() {
        return defaultProtocol;
    }

    public void addServlets(final HTTPContext httpContext, final AppInfo appInfo) {
        for (final WebAppInfo webApps : appInfo.webApps) {
            for (final ServletInfo servlet : webApps.servlets) {
                // weird but arquillian url doesn't match the servlet url but its context
                String clazz = servlet.servletClass;
                if (clazz == null) {
                    clazz = servlet.servletName;
                    if (clazz == null) {
                        continue;
                    }
                }

                httpContext.add(new Servlet(clazz, webApps.contextRoot));
                /*
                for (String mapping : servlet.mappings) {
                    httpContext.add(new Servlet(servlet.servletClass, startWithSlash(uniqueSlash(webApps.contextRoot, mapping))));

                }
                */
            }
        }
    }

    @Override
    public ProtocolMetaData deploy(final Archive<?> archive) throws DeploymentException {
        try {
            final Dump dump = dumpFile(archive);
            final File file = dump.getFile();

            final String fileName = file.getName();
            if (dump.isCreated() && (fileName.endsWith(".war") || fileName.endsWith(".ear"))) {
                // extracted folder, TODO: openejb work dir is ignored here
                Files.deleteOnExit(new File(file.getParentFile(), fileName.substring(0, fileName.length() - 4)));
            }

            final AppInfo appInfo;
            final String archiveName = archive.getName();
            try {
                if (dump.isCreated() || !configuration.isSingleDeploymentByArchiveName(archiveName)) {
                    appInfo = doDeploy(archive, file);

                    if (appInfo != null) {
                        moduleIds.put(archiveName, new DeployedApp(appInfo.path, file));
                        Files.deleteOnExit(file); // "i" folder
                    }
                } else {
                    final String path = moduleIds.get(archiveName).path;
                    AppInfo selected = null;
                    for (final AppInfo info : getDeployedApps()) {
                        if (path.equals(info.path)) {
                            selected = info;
                            break;
                        }
                    }
                    appInfo = selected;
                }

                 if (appInfo == null) {
                    LOGGER.severe("appInfo was not found for " + file.getPath() + ", available are: " + apps());
                    throw new OpenEJBException("can't get appInfo");
                }
            } catch (final OpenEJBException re) { // clean up in undeploy needs it
                moduleIds.put(archiveName, new DeployedApp(file.getPath(), file));
                throw re;
            }

            if (options.get("tomee.appinfo.output", false)) {
                Info.marshal(appInfo);
            }

            final HTTPContext httpContext = new HTTPContext(configuration.getHost(), configuration.getHttpPort());

            addArquillianServlet(archive, appInfo, archiveName, httpContext);
            addServlets(httpContext, appInfo);

            return new ProtocolMetaData().addContext(httpContext);
        } catch (final Exception e) {
            throw new DeploymentException("Unable to deploy", e);
        }
    }

    protected Collection<AppInfo> getDeployedApps() throws NamingException {
        return deployer().getDeployedApps();
    }

    protected AppInfo doDeploy(final Archive<?> archive, final File file) throws OpenEJBException, NamingException, IOException {
        AppInfo appInfo;
        final Properties deployerProperties = getDeployerProperties();
        if (deployerProperties == null) {
            appInfo = deployer().deploy(file.getAbsolutePath());
        } else {
            final Properties props = new Properties();
            props.putAll(deployerProperties);

            if ("true".equalsIgnoreCase(deployerProperties.getProperty(DeployerEjb.OPENEJB_USE_BINARIES, "false"))) {
                final byte[] slurpBinaries = IO.slurpBytes(file);
                props.put(DeployerEjb.OPENEJB_VALUE_BINARIES, slurpBinaries);
                props.put(DeployerEjb.OPENEJB_PATH_BINARIES, archive.getName());
            }

            appInfo = deployer().deploy(file.getAbsolutePath(), props);
        }
        return appInfo;
    }

    protected Properties getDeployerProperties() {
        return null;
    }

    protected Dump dumpFile(final Archive<?> archive) {
        final String tmpDir = configuration.getAppWorkingDir();
        Files.deleteOnExit(new File(tmpDir));

        File file;
        if (configuration.isSingleDumpByArchiveName()) {
            file = new File(tmpDir + File.separator + archive.getName());
            Files.deleteOnExit(file);
        } else {
            int i = 0;
            do { // be sure we don't override something existing
                file = new File(tmpDir + File.separator + i++ + File.separator + archive.getName());
            } while (file.getParentFile().exists()); // we will delete the parent (to clean even complicated unpacking)
            Files.deleteOnExit(file.getParentFile());
        }
        if (!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
            LOGGER.warning("can't create " + file.getParent());
        }

        final Assignable finalArchive;
        if (isTestable(archive, deployment.get())) {
            finalArchive = archiveWithTestInfo(archive);
        } else {
            finalArchive = archive;
        }

        long size = -1;
        if (file.exists()) {
            size = file.length();
        }

        final boolean created;
        if (!configuration.isSingleDumpByArchiveName() || !file.exists()) {
            finalArchive.as(ZipExporter.class).exportTo(file, true);
            created = true;
        } else {
            created = false;
        }
        if (size > 0 && size != file.length()) {
            LOGGER.warning("\nFile overwritten but size doesn't match: (now) "
                    + file.length() + "/(before) " + size + " name="+ file.getName()
                    + (configuration.isSingleDumpByArchiveName() ? " maybe set singleDumpByArchiveName to false" : "")
                    + "\n");
        }

        return new Dump(file, created);
    }

    private Collection<String> apps() {
        final Collection<String> paths = new ArrayList<String>();
        try {
            final Collection<AppInfo> appInfos = getDeployedApps();
            for (final AppInfo info : appInfos) {
                paths.add(info.path);
            }
        } catch (final Exception e) { // don't throw an exception just because of this log info
            // no-op
        }
        return paths;
    }

    protected Assignable archiveWithTestInfo(final Archive<?> archive) {
        String name = archive.getName();
        if (name.endsWith(".war") || name.endsWith(".ear")) {
            name = name.substring(0, name.length() - ".war".length());
        }
        return archive.add(
                new StringAsset(testClass.get().getJavaClass().getName() + '#' + name),
                ArchivePaths.create("arquillian-tomee-info.txt"));
    }

    protected Deployer deployer() throws NamingException {
        return lookupDeployerWithRetry(5);
    }

    protected Deployer lookupDeployerWithRetry(final int retry) throws NamingException {
        try {
            final Properties properties = new Properties();
            properties.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.openejb.client.RemoteInitialContextFactory");
            properties.setProperty(Context.PROVIDER_URL, providerUrl());
            return (Deployer) new InitialContext(properties).lookup("openejb/DeployerBusinessRemote");
        } catch (final RuntimeException ne) { // surely "org.apache.openejb.client.ClientRuntimeException: Invalid response from server: -1"
            if (retry > 1) {
                try { // wait a bit before retrying
                    Thread.sleep(200);
                } catch (final InterruptedException ignored) {
                    // no-op
                }
                return lookupDeployerWithRetry(retry - 1);
            }
            if (Boolean.getBoolean("openejb.arquillian.debug") && retry >= 0) {
                try { // wait a lot to be sure that's not a timing issue
                    Thread.sleep(10000);
                } catch (final InterruptedException ignored) {
                    // no-op
                }
                return lookupDeployerWithRetry(-1);
            }
            throw ne;
        }
    }

    protected String providerUrl() {
        return "http://" + configuration.getHost() + ":" + configuration.getHttpPort() + "/tomee/ejb";
    }

    protected String getArchiveNameWithoutExtension(final Archive<?> archive) {
        final String archiveName = archive.getName();
        final int extensionOffset = archiveName.lastIndexOf('.');
        if (extensionOffset >= 0) {
            return archiveName.substring(0, extensionOffset);
        }
        return archiveName;
    }

    @Override
    public void undeploy(final Archive<?> archive) throws DeploymentException {
        final String archiveName = archive.getName();
        if (configuration.isSingleDeploymentByArchiveName(archiveName)) {
            return;
        }

        final DeployedApp deployed = moduleIds.remove(archiveName);
        try {
            if (deployed == null) {
                LOGGER.warning(archiveName + " was not deployed");
                return;
            }
            doUndeploy(deployed);
        } catch (final Exception e) {
            throw new DeploymentException("Unable to undeploy " + archiveName, e);
        } finally {
            if (deployed != null && !configuration.isSingleDumpByArchiveName()) {
                LOGGER.info("cleaning " + deployed.file.getAbsolutePath());
                Files.delete(deployed.file); // "i" folder

                final File pathFile = new File(deployed.path);
                if (!deployed.path.equals(deployed.file.getAbsolutePath()) && pathFile.exists()) {
                    LOGGER.info("cleaning " + pathFile);
                    Files.delete(pathFile);
                }
                final File parentFile = deployed.file.getParentFile();
                final File[] parentChildren = parentFile.listFiles();
                if (parentChildren == null || parentChildren.length == 0) {
                    Files.delete(deployed.file.getParentFile());
                }
            }
        }
    }

    protected void doUndeploy(DeployedApp deployed) throws UndeployException, NoSuchApplicationException, NamingException {
        deployer().undeploy(deployed.path);
    }

    @Override
    public void deploy(final Descriptor descriptor) throws DeploymentException {
        throw new UnsupportedOperationException("Not implemented");
    }

    @Override
    public void undeploy(final Descriptor descriptor) throws DeploymentException {
        throw new UnsupportedOperationException("Not implemented");
    }

    public static class DeployedApp {
        public final File file;
        public final String path;

        public DeployedApp(final String path, final File file) {
            this.path = path;
            this.file = file;
        }
    }

    protected final class Dump {
        private final File file;
        private final boolean created;

        public Dump(final File file, final boolean created) {
            this.file = file;
            this.created = created;
        }

        public File getFile() {
            return file;
        }

        public boolean isCreated() {
            return created;
        }
    }
}
