/**
 *
 * Copyright 2005 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.gbean.kernel.standard;

import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Collections;

import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit;
import edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicLong;
import edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock;
import org.gbean.kernel.ForcedStopException;
import org.gbean.kernel.IllegalServiceStateException;
import org.gbean.kernel.Kernel;
import org.gbean.kernel.KernelOperationInterruptedException;
import org.gbean.kernel.KernelOperationTimoutException;
import org.gbean.kernel.ServiceCondition;
import org.gbean.kernel.ServiceEvent;
import org.gbean.kernel.ServiceFactory;
import org.gbean.kernel.ServiceMonitor;
import org.gbean.kernel.ServiceName;
import org.gbean.kernel.ServiceNotFoundException;
import org.gbean.kernel.ServiceState;
import org.gbean.kernel.StartStrategies;
import org.gbean.kernel.StartStrategy;
import org.gbean.kernel.StopStrategy;
import org.gbean.kernel.UnregisterServiceException;
import org.gbean.kernel.UnsatisfiedConditionsException;
import org.gbean.kernel.InvalidServiceTypeException;

/**
 * The ServiceManager handles the life cycle of a single service.   The manager is responsible for gaurenteeing that
 * all start conditions have been satisfied before the service is constructed, and that all stop conditions have been
 * satisfied before the service is destroyed.  The ServiceManager can be started and stopped several times, but once
 * destroyed no methods may be called.
 *
 * @author Dain Sundstrom
 * @version $Id$
 * @since 1.0
 */
public class ServiceManager implements Comparable {
    /**
     * The kernel in which this service is registered.
     */
    private final Kernel kernel;

    /**
     * The unique id of this service in the kernel.
     */
    private final long serviceId;

    /**
     * The unique name of this service in the kernel.
     */
    private final ServiceName serviceName;

    /**
     * The factory used to create and destroy the service instance.
     */
    private final ServiceFactory serviceFactory;

    /**
     * The type of service this service manager will create.  This value is cached from the serviceFactory.getT
     */
    private final Set serviceTypes;

    /**
     * The class loader for this service.
     */
    private final ClassLoader classLoader;

    /**
     * The monitor to which we fire service events.  The ServiceManager requires an asynchronous monitor becuse events are
     * fired from within the lock.  This helps to reduce complexity but will cause more services to sit in the
     * {@link ServiceState#STARTING} and {@link ServiceState#STOPPING} states since events are propagated in a separate
     * thread.
     */
    private final ServiceMonitor serviceMonitor;

    /**
     * The service context given to the service factory.  This contans a reference to the kernel, serviceName and
     * classloader.
     */
    private final StandardServiceContext standardServiceContext;

    /**
     * Current state of this service.
     */
    private volatile ServiceState state = ServiceState.STOPPED;

    /**
     * The time the service was started or 0 if not started.
     */
    private volatile long startTime;

    /**
     * The {@link ServiceCondition) objects required to be ready before this service can be completely started.
     */
    private AggregateCondition startCondition;

    /**
     * The {@link ServiceCondition) objects required to be ready before this service can be completely stopped.
     */
    private AggregateCondition stopCondition;

    /**
     * The service instance.
     */
    private volatile Object service;

    /**
     * The single lock we use.
     */
    private final ReentrantLock lock = new ReentrantLock();

    /**
     * The maximum duration to wait for the lock.
     */
    private final long timeoutDuration;

    /**
     * The unit of measure for the {@link #timeoutDuration}.
     */
    private final TimeUnit timeoutUnits;

    /**
     * The name of the operation for which the lock is held; this is used in the reentrant exception message.
     */
    private String currentLockHolderOperation = "NOT-HELD";

    /**
     * Sequence number for service event objects.
     */
    private final AtomicLong eventId = new AtomicLong(0);

    /**
     * If true, when start is successful we will startRecusrive all of the services owned by this service.
     */
    private boolean recursive = false;

    /**
     * Creates a service manager for a single service.
     *
     * @param kernel the kernel in which this wraper will be registered
     * @param serviceId the unique id of this service in the kernel
     * @param serviceName the unique name of this service in the kernel
     * @param serviceFactory the factory used to create and destroy the service instance
     * @param classLoader the class loader for this service
     * @param serviceMonitor the monitor of service events
     * @param timeoutDuration the maximum duration to wait for a lock
     * @param timeoutUnits the unit of measure for the timeoutDuration
     */
    public ServiceManager(Kernel kernel,
            long serviceId,
            ServiceName serviceName,
            ServiceFactory serviceFactory,
            ClassLoader classLoader,
            ServiceMonitor serviceMonitor,
            long timeoutDuration,
            TimeUnit timeoutUnits) {

        this.kernel = kernel;
        this.serviceId = serviceId;
        this.serviceName = serviceName;
        this.serviceFactory = serviceFactory;
        this.classLoader = classLoader;
        this.serviceMonitor = serviceMonitor;
        this.timeoutDuration = timeoutDuration;
        this.timeoutUnits = timeoutUnits;
        standardServiceContext = new StandardServiceContext(kernel, serviceName, classLoader);
        serviceTypes = Collections.unmodifiableSet(new LinkedHashSet(Arrays.asList(serviceFactory.getTypes())));
    }

    /**
     * Initializes the service.
     *
     * @throws IllegalServiceStateException if the service is not restartable and is disabled
     * @throws UnsatisfiedConditionsException if the service is not restartable and there were unsatisfied start conditions
     * @throws Exception if the service is not restartable and service construction threw an exception
     * @see Kernel#registerService(ServiceName, ServiceFactory, ClassLoader)
     */
    public void initialize() throws IllegalServiceStateException, UnsatisfiedConditionsException, Exception {
        if (!serviceFactory.isRestartable() && !serviceFactory.isEnabled()) {
            throw new IllegalServiceStateException("A disabled non-restartable service factory can not be initalized", serviceName);
        }

        serviceMonitor.serviceRegistered(createServiceEvent());

        // if we are not restartable, we need to start immediately, otherwise we are not going to register this service
        if (!serviceFactory.isRestartable()) {
            try {
                start(false, StartStrategies.UNREGISTER);
            } catch (UnregisterServiceException e) {
                serviceMonitor.serviceUnregistered(createServiceEvent());
                Throwable cause = e.getCause();
                if (cause instanceof Exception) {
                    throw (Exception) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                } else {
                    throw new AssertionError(cause);
                }
            }

            // a non restartable service uses a special stop conditions object that picks up stop conditions as they
            // are added.  When the stop() method is called on a non-restartable service all of the stop conditions
            // registered with the service factory are initialized (if not already initialized), and the isSatisfied
            // method is called.  This should cause the stop logic of a stop condition to fire.
            lock("initialize");
            try {
                stopCondition = new NonRestartableStopCondition(kernel, serviceName, classLoader, lock, serviceFactory);
            } finally {
                unlock();
            }
        }
    }

    /**
     * Attempts to stop and destroy the service.
     *
     * @param stopStrategy the strategy used to determine how to handle unsatisfied stop conditions
     * @throws IllegalServiceStateException is the service did not stop
     * @throws UnsatisfiedConditionsException if there were unsatisfied stop conditions
     * @see Kernel#unregisterService(ServiceName, StopStrategy)
     */
    public void destroy(StopStrategy stopStrategy) throws IllegalServiceStateException, UnsatisfiedConditionsException {
        // if we are not restartable, we need to stop
        try {
            if (!stop(stopStrategy)) {
                throw new IllegalServiceStateException("Service did not stop", serviceName);
            }
        } catch (UnsatisfiedConditionsException e) {
            throw e;
        }

        if (!serviceFactory.isRestartable()) {
            lock("destroy");
            try {
                if (state != ServiceState.STOPPED) {
                    state = ServiceState.STARTING;
                    serviceMonitor.serviceStopping(createServiceEvent());
                    if (service != null) {
                        try {
                            // destroy the service
                            serviceFactory.destroyService(standardServiceContext);
                        } catch (Throwable e) {
                            serviceMonitor.serviceStopError(createErrorServiceEvent(e));
                        }
                    }

                    destroyAllConditions(serviceMonitor);

                    service = null;
                    startTime = 0;
                    state = ServiceState.STOPPED;
                    serviceMonitor.serviceStopped(createServiceEvent());
                }
            } finally {
                unlock();
            }
        }

        // cool we can unregistered
        serviceMonitor.serviceUnregistered(createServiceEvent());
    }

    /**
     * Gets the unique id of this service in the kernel.
     *
     * @return the unique id of this service in the kernel
     */
    public long getServiceId() {
        return serviceId;
    }

    /**
     * Gets the unique name of this service in the kernel.
     *
     * @return the unique name of this servce in the kernel
     */
    public ServiceName getServiceName() {
        return serviceName;
    }

    /**
     * Gets the types of the service that will be managed by this service manager.
     * @return the types of the service
     */
    public Set getServiceTypes() {
        return serviceTypes;
    }

    /**
     * Gets the factory used to create and destroy the service instance.
     *
     * @return the factory for the service instance
     * @see Kernel#getServiceFactory(ServiceName)
     */
    public ServiceFactory getServiceFactory() {
        return serviceFactory;
    }

    /**
     * Gets the class loader for this service.  This class loader is provided to the service factory in the
     * ServiceContext object.
     *
     * @return the classloader for this service
     * @see Kernel#getClassLoaderFor(ServiceName)
     */
    public ClassLoader getClassLoader() {
        return classLoader;
    }

    /**
     * Gets the service instance.
     *
     * @return the service instance
     * @see Kernel#getService(ServiceName)
     */
    public Object getService() {
        return service;
    }

    /**
     * Gets the current state of this service.
     *
     * @return the current state of this service
     * @see Kernel#getServiceState(ServiceName)
     */
    public ServiceState getState() {
        return state;
    }

    /**
     * Gets the time at which this service entered the STARTING state or 0 if the service is STOPPED.
     *
     * @return the start time or 0 if the service is stopped
     * @see Kernel#getServiceStartTime(ServiceName)
     */
    public long getStartTime() {
        return startTime;
    }

    /**
     * Attempts to starts the service.
     *
     * @param recursive if start is successful should we start recursive the services owned by this servic
     * @param startStrategy the strategy used to determine how to handle unsatisfied start conditions and start errors
     * @throws IllegalServiceStateException if the service is in a state in which it can not be started
     * @throws UnregisterServiceException if the kernel should unregister this service
     * @throws UnsatisfiedConditionsException if there were unsatisfied start conditions
     * @throws Exception it service creation threw an exception
     * @see Kernel#startService(ServiceName)
     * @see Kernel#startServiceRecursive(ServiceName)
     */
    public void start(boolean recursive, StartStrategy startStrategy) throws IllegalServiceStateException, UnregisterServiceException, UnsatisfiedConditionsException, Exception {
        // verify that it is possible to start this service in the current state before obtaining the lock
        if (!verifyStartable(state)) {
            if (recursive) {
                startOwnedServices(startStrategy);
            }
            return;
        }

        boolean shouldStartRecursive = false;
        lock("start");
        try {
            // update the recursive flag
            this.recursive = this.recursive || recursive;

            Throwable startError = null;
            try {
                //
                // Loop until all start conditions have been satified.  The start strategy can break this loop.
                //
                boolean satisfied = false;
                while (!satisfied) {
                    // do we still want to start?
                    if (!verifyStartable(state)) {
                        // assume someone else called startOwnedServices
                        return;
                    }

                    // if we are in the STOPPED state, we need to move to the STARTING state
                    if (state == ServiceState.STOPPED) {
                        // we are now officially starting
                        state = ServiceState.STARTING;
                        serviceMonitor.serviceStarting(createServiceEvent());

                        // initialize the start conditions
                        startCondition = new AggregateCondition(kernel, serviceName, classLoader, lock, serviceFactory.getStartConditions());
                        startCondition.initialize();
                    }

                    // are we satisfied?
                    Set unsatisfiedConditions = startCondition.getUnsatisfied();
                    satisfied = unsatisfiedConditions.isEmpty();
                    if (!satisfied) {
                        // if the stragegy wants us to wait for conditions to be satisfied, it will return true
                        if (startStrategy.waitForUnsatisfiedConditions(serviceName, unsatisfiedConditions)) {
                            // wait for satisfaction and loop
                            startCondition.awaitSatisfaction();
                        } else {
                            // no wait, notify the monitor and exit
                            serviceMonitor.serviceWaitingToStart(createWaitingServiceEvent(unsatisfiedConditions));
                            return;
                        }
                    }
                }

                // we are ready to create the service
                service = serviceFactory.createService(standardServiceContext);

                // verify that the service implements all of the types
                if (service == null) {
                    throw new NullPointerException("Service factory return null from createService for service " + serviceName);
                }
                for (Iterator iterator = serviceTypes.iterator(); iterator.hasNext();) {
                    Class type = (Class) iterator.next();
                    if (!type.isInstance(service)) {
                        throw new InvalidServiceTypeException(serviceName, type, service.getClass());
                    }
                }

                // success transition to running
                startTime = System.currentTimeMillis();
                state = ServiceState.RUNNING;
                serviceMonitor.serviceRunning(createServiceEvent());

                // should we recursively start our children
                shouldStartRecursive = this.recursive || recursive;
                this.recursive = false;
            } catch (UnsatisfiedConditionsException e) {
                // thrown from waitForUnsatisfiedConditions
                throw e;
            } catch (IllegalServiceStateException e) {
                // this can be thrown while awaiting satisfaction
                throw e;
            } catch (Exception e) {
                startError = e;
            } catch (Error e) {
                startError = e;
            }

            if (startError != null) {
                try {
                    if (startError instanceof UnregisterServiceException) {
                        throw (UnregisterServiceException) startError;
                    } else {
                        // the strategy will normally rethrow the startError, but if it doesn't notify the service monitor
                        startStrategy.startError(serviceName, startError);
                        serviceMonitor.serviceStartError(createErrorServiceEvent(startError));
                    }
                } finally {
                    // we are now STOPPING
                    state = ServiceState.STOPPING;
                    serviceMonitor.serviceStopping(createServiceEvent());

                    // clean up the conditons
                    destroyAllConditions(serviceMonitor);

                    // transition to the STOPPED state
                    service = null;
                    startTime = 0;
                    state = ServiceState.STOPPED;
                    serviceMonitor.serviceStopped(createServiceEvent());
                }
            }
        } finally {
            unlock();
        }


        // startRecursive all of the owned services
        if (shouldStartRecursive) {
            startOwnedServices(startStrategy);
        }
    }

    private void startOwnedServices(StartStrategy startStrategy) throws IllegalServiceStateException, UnsatisfiedConditionsException, Exception {
        Set ownedServices = serviceFactory.getOwnedServices();
        if (ownedServices == null) throw new NullPointerException("serviceFactory.getOwnedServices() returned null");
        for (Iterator iterator = ownedServices.iterator(); iterator.hasNext();) {
            ServiceName ownedService = (ServiceName) iterator.next();
            try {
                kernel.startServiceRecursive(ownedService, startStrategy);
            } catch (ServiceNotFoundException ignored) {
                // this is ok -- service unregistered
            } catch (IllegalServiceStateException ignored) {
                // ownedService is disabled or stopping -- anyway we don't care
            }
        }
    }

    /**
     * Verifies that the service is startable.  This can be used out side a lock to avoid unecessary locking.
     *
     * @param state the state of the service
     * @return true if it is possible to start a service in the specifiec state
     * @throws IllegalServiceStateException if it is illegal to start a service in the specified state
     */
    private boolean verifyStartable(ServiceState state) throws IllegalServiceStateException {
        // if we are alredy in the running state, there is nothing to do
        if (state == ServiceState.RUNNING) {
            return false;
        }

        // if we are in the stopping states, that is an error
        if (state == ServiceState.STOPPING) {
            throw new IllegalServiceStateException("A stopping service can not be started", serviceName);
        }

        // is this service enabled?
        if (state == ServiceState.STOPPED && !serviceFactory.isEnabled()) {
            throw new IllegalServiceStateException("Service is disabled", serviceName);
        }

        return true;
    }

    /**
     * Attempts to stop the service.
     *
     * @param stopStrategy the strategy used to determine how to handle unsatisfied stop conditions
     * @return true if the service was sucessfully stopped; false otherwise
     * @throws UnsatisfiedConditionsException if there were unsatisfied stop conditions
     * @see Kernel#stopService(ServiceName)
     */
    public boolean stop(StopStrategy stopStrategy) throws UnsatisfiedConditionsException {
        // check that we aren't already stopped before attempting to acquire the lock
        ServiceState initialState = state;
        if (initialState == ServiceState.STOPPED) {
            return true;
        }

        lock("stop");
        try {
            try {
                //
                // Loop until all stop conditions have been satified.  The stop strategy can break this loop.
                //
                boolean satisfied = false;
                while (!satisfied) {
                    // do we still want to stop?
                    if (state == ServiceState.STOPPED) {
                        return true;
                    }

                    // if we are not the STOPPING state, transition to it
                    // we check on the stopConditions variable because non-restartable services preset this in the
                    // intialization method
                    if (stopCondition == null) {
                        // we are not officially stopping
                        serviceMonitor.serviceStopping(createServiceEvent());
                        state = ServiceState.STOPPING;

                        // initialize all of the stop conditions
                        stopCondition = new AggregateCondition(kernel, serviceName, classLoader, lock, serviceFactory.getStopConditions());
                        stopCondition.initialize();
                    }

                    // are we satisfied?
                    Set unsatisfiedConditions = stopCondition.getUnsatisfied();
                    satisfied = unsatisfiedConditions.isEmpty();
                    if (!satisfied) {
                        // if the stragegy wants us to wait for conditions to be satisfied, it will return true
                        if (stopStrategy.waitForUnsatisfiedConditions(serviceName, unsatisfiedConditions)) {
                            // wait for satisfaction and loop
                            stopCondition.awaitSatisfaction();
                        } else {
                            // no wait, notify the monitor and exit
                            serviceMonitor.serviceWaitingToStop(createWaitingServiceEvent(unsatisfiedConditions));
                            return false;
                        }
                    }
                }
            } catch (UnsatisfiedConditionsException e) {
                throw e;
            } catch (ForcedStopException e) {
                serviceMonitor.serviceStopError(createErrorServiceEvent(e));
            } catch (Exception e) {
                serviceMonitor.serviceStopError(createErrorServiceEvent(e));
            } catch (Error e) {
                serviceMonitor.serviceStopError(createErrorServiceEvent(e));
            }

            if (serviceFactory.isRestartable()) {
                if (service != null) {
                    try {
                        // destroy the service
                        serviceFactory.destroyService(standardServiceContext);
                    } catch (Throwable e) {
                        serviceMonitor.serviceStopError(createErrorServiceEvent(e));
                    }
                }

                destroyAllConditions(serviceMonitor);

                service = null;
                startTime = 0;
                state = ServiceState.STOPPED;
                serviceMonitor.serviceStopped(createServiceEvent());
            }
            return true;
        } finally {
            unlock();
        }
    }

    private void destroyAllConditions(ServiceMonitor monitor) {
        if (!lock.isHeldByCurrentThread()) {
            throw new IllegalStateException("Current thread must hold lock before calling destroyAllConditions");
        }

        if (startCondition != null) {
            List errors = startCondition.destroy();
            // errors from destroying the start conditions are stop errors because destroy is only called while
            // stopping the service
            for (Iterator iterator = errors.iterator(); iterator.hasNext();) {
                Throwable stopError = (Throwable) iterator.next();
                monitor.serviceStopError(createErrorServiceEvent(stopError));
            }
            startCondition = null;
        }
        if (stopCondition != null) {
            List errors = stopCondition.destroy();
            for (Iterator iterator = errors.iterator(); iterator.hasNext();) {
                Throwable stopError = (Throwable) iterator.next();
                monitor.serviceStopError(createErrorServiceEvent(stopError));
            }
            stopCondition = null;
        }
    }

    /**
     * Obtain the lock for the specified operation.
     *
     * @param operationName name of the operation that lock will be used for - this is only used for exception messages
     * @throws IllegalStateException if thread tries to reenter while holding the lock
     * @throws KernelOperationTimoutException if lock could not be obtained in {@link #timeoutDuration} {@link #timeoutUnits}
     * @throws KernelOperationInterruptedException if the thread was interrupted while waiting for the lock
     */
    private void lock(String operationName) throws IllegalStateException, KernelOperationTimoutException, KernelOperationInterruptedException {
        if (lock.isHeldByCurrentThread()) {
            throw new IllegalStateException("Current thread holds lock for " + currentLockHolderOperation +
                    " and lock can not be reacquired for " + operationName + " on " + serviceName);
        }

        try {
            if (!lock.tryLock(timeoutDuration, timeoutUnits)) {
                throw new KernelOperationTimoutException("Could not obtain lock for " + operationName + " operation on " +
                        serviceName + " within " + timeoutDuration + " " + timeoutUnits.toString().toLowerCase(),
                        serviceName,
                        operationName);
            }
            currentLockHolderOperation = operationName;
        } catch (InterruptedException e) {
            throw new KernelOperationInterruptedException("Interrupted while attempting to obtain lock for " + operationName +
                    " operation on " + serviceName,
                    e,
                    serviceName,
                    operationName);

        }
    }

    /**
     * Unlock the lock and clear the currentLockHolderOperation name.
     */
    private void unlock() {
        if (!lock.isHeldByCurrentThread()) {
            throw new IllegalMonitorStateException("Not owner");
        }

        currentLockHolderOperation = "NOT-HELD";
        lock.unlock();
    }

    private ServiceEvent createServiceEvent() {
        return new ServiceEvent(eventId.getAndIncrement(), kernel, serviceName, serviceFactory, classLoader, service, null, null);
    }

    private ServiceEvent createWaitingServiceEvent(Set unsatisfiedConditions) {
        return new ServiceEvent(eventId.getAndIncrement(), kernel, serviceName, serviceFactory, classLoader, service, null, unsatisfiedConditions);
    }

    private ServiceEvent createErrorServiceEvent(Throwable cause) {
        return new ServiceEvent(eventId.getAndIncrement(), kernel, serviceName, serviceFactory, classLoader, null, cause, null);
    }

    public int hashCode() {
        return (int) (serviceId ^ (serviceId >>> 32));
    }

    public boolean equals(Object o) {
        if (o instanceof ServiceManager) {
            return serviceId == ((ServiceManager)o).serviceId;
        }
        return false;
    }

    public int compareTo(Object o) {
        ServiceManager serviceManager = (ServiceManager) o;

        if (serviceId < serviceManager.serviceId) {
            return -1;
        } else if (serviceId > serviceManager.serviceId) {
            return 1;
        } else {
            return 0;
        }
    }

    public String toString() {
        return "[ServiceManager: serviceId=" + serviceId + ", serviceName=" + serviceName + ", state=" + state + "]";
    }
}