package org.jenkinsci.plugins.activemq;

import hudson.Extension;
import hudson.Plugin;
import hudson.model.AbstractProject;
import hudson.model.Build;
import hudson.model.Cause;
import hudson.model.CauseAction;
import hudson.model.ParametersAction;
import hudson.model.TaskListener;
import jenkins.model.GlobalConfiguration;
import jenkins.model.Jenkins;
import jenkins.util.TimeDuration;
import org.slf4j.Logger;

import javax.annotation.Nonnull;
import javax.jms.JMSException;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import java.net.URISyntaxException;
import java.util.Map;

import static org.slf4j.LoggerFactory.getLogger;

@Extension
public class ActiveMqPlugin extends Plugin implements ActiveMqClient.BuildRequestListener /*implements ReconfigurableDescribable<ActiveMqPlugin>*/ {

    private static final Logger log = getLogger(ActiveMqPlugin.class);

    private transient ActiveMqClient client;
    private transient ScriptEngineManager scriptEngineManager;

    @Override
    public void start() throws Exception {
        // Use null as the class loader to get only the script engined defined by the JDK. With out it only the
        // Groovy engine was exposed.
        scriptEngineManager = new ScriptEngineManager(null);

        reconfigure();
    }

    public void postInitialize() throws Exception {
        log.info("ActiveMqPlugin.postInitialize");
        reconfigure();
    }

    public void onCompleted(Build build, @Nonnull TaskListener listener) {
        log.info("ActiveMqPlugin.onCompleted: listener={}", listener);
        @SuppressWarnings("unchecked") Map<String, String> buildVariables = build.getBuildVariables();
        log.info("Build variables");
        for (Map.Entry<String, String> e : buildVariables.entrySet()) {
            log.info(e.getKey() + " = " + e.getValue());
        }

        log.info("client = " + client);
        if (client == null) {
            log.debug("client is null");
            return;
        }

        client.sendMessage(build.getProject().getName(), build.getNumber(), build.getResult().toString());
    }

    public void reconfigure() {
        log.info("ActiveMqPlugin.reconfigure");
        ActiveMqGlobalConfig config = GlobalConfiguration.all().get(ActiveMqGlobalConfig.class);
        log.info("config = " + config);
        if (config == null) {
            return;
        }
        String brokerUrl = config.getBrokerUrl();
        boolean enable = config.isEnable();

        if (enable) {
            if (client != null && !client.brokerUrl.equals(brokerUrl)) {
                log.info("Disposing current JMS client.");
                client.close();
                client = null;
            }

            log.info("Creating client of broker {}", brokerUrl);
            try {
                client = new ActiveMqClient(brokerUrl, config.getTopicName(), this);
            } catch (JMSException e) {
                log.warn("Unable to connect to queue");
            } catch (URISyntaxException e) {
                log.warn("Unable to connect to queue");
            }
        } else {
            if (client != null) {
                log.info("Disposing current JMS client.");
                client.close();
                client = null;
            }
        }
    }

    @Override
    public void onBuildRequest(ActiveMqClient.BuildRequest req) {
        log.info("ActiveMqPlugin.onBuildRequest");
        log.info(req.parameters.toString());

        for (AbstractProject project : Jenkins.getInstance().getAllItems(AbstractProject.class)) {
            log.info("Checking project " + project.getDisplayName());
            ActiveMqBuildTrigger trigger = (ActiveMqBuildTrigger) project.getTrigger(ActiveMqBuildTrigger.class);

            if (trigger == null) {
                log.debug("No trigger configured");
                continue;
            }

            DoBuildResponse doBuildResponse = trigger.matches(req);
            if (doBuildResponse instanceof DoBuildResponse.NoBuild) {
                log.debug("Trigger did not match");
            } else {
                log.debug("Trigger matched: {}", doBuildResponse.getClass().getSimpleName());

                if (doBuildResponse instanceof DoBuildResponse.BuildWithParameters && project.isParameterized()) {
                    DoBuildResponse.BuildWithParameters buildWithParameters = (DoBuildResponse.BuildWithParameters) doBuildResponse;

                    TimeDuration delay = new TimeDuration(project.getQuietPeriod());

                    ParametersAction parametersAction = new ParametersAction(buildWithParameters.parameters);
                    CauseAction causeAction = new CauseAction(new ActiveMqCause());

                    Jenkins.getInstance().getQueue().schedule(project, delay.getTime(), parametersAction, causeAction);
                } else {
                    project.scheduleBuild(new ActiveMqCause());
                }
            }
        }
    }

    public static class ActiveMqCause extends Cause {
        @Override
        public String getShortDescription() {
            return "ActiveMQ cause";
        }
    }

    /**
     * Used by other parts of the plugin.
     */
    public ScriptEngine createEngine() {
        ScriptEngine engine = scriptEngineManager.getEngineByName("JavaScript");
        if (engine == null) {
            throw new RuntimeException("Unable to create script engine");
        }
        return engine;
    }
}