Copyright (c) 2006, 2016 Cognos Incorporated, IBM Corporation and others
This program and the accompanying materials are made
available under the terms of the Eclipse Public License 2.0 which
accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
/*******************************************************************************
 * Copyright (c) 2006, 2016 Cognos Incorporated, IBM Corporation and others
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 ******************************************************************************/
package org.eclipse.osgi.internal.log;

import java.util.HashMap;
import java.util.Map;
import org.eclipse.equinox.log.ExtendedLogService;
import org.eclipse.equinox.log.Logger;
import org.eclipse.osgi.internal.log.ExtendedLogServiceFactory.EquinoxLoggerContext;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceReference;
import org.osgi.service.log.FormatterLogger;
import org.osgi.service.log.LoggerConsumer;
import org.osgi.service.log.admin.LoggerContext;

public class ExtendedLogServiceImpl implements ExtendedLogService {

	private final ExtendedLogServiceFactory factory;
	private volatile Bundle bundle;
	private final Map<Class<? extends org.osgi.service.log.Logger>, Map<String, LoggerImpl>> loggerCache = new HashMap<>();
	private final String LOG_SERVICE = "LogService"; //$NON-NLS-1$

	public ExtendedLogServiceImpl(ExtendedLogServiceFactory factory, Bundle bundle) {
		this.factory = factory;
		this.bundle = bundle;
		loggerCache.put(org.osgi.service.log.Logger.class, new HashMap<String, LoggerImpl>());
		loggerCache.put(org.osgi.service.log.FormatterLogger.class, new HashMap<String, LoggerImpl>());
	}

	@SuppressWarnings("deprecation")
	@Override
	public void log(int level, String message) {
		log(null, level, message, null);
	}

	@SuppressWarnings("deprecation")
	@Override
	public void log(int level, String message, Throwable exception) {
		log(null, level, message, exception);
	}

	@SuppressWarnings("deprecation")
	@Override
	public void log(ServiceReference<?> sr, int level, String message) {
		log(sr, level, message, null);
	}

	@SuppressWarnings("deprecation")
	@Override
	public void log(ServiceReference<?> sr, int level, String message, Throwable exception) {
		getLogger((String) null).log(sr, level, message, exception);
	}

	@Override
	public void log(Object context, int level, String message) {
		log(context, level, message, null);
	}

	@Override
	public void log(Object context, int level, String message, Throwable exception) {
		getLogger((String) null).log(context, level, message, exception);
	}

	@Override
	public Logger getLogger(String name) {
		return (Logger) getLogger(name, org.osgi.service.log.Logger.class);
	}

	@Override
	public Logger getLogger(Bundle logBundle, String name) {
		if (logBundle == null || logBundle == bundle)
			return getLogger(name);
		// only check permission if getting another bundles log
		factory.checkLogPermission();
		ExtendedLogService bundleLogService = factory.getLogService(logBundle);
		return bundleLogService.getLogger(name);
	}

	@Override
	public <L extends org.osgi.service.log.Logger> L getLogger(Bundle logBundle, String name, Class<L> loggerType) {
		if (logBundle == null || (logBundle.getState() & (Bundle.INSTALLED | Bundle.UNINSTALLED)) != 0) {
			throw new IllegalArgumentException("The bundle is not resolved: " + logBundle); //$NON-NLS-1$
		}
		ExtendedLogService bundleLogService = factory.getLogService(logBundle);
		return bundleLogService.getLogger(name, loggerType);
	}

	@Override
	public String getName() {
		return getLogger((String) null).getName();
	}

	@Override
	public boolean isLoggable(int level) {
		return getLogger((String) null).isLoggable(level);
	}

	// package private methods called from Logger
	boolean isLoggable(String name, int level) {
		return factory.isLoggable(bundle, name, level);
	}

	void setBundle(Bundle bundle) {
		factory.contextsLock.writeLock().lock();
		try {
			Bundle previous = this.bundle;
			this.bundle = bundle;
			factory.loggerContextTargetMap.replaceSystemBundleLogService(previous, bundle);
		} finally {
			factory.contextsLock.writeLock().unlock();
		}
	}

	Bundle getBundle() {
		return bundle;
	}

	ExtendedLogServiceFactory getFactory() {
		return factory;
	}

	@Override
	public org.osgi.service.log.Logger getLogger(Class<?> clazz) {
		return getLogger(clazz.getName());
	}

	@Override
	public <L extends org.osgi.service.log.Logger> L getLogger(String name, Class<L> loggerType) {
		if (name == null) {
			Bundle current = bundle;
			String bsn = (current == null) ? null : current.getSymbolicName();
			name = (bsn == null) ? LOG_SERVICE : LOG_SERVICE + "." + bsn; //$NON-NLS-1$
		}
		LoggerImpl logger = null;
		Map<String, LoggerImpl> loggers = null;
		factory.contextsLock.readLock().lock();
		try {
			loggers = loggerCache.get(loggerType);
			if (loggers == null) {
				throw new IllegalArgumentException(loggerType.getName());
			}
			logger = loggers.get(name);
		} finally {
			factory.contextsLock.readLock().unlock();
		}
		if (logger == null) {
			LoggerContext loggerContext = factory.loggerContextTargetMap.getEffectiveLoggerContext(bundle);
			if (loggerType == FormatterLogger.class) {
				logger = new FormatterLoggerImpl(this, name, loggerContext);
			} else if (loggerType == org.osgi.service.log.Logger.class) {
				logger = new LoggerImpl(this, name, loggerContext);
			} else {
				throw new IllegalArgumentException(loggerType.getName());
			}
			factory.contextsLock.writeLock().lock();
			try {
				LoggerImpl existing = loggers.get(name);
				if (existing == null) {
					loggers.put(name, logger);
				} else {
					logger = existing;
				}
			} finally {
				factory.contextsLock.writeLock().unlock();
			}
		}
		return loggerType.cast(logger);
	}

	@Override
	public <L extends org.osgi.service.log.Logger> L getLogger(Class<?> clazz, Class<L> loggerType) {
		return getLogger(clazz.getName(), loggerType);
	}

	@Override
	public boolean isTraceEnabled() {
		return getLogger((String) null).isTraceEnabled();
	}

	@Override
	public void trace(String message) {
		getLogger((String) null).trace(message);
	}

	@Override
	public void trace(String format, Object arg) {
		getLogger((String) null).trace(format, arg);
	}

	@Override
	public void trace(String format, Object arg1, Object arg2) {
		getLogger((String) null).trace(format, arg1, arg2);
	}

	@Override
	public void trace(String format, Object... arguments) {
		getLogger((String) null).trace(format, arguments);
	}

	@Override
	public boolean isDebugEnabled() {
		return getLogger((String) null).isDebugEnabled();
	}

	@Override
	public void debug(String message) {
		getLogger((String) null).debug(message);
	}

	@Override
	public void debug(String format, Object arg) {
		getLogger((String) null).debug(format, arg);
	}

	@Override
	public void debug(String format, Object arg1, Object arg2) {
		getLogger((String) null).debug(format, arg1, arg2);
	}

	@Override
	public void debug(String format, Object... arguments) {
		getLogger((String) null).debug(format, arguments);
	}

	@Override
	public boolean isInfoEnabled() {
		return getLogger((String) null).isInfoEnabled();
	}

	@Override
	public void info(String message) {
		getLogger((String) null).info(message);
	}

	@Override
	public void info(String format, Object arg) {
		getLogger((String) null).info(format, arg);
	}

	@Override
	public void info(String format, Object arg1, Object arg2) {
		getLogger((String) null).info(format, arg1, arg2);
	}

	@Override
	public void info(String format, Object... arguments) {
		getLogger((String) null).info(format, arguments);
	}

	@Override
	public boolean isWarnEnabled() {
		return getLogger((String) null).isWarnEnabled();
	}

	@Override
	public void warn(String message) {
		getLogger((String) null).warn(message);
	}

	@Override
	public void warn(String format, Object arg) {
		getLogger((String) null).warn(format, arg);
	}

	@Override
	public void warn(String format, Object arg1, Object arg2) {
		getLogger((String) null).warn(format, arg1, arg2);
	}

	@Override
	public void warn(String format, Object... arguments) {
		getLogger((String) null).warn(format, arguments);
	}

	@Override
	public boolean isErrorEnabled() {
		return getLogger((String) null).isErrorEnabled();
	}

	@Override
	public void error(String message) {
		getLogger((String) null).error(message);
	}

	@Override
	public void error(String format, Object arg) {
		getLogger((String) null).error(format, arg);
	}

	@Override
	public void error(String format, Object arg1, Object arg2) {
		getLogger((String) null).error(format, arg1, arg2);
	}

	@Override
	public void error(String format, Object... arguments) {
		getLogger((String) null).error(format, arguments);
	}

	@Override
	public void audit(String message) {
		getLogger((String) null).audit(message);
	}

	@Override
	public void audit(String format, Object arg) {
		getLogger((String) null).audit(format, arg);
	}

	@Override
	public void audit(String format, Object arg1, Object arg2) {
		getLogger((String) null).audit(format, arg1, arg2);
	}

	@Override
	public void audit(String format, Object... arguments) {
		getLogger((String) null).audit(format, arguments);
	}

	@Override
	public <E extends Exception> void trace(LoggerConsumer<E> consumer) throws E {
		getLogger((String) null).trace(consumer);
	}

	@Override
	public <E extends Exception> void debug(LoggerConsumer<E> consumer) throws E {
		getLogger((String) null).debug(consumer);
	}

	@Override
	public <E extends Exception> void info(LoggerConsumer<E> consumer) throws E {
		getLogger((String) null).info(consumer);
	}

	@Override
	public <E extends Exception> void warn(LoggerConsumer<E> consumer) throws E {
		getLogger((String) null).warn(consumer);
	}

	@Override
	public <E extends Exception> void error(LoggerConsumer<E> consumer) throws E {
		getLogger((String) null).error(consumer);
	}

	void applyLogLevels(EquinoxLoggerContext effectiveLoggerContext) {
		for (Map<String, LoggerImpl> loggers : loggerCache.values()) {
			for (LoggerImpl logger : loggers.values()) {
				logger.applyLoggerContext(effectiveLoggerContext);
			}
		}
	}
}