package org.jenkinsci.plugins.activemq;

import hudson.Extension;
import hudson.model.AbstractProject;
import hudson.model.BuildableItem;
import hudson.model.Item;
import hudson.triggers.Trigger;
import hudson.triggers.TriggerDescriptor;
import hudson.util.FormValidation;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.QueryParameter;
import org.slf4j.Logger;

import java.io.Serializable;
import java.util.Map;
import java.util.TreeMap;

import static java.util.Collections.singletonMap;
import static org.apache.commons.lang.StringUtils.trimToNull;
import static org.jenkinsci.plugins.activemq.ActiveMqClient.BuildRequest;
import static org.mvel2.MVEL.compileExpression;
import static org.mvel2.MVEL.executeExpression;
import static org.slf4j.LoggerFactory.getLogger;

public class ActiveMqBuildTrigger extends Trigger<AbstractProject> {

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

    private String mvel;

    private transient Serializable compiledMvel;

    @DataBoundConstructor
    public ActiveMqBuildTrigger(String mvel) {
        log.info("ActiveMqBuildTrigger.ActiveMqBuildTrigger");
        this.mvel = mvel;
    }

    @Override
    public void start(AbstractProject project, boolean newInstance) {
        super.start(project, newInstance);
        log.info("ActiveMqBuildTrigger.start");
        compileMvel();
    }

    public String getMvel() {
        log.info("ActiveMqBuildTrigger.getMvel");
        return mvel;
    }

    public void setMvel(String mvel) {
        this.mvel = mvel;
    }

    private void setMvel_(String mvel) {
        mvel = trimToNull(mvel);
        if (mvel == null) {
            log.info("ActiveMqBuildTrigger.setMvel_: mvel is null");
            this.mvel = null;
            this.compiledMvel = null;
            return;
        }

        compileMvel();
    }

    private void compileMvel() {
        try {
            compiledMvel = compileExpression(mvel);
            log.info("ActiveMqBuildTrigger.compileMvel: mvel={}", mvel);
        } catch (Exception e) {
            log.warn("Unable to compile MVEL", e);
        }
    }

//    public FormValidation doCheckMvel(@QueryParameter String mvel) {
//        log.info("ActiveMqBuildTrigger.doCheckMvel");
//        mvel = trimToNull(mvel);
//        if (mvel == null) {
//            return FormValidation.ok();
//        }
//        try {
//            compileExpression(mvel);
//            return FormValidation.ok();
//        } catch (Exception e) {
//            log.info("Unable to compile MVEL: " + mvel, e);
//            return FormValidation.error(e, "Unable to compile MVEL");
//        }
//    }

//    public Serializable getCompiledMvel() {
//        return compiledMvel;
//    }

    public boolean matches(BuildRequest req) {
        if (compiledMvel == null) {
            return false;
        }

        Map<String, String> parameters = new TreeMap<String, String>(req.parameters);
        Map<String, Map<String, String>> context = singletonMap("parameters", parameters);
        try {
            Boolean b = executeExpression(compiledMvel, context, Boolean.class);

            return b != null && b;
        } catch (Exception e) {
            log.warn("Could not evaluate expression");
            log.warn("Expression = {}", mvel);
            log.warn("Context:");
            for (Map.Entry<String, Map<String, String>> entry : context.entrySet()) {
                log.warn("{} = {}", entry.getKey(), entry.getValue());
            }
            log.warn("Exception", e);
            return false;
        }
    }

    @Extension
    public static class DescriptorImpl extends TriggerDescriptor {

        @Override
        public boolean isApplicable(Item item) {
            return item instanceof BuildableItem;
        }

        @Override
        public String getDisplayName() {
            return "ActiveMQ Trigger";
        }
    }
}