/**
 * Logback: the reliable, generic, fast and flexible logging framework.
 * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
 *
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *
 *   or (per the licensee's choosing)
 *
 * under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation.
 */
package ch.qos.logback.core;

import static ch.qos.logback.core.CoreConstants.CONTEXT_NAME_KEY;
import static ch.qos.logback.core.CoreConstants.HOSTNAME_KEY;
import static ch.qos.logback.core.CoreConstants.FA_FILENAME_COLLISION_MAP;
import static ch.qos.logback.core.CoreConstants.RFA_FILENAME_PATTERN_COLLISION_MAP;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;

import ch.qos.logback.core.rolling.helper.FileNamePattern;
import ch.qos.logback.core.spi.LifeCycle;
import ch.qos.logback.core.spi.LogbackLock;
import ch.qos.logback.core.status.StatusManager;
import ch.qos.logback.core.util.ContextUtil;
import ch.qos.logback.core.util.ExecutorServiceUtil;

public class ContextBase implements Context, LifeCycle {

    private long birthTime = System.currentTimeMillis();

    private String name;
    private StatusManager sm = new BasicStatusManager();
    // TODO propertyMap should be observable so that we can be notified
    // when it changes so that a new instance of propertyMap can be
    // serialized. For the time being, we ignore this shortcoming.
    Map<String, String> propertyMap = new HashMap<String, String>();
    Map<String, Object> objectMap = new HashMap<String, Object>();

    LogbackLock configurationLock = new LogbackLock();

    private ScheduledExecutorService scheduledExecutorService;
    protected List<ScheduledFuture<?>> scheduledFutures = new ArrayList<ScheduledFuture<?>>(1);
    private LifeCycleManager lifeCycleManager;
    private boolean started;

    public ContextBase() {
        initCollisionMaps();
    }

    public StatusManager getStatusManager() {
        return sm;
    }

    /**
     * Set the {@link StatusManager} for this context. Note that by default this
     * context is initialized with a {@link BasicStatusManager}. A null value for
     * the 'statusManager' argument is not allowed.
     * <p/>
     * <p> A malicious attacker can set the status manager to a dummy instance,
     * disabling internal error reporting.
     *
     * @param statusManager the new status manager
     */
    public void setStatusManager(StatusManager statusManager) {
        // this method was added in response to http://jira.qos.ch/browse/LBCORE-35
        if (statusManager == null) {
            throw new IllegalArgumentException("null StatusManager not allowed");
        }
        this.sm = statusManager;
    }

    public Map<String, String> getCopyOfPropertyMap() {
        return new HashMap<String, String>(propertyMap);
    }

    public void putProperty(String key, String val) {
        if (HOSTNAME_KEY.equalsIgnoreCase(key)) {
            putHostnameProperty(val);
        } else {
            this.propertyMap.put(key, val);
        }
    }

    protected void initCollisionMaps() {
        putObject(FA_FILENAME_COLLISION_MAP, new HashMap<String, String>());
        putObject(RFA_FILENAME_PATTERN_COLLISION_MAP, new HashMap<String, FileNamePattern>());
    }

    /**
     * Given a key, return the corresponding property value. If invoked with
     * the special key "CONTEXT_NAME", the name of the context is returned.
     *
     * @param key
     * @return
     */
    public String getProperty(String key) {
        if (CONTEXT_NAME_KEY.equals(key))
            return getName();
        if (HOSTNAME_KEY.equalsIgnoreCase(key)) {
            return lazyGetHostname();
        }

        return (String) this.propertyMap.get(key);
    }

    private String lazyGetHostname() {
        String hostname = (String) this.propertyMap.get(HOSTNAME_KEY);
        if (hostname == null) {
            hostname = new ContextUtil(this).safelyGetLocalHostName();
            putHostnameProperty(hostname);
        }
        return hostname;
    }

    private void putHostnameProperty(String hostname) {
        String existingHostname = (String) this.propertyMap.get(HOSTNAME_KEY);
        if (existingHostname == null) {
            this.propertyMap.put(CoreConstants.HOSTNAME_KEY, hostname);
        } else {

        }
    }

    public Object getObject(String key) {
        return objectMap.get(key);
    }

    public void putObject(String key, Object value) {
        objectMap.put(key, value);
    }

    public void removeObject(String key) {
        objectMap.remove(key);
    }

    public String getName() {
        return name;
    }

    public void start() {
        // We'd like to create the executor service here, but we can't;
        // ContextBase has not always implemented LifeCycle and there are *many*
        // uses (mostly in tests) that would need to be modified.
        started = true;
    }

    public void stop() {
        // We don't check "started" here, because the executor service uses
        // lazy initialization, rather than being created in the start method
        stopExecutorService();

        started = false;
    }

    public boolean isStarted() {
        return started;
    }

    /**
     * Clear the internal objectMap and all properties. Removes registered
     * shutdown hook
     */
    public void reset() {

        removeShutdownHook();
        getLifeCycleManager().reset();
        propertyMap.clear();
        objectMap.clear();
    }

    /**
     * The context name can be set only if it is not already set, or if the
     * current name is the default context name, namely "default", or if the
     * current name and the old name are the same.
     *
     * @throws IllegalStateException if the context already has a name, other than "default".
     */
    public void setName(String name) throws IllegalStateException {
        if (name != null && name.equals(this.name)) {
            return; // idempotent naming
        }
        if (this.name == null || CoreConstants.DEFAULT_CONTEXT_NAME.equals(this.name)) {
            this.name = name;
        } else {
            throw new IllegalStateException("Context has been already given a name");
        }
    }

    public long getBirthTime() {
        return birthTime;
    }

    public Object getConfigurationLock() {
        return configurationLock;
    }

    @Override
    /**
     * @deprecated
     */
    public synchronized ExecutorService getExecutorService() {
        return getScheduledExecutorService();
    }

    @Override
    public synchronized ScheduledExecutorService getScheduledExecutorService() {
        if (scheduledExecutorService == null) {
            scheduledExecutorService = ExecutorServiceUtil.newScheduledExecutorService();
        }
        return scheduledExecutorService;
    }

    private synchronized void stopExecutorService() {
        if (scheduledExecutorService != null) {
            ExecutorServiceUtil.shutdown(scheduledExecutorService);
            scheduledExecutorService = null;
        }
    }

    private void removeShutdownHook() {
        Thread hook = (Thread) getObject(CoreConstants.SHUTDOWN_HOOK_THREAD);
        if (hook != null) {
            removeObject(CoreConstants.SHUTDOWN_HOOK_THREAD);
            try {
                Runtime.getRuntime().removeShutdownHook(hook);
            } catch (IllegalStateException e) {
                // if JVM is already shutting down, ISE is thrown
                // no need to do anything else
            }
        }
    }

    public void register(LifeCycle component) {
        getLifeCycleManager().register(component);
    }

    /**
     * Gets the life cycle manager for this context.
     * <p>
     * The default implementation lazily initializes an instance of
     * {@link LifeCycleManager}.  Subclasses may override to provide a custom 
     * manager implementation, but must take care to return the same manager
     * object for each call to this method.
     * <p>
     * This is exposed primarily to support instrumentation for unit testing.
     * 
     * @return manager object 
     */
    synchronized LifeCycleManager getLifeCycleManager() {
        if (lifeCycleManager == null) {
            lifeCycleManager = new LifeCycleManager();
        }
        return lifeCycleManager;
    }

    @Override
    public String toString() {
        return name;
    }

    @Override
    public void addScheduledFuture(ScheduledFuture<?> scheduledFuture) {
        scheduledFutures.add(scheduledFuture);
    }

    public List<ScheduledFuture<?>> getScheduledFutures() {
        return new ArrayList<ScheduledFuture<?>>(scheduledFutures);
    }

}
