package com.atlassian.activeobjects.plugin;

import com.atlassian.activeobjects.ActiveObjectsPluginException;
import com.atlassian.activeobjects.EntitiesValidator;
import com.atlassian.activeobjects.admin.PluginInfo;
import com.atlassian.activeobjects.admin.PluginToTablesMapping;
import com.atlassian.activeobjects.config.ActiveObjectsConfiguration;
import com.atlassian.activeobjects.config.ActiveObjectsConfigurationFactory;
import com.atlassian.activeobjects.external.ActiveObjectsUpgradeTask;
import com.atlassian.activeobjects.osgi.OsgiServiceUtils;
import com.atlassian.plugin.Plugin;
import com.atlassian.plugin.PluginParseException;
import com.atlassian.plugin.descriptors.AbstractModuleDescriptor;
import com.atlassian.plugin.module.ContainerManagedPlugin;
import com.atlassian.plugin.module.ModuleFactory;
import com.atlassian.plugin.osgi.factory.OsgiPlugin;
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import net.java.ao.RawEntity;
import net.java.ao.schema.TableNameConverter;
import org.dom4j.Element;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Set;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Lists.newLinkedList;

/**
 * <p>The module descriptor for active objects.</p>
 * <p>This parses the 'ao' module definition and registers a 'bundle specific'
 * {@link com.atlassian.activeobjects.config.ActiveObjectsConfiguration configuration}
 * as an OSGi service.</p>
 * <p>This configuration is then looked up when the active object service is requested by the given bundle
 * through a &lt;component-import ... &gt; module to configure the service appropriately.</p>
 */
public class ActiveObjectModuleDescriptor extends AbstractModuleDescriptor<Object> {

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

    private final ActiveObjectsConfigurationFactory configurationFactory;
    private final OsgiServiceUtils osgiUtils;
    private final EntitiesValidator entitiesValidator;
    private final PluginToTablesMapping pluginToTablesMapping;

    /**
     * The service registration for the active objects configuration, defined by this plugin.
     */
    private ServiceRegistration activeObjectsConfigurationServiceRegistration;
    private ServiceRegistration tableNameConverterServiceRegistration;

    private ActiveObjectsConfiguration configuration;

    ActiveObjectModuleDescriptor(ModuleFactory moduleFactory,
                                 ActiveObjectsConfigurationFactory configurationFactory,
                                 OsgiServiceUtils osgiUtils,
                                 PluginToTablesMapping pluginToTablesMapping,
                                 EntitiesValidator entitiesValidator) {
        super(moduleFactory);
        this.configurationFactory = checkNotNull(configurationFactory);
        this.osgiUtils = checkNotNull(osgiUtils);
        this.pluginToTablesMapping = checkNotNull(pluginToTablesMapping);
        this.entitiesValidator = checkNotNull(entitiesValidator);
    }

    @Override
    public void init(Plugin plugin, Element element) throws PluginParseException {
        super.init(plugin, element);

        final Set<Class<? extends RawEntity<?>>> entities = getEntities(element);
        final List<ActiveObjectsUpgradeTask> upgradeTasks = getUpgradeTasks(element);
        configuration = getActiveObjectsConfiguration(getNameSpace(element), entities, upgradeTasks);

        final Set<Class<? extends RawEntity<?>>> entityClasses = entitiesValidator.check(entities, configuration.getNameConverters());
        recordTables(entityClasses, configuration.getNameConverters().getTableNameConverter());
    }

    private List<ActiveObjectsUpgradeTask> getUpgradeTasks(Element element) {
        final List<Element> upgradeTask = getSubElements(element, "upgradeTask");

        final List<Class<ActiveObjectsUpgradeTask>> classes = Lists.transform(upgradeTask, new Function<Element, Class<ActiveObjectsUpgradeTask>>() {
            @Override
            public Class<ActiveObjectsUpgradeTask> apply(Element utElement) {
                final String upgradeTaskClass = utElement.getText().trim();
                logger.debug("Found upgrade task class <{}>", upgradeTaskClass);
                return getUpgradeTaskClass(upgradeTaskClass);
            }
        });

        if (!(getPlugin() instanceof ContainerManagedPlugin)) {
            throw new ActiveObjectsPluginException("Plugin " + getPlugin().getKey() + " " + getPlugin().getClass().getCanonicalName() + " is not a ContainerManagedPlugin, cannot wire context");
        }
        final ContainerManagedPlugin plugin = (ContainerManagedPlugin) getPlugin();
        return Lists.transform(classes, new Function<Class<ActiveObjectsUpgradeTask>, ActiveObjectsUpgradeTask>() {
            @Override
            public ActiveObjectsUpgradeTask apply(Class<ActiveObjectsUpgradeTask> upgradeTaskClass) {
                return plugin.getContainerAccessor().createBean(upgradeTaskClass);
            }
        });
    }

    private Class<ActiveObjectsUpgradeTask> getUpgradeTaskClass(String upgradeTask) {
        try {
            return getPlugin().loadClass(upgradeTask, getClass());
        } catch (ClassNotFoundException e) {
            throw new ActiveObjectsPluginException(e);
        }
    }

    private void recordTables(final Set<Class<? extends RawEntity<?>>> entityClasses, final TableNameConverter tableNameConverter) {
        pluginToTablesMapping.add(PluginInfo.of(getPlugin()), Lists.transform(newLinkedList(entityClasses), new Function<Class<? extends RawEntity<?>>, String>() {
            @Override
            public String apply(Class<? extends RawEntity<?>> from) {
                return tableNameConverter.getName(from);
            }
        }));
    }

    @Override
    public void enabled() {
        super.enabled();

        if (tableNameConverterServiceRegistration == null) {
            tableNameConverterServiceRegistration = osgiUtils.registerService(getBundle(), TableNameConverter.class, configuration.getNameConverters().getTableNameConverter());
        }
        if (activeObjectsConfigurationServiceRegistration == null) {
            activeObjectsConfigurationServiceRegistration = osgiUtils.registerService(getBundle(), ActiveObjectsConfiguration.class, configuration);
        }
    }

    @Override
    public void disabled() {
        unregister(activeObjectsConfigurationServiceRegistration);
        activeObjectsConfigurationServiceRegistration = null;
        unregister(tableNameConverterServiceRegistration);
        tableNameConverterServiceRegistration = null;
        super.disabled();
    }

    @Override
    public Object getModule() {
        return null; // no module
    }

    public ActiveObjectsConfiguration getConfiguration() {
        return configuration;
    }

    private ActiveObjectsConfiguration getActiveObjectsConfiguration(String namespace, Set<Class<? extends RawEntity<?>>> entities, List<ActiveObjectsUpgradeTask> upgradeTasks) {
        return configurationFactory.getConfiguration(getBundle(), namespace, entities, upgradeTasks);
    }

    private void unregister(ServiceRegistration serviceRegistration) {
        if (serviceRegistration != null) {
            try {
                serviceRegistration.unregister();
            } catch (IllegalStateException ignored) {
                logger.debug("Service has already been unregistered", ignored);
            }
        }
    }

    /**
     * The table name space is either the custom namespace set by the product, or the bundle symbolic name
     *
     * @param element the 'ao' descriptor element
     * @return the name space for names
     */
    private String getNameSpace(Element element) {
        final String custom = element.attributeValue("namespace");
        return custom != null ? custom : getBundle().getSymbolicName();
    }

    private Set<Class<? extends RawEntity<?>>> getEntities(Element element) {
        return Sets.newHashSet(Iterables.transform(getEntityClassNames(element), new Function<String, Class<? extends RawEntity<?>>>() {
            public Class<? extends RawEntity<?>> apply(String entityClassName) {
                return getEntityClass(entityClassName);
            }
        }));
    }

    private Class<? extends RawEntity<?>> getEntityClass(String entityClassName) {
        try {
            return getPlugin().loadClass(entityClassName, getClass());
        } catch (ClassNotFoundException e) {
            throw new ActiveObjectsPluginException(e);
        }
    }

    private Iterable<String> getEntityClassNames(Element element) {
        return Iterables.transform(getSubElements(element, "entity"), new Function<Element, String>() {
            public String apply(Element entityElement) {
                final String entityClassName = entityElement.getText().trim();
                logger.debug("Found entity class <{}>", entityClassName);
                return entityClassName;
            }
        });
    }

    private Bundle getBundle() {
        return ((OsgiPlugin) getPlugin()).getBundle();
    }

    @SuppressWarnings("unchecked")
    private static List<Element> getSubElements(Element element, String name) {
        return element.elements(name);
    }
}