/*
 * 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.sling.installer.factories.subsystems.impl;

import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import org.apache.sling.installer.api.InstallableResource;
import org.apache.sling.installer.api.tasks.ChangeStateTask;
import org.apache.sling.installer.api.tasks.InstallTask;
import org.apache.sling.installer.api.tasks.InstallTaskFactory;
import org.apache.sling.installer.api.tasks.RegisteredResource;
import org.apache.sling.installer.api.tasks.ResourceState;
import org.apache.sling.installer.api.tasks.ResourceTransformer;
import org.apache.sling.installer.api.tasks.TaskResource;
import org.apache.sling.installer.api.tasks.TaskResourceGroup;
import org.apache.sling.installer.api.tasks.TransformationResult;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.Version;
import org.osgi.service.subsystem.Subsystem;
import org.osgi.service.subsystem.Subsystem.State;
import org.osgi.service.subsystem.SubsystemConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This is an extension for the OSGi installer
 * It listens for files ending with ".esa" and a proper subsystem manifest.
 * Though subsystems does not require a complete manifest, the installer supports
 * only subsystems with the basic info (name and version).
 *
 * As subsystems currently do not support an update, an uninstall/install is done
 * instead - which will lose bundle private data, bound configurations etc.
 */
public class SubsystemInstaller
    implements ResourceTransformer, InstallTaskFactory {

    private static final String TYPE_SUBSYSTEM = "esa";

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private final Subsystem rootSubsystem;

    private final BundleContext bundleContext;

    public SubsystemInstaller(final Subsystem root, final BundleContext bundleContext) {
        this.rootSubsystem = root;
        this.bundleContext = bundleContext;
    }

    /**
     * @see org.apache.sling.installer.api.tasks.ResourceTransformer#transform(org.apache.sling.installer.api.tasks.RegisteredResource)
     */
    public TransformationResult[] transform(final RegisteredResource resource) {
        if ( resource.getType().equals(InstallableResource.TYPE_FILE) ) {
            if ( resource.getURL().endsWith("." + TYPE_SUBSYSTEM) ) {
                logger.info("Found potential subsystem resource {}", resource);
                final SubsystemInfo headers = readSubsystemHeaders(resource);
                if ( headers != null ) {
                    // check the version for validity
                    boolean validVersion = true;
                    try {
                        new Version(headers.version);
                    } catch (final IllegalArgumentException iae) {
                        logger.info("Rejecting subsystem {} from {} due to invalid version information: {}.",
                                new Object[] {headers.symbolicName, resource, headers.version});
                        validVersion = false;
                    }
                    if ( validVersion ) {
                        final Map<String, Object> attr = new HashMap<String, Object>();
                        attr.put(SubsystemConstants.SUBSYSTEM_SYMBOLICNAME, headers.symbolicName);
                        attr.put(SubsystemConstants.SUBSYSTEM_VERSION, headers.version);

                        final TransformationResult tr = new TransformationResult();
                        tr.setId(headers.symbolicName);
                        tr.setResourceType(TYPE_SUBSYSTEM);
                        tr.setAttributes(attr);
                        tr.setVersion(new Version(headers.version));

                        return new TransformationResult[] {tr};
                    }

                } else {
                    logger.info("Subsystem resource does not have required headers.");
                }
            }
        }
        return null;
    }

    /**
     * Check that the required attributes are available.
     * This is just a sanity check
     */
    private SubsystemInfo checkResource(final TaskResourceGroup toActivate) {
        final TaskResource rsrc = toActivate.getActiveResource();

        SubsystemInfo result = null;
        final String symbolicName = (String) rsrc.getAttribute(SubsystemConstants.SUBSYSTEM_SYMBOLICNAME);
        if ( symbolicName == null ) {
            logger.error("Subsystem resource is missing symbolic name {}", rsrc);
        } else {
            final String version = (String)rsrc.getAttribute(SubsystemConstants.SUBSYSTEM_VERSION);
            if ( version == null ) {
                logger.error("Subsystem resource is missing version {}", rsrc);
            } else {
                // check the version for validity
                boolean validVersion = true;
                try {
                    new Version(version);
                } catch (final IllegalArgumentException iae) {
                    logger.info("Rejecting subsystem {} from {} due to invalid version information: {}.",
                            new Object[] {symbolicName, rsrc, version});
                    validVersion = false;
                }
                if ( validVersion ) {
                    result = new SubsystemInfo();
                    result.symbolicName = symbolicName;
                    result.version = version;
                }
            }
        }
        return result;
    }

    private ServiceReference<Subsystem> getSubsystemReference(final String symbolicName) {
        // search a subsystem with the symbolic name
        ServiceReference<Subsystem> ref = null;
        try {
            final Collection<ServiceReference<Subsystem>> refs = this.bundleContext.getServiceReferences(Subsystem.class, "(subsystem.symbolicName=" + symbolicName + ")");
            if ( refs.size() > 0 ) {
                ref = refs.iterator().next();
            }
        } catch (final InvalidSyntaxException e) {
            logger.error("Problem searching for subsystem with symbolic name " + symbolicName, e);
        }
        return ref;
    }

    /**
     * @see org.apache.sling.installer.api.tasks.InstallTaskFactory#createTask(org.apache.sling.installer.api.tasks.TaskResourceGroup)
     */
    public InstallTask createTask(final TaskResourceGroup toActivate) {
        final InstallTask result;

        final TaskResource rsrc = toActivate.getActiveResource();
        if ( rsrc.getType().equals(TYPE_SUBSYSTEM) ) {

            // check if the required info is available
            final SubsystemInfo info = checkResource(toActivate);
            if ( info == null ) {
                // ignore as info is missing
                result = new ChangeStateTask(toActivate, ResourceState.IGNORED);
            } else {
                // search a subsystem with the symbolic name
                final ServiceReference<Subsystem> ref = this.getSubsystemReference(info.symbolicName);

                final Subsystem currentSubsystem = (ref != null ? this.bundleContext.getService(ref) : null);
                try {
                    final Version newVersion = new Version(info.version);
                    final Version oldVersion = (ref == null ? null : (Version)ref.getProperty("subsystem.version"));

                    // Install
                    if ( rsrc.getState() == ResourceState.INSTALL ) {
                        if ( oldVersion != null ) {

                            final int compare = oldVersion.compareTo(newVersion);
                            if (compare < 0) {
                                // installed version is lower -> update
                                result = new UpdateSubsystemTask(toActivate, this.bundleContext, ref, this.rootSubsystem);
                            } else if ( compare == 0 && isSnapshot(newVersion) ) {
                                // same version but snapshot -> update
                                result = new UpdateSubsystemTask(toActivate, this.bundleContext, ref, this.rootSubsystem);
                            } else if ( compare == 0 && currentSubsystem != null && currentSubsystem.getState() != State.ACTIVE ) {
                                // try to start the version
                                result = new StartSubsystemTask(toActivate, currentSubsystem);
                            } else {
                                logger.info("{} is not installed, subsystem with same or higher version is already installed: {}", info, newVersion);
                                result = new ChangeStateTask(toActivate, ResourceState.IGNORED);
                            }
                        } else {
                            result = new InstallSubsystemTask(toActivate, this.rootSubsystem);
                        }

                    // Uninstall
                    } else if ( rsrc.getState() == ResourceState.UNINSTALL ) {
                        if ( oldVersion == null ) {
                            logger.error("Nothing to uninstall. {} is currently not installed.", info);
                            result = new ChangeStateTask(toActivate, ResourceState.IGNORED);
                        } else {

                            final int compare = oldVersion.compareTo(newVersion);
                            if ( compare == 0 ) {
                                result = new UninstallSubsystemTask(toActivate, this.bundleContext, ref);
                            } else {
                                logger.error("Nothing to uninstall. {} is currently not installed, different version is installed {}", info, oldVersion);
                                result = new ChangeStateTask(toActivate, ResourceState.IGNORED);
                            }
                        }
                    } else {
                        result = null;
                    }
                } finally {
                    if ( currentSubsystem != null ) {
                        this.bundleContext.ungetService(ref);
                    }
                }
            }
        } else {
            result = null;
        }
        return result;
    }

    /**
     * Read the manifest from supplied input stream, which is closed before return.
     */
    private static Manifest getManifest(final RegisteredResource rsrc, final Logger logger)
    throws IOException {
        final InputStream ins = rsrc.getInputStream();

        Manifest result = null;

        if ( ins != null ) {
            ZipInputStream jis = null;
            try {
                jis = new ZipInputStream(ins);

                ZipEntry entry;

                while ( (entry = jis.getNextEntry()) != null ) {
                    if (entry.getName().equals("OSGI-INF/SUBSYSTEM.MF") ) {
                        result = new Manifest(jis);
                    }
                }

            } finally {

                // close the jar stream or the input stream, if the jar
                // stream is set, we don't need to close the input stream
                // since closing the jar stream closes the input stream
                if (jis != null) {
                    try {
                        jis.close();
                    } catch (IOException ignore) {
                    }
                } else {
                    try {
                        ins.close();
                    } catch (IOException ignore) {
                    }
                }
            }
        }
        return result;
    }

    final static public class SubsystemInfo {
        public String symbolicName;
        public String version;
        @Override

        public String toString() {
            return "Subsystem[symbolicName=" + symbolicName + ", version="
                    + version + "]";
        }

    }

    /**
     * Read the subsystem info from the manifest (if available)
     */
    private SubsystemInfo readSubsystemHeaders(final RegisteredResource resource) {
        try {
            final Manifest m = SubsystemInstaller.getManifest(resource, logger);
            if (m != null) {
                final String sn = m.getMainAttributes().getValue(SubsystemConstants.SUBSYSTEM_SYMBOLICNAME);
                if (sn != null) {
                    final String v = m.getMainAttributes().getValue(SubsystemConstants.SUBSYSTEM_VERSION);
                    final int paramPos = sn.indexOf(';');
                    final String symbolicName = (paramPos == -1 ? sn : sn.substring(0, paramPos));
                    final SubsystemInfo headers = new SubsystemInfo();
                    headers.symbolicName = symbolicName;
                    headers.version = v;

                    // if no version is specified, use default version
                    if ( headers.version == null ) {
                        headers.version = "0.0.0.0";
                    }
                    return headers;
                }
            }
        } catch (final IOException ignore) {
            // ignore
        }
        return null;
    }

    private static final String MAVEN_SNAPSHOT_MARKER = "SNAPSHOT";

    /**
     * Check if the version is a snapshot version
     */
    public static boolean isSnapshot(final Version v) {
        return v.toString().indexOf(MAVEN_SNAPSHOT_MARKER) >= 0;
    }
}