package org.kuali.ole.deliver.drools;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.text.StrSubstitutor;
import org.apache.commons.lang3.StringUtils;
import org.kuali.ole.deliver.bo.drools.DroolsRuleBo;
import org.kuali.rice.core.api.config.property.ConfigContext;

import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.*;

/**
 * Created by pvsubrah on 7/2/15.
 */
public abstract class DroolFileGenerator {

    private List<DroolsRuleBo> droolsRuleBos;

    public List<DroolsRuleBo> getDroolsRuleBos() {
        return droolsRuleBos;
    }

    public void setDroolsRuleBos(List<DroolsRuleBo> droolsRuleBos) {
        this.droolsRuleBos = droolsRuleBos;
    }

    public File generateFile(List<DroolsRuleBo> droolsRuleBos) throws Exception {

        this.droolsRuleBos = droolsRuleBos;

        StringBuilder droolFileContent = new StringBuilder();

        List<Map> customRules = getCustomRules();

        String templateStringForPackageImportTextFile = getTemplateStringForPackageImportTextFile();

        droolFileContent.append(templateStringForPackageImportTextFile).append("\n");

        generateRules(droolFileContent, customRules, false);

        List<Map> customRulesWithParameters = getCustomRulesWithParameters();

        generateRulesWithParameters(droolFileContent, customRulesWithParameters);

        String fileContent = droolFileContent.toString();

        File file = new File(getFileName());
        FileUtils.write(file, fileContent);
        return file;
    }

    private void generateRulesWithParameters(StringBuilder droolFileContent, List<Map> customRulesWithParameters) {
        generateRules(droolFileContent, customRulesWithParameters, true);
    }

    private void generateRules(StringBuilder droolFileContent, List<Map> customRules, boolean parameters) {
        for (Iterator<Map> iterator = customRules.iterator(); iterator.hasNext(); ) {
            Map ruleMap = iterator.next();
            for (Iterator mapIterator = ruleMap.keySet().iterator(); mapIterator.hasNext(); ) {
                String rule = (String) mapIterator.next();

                String templateStringForRule = getTemplateStringForRule();

                String templateStringForAgendaGroup = getTemplateStringForAgendaGroup();

                String templateStringForActivationGroup = getTemplateStringForActivationGroup();

                String templateStringForErrorMessage = getTemplateStringForErrorMessage();

                String templateStringForErrorAndPermissions = getTemplateStringForErrorAndPermissions();

                droolFileContent.append(
                        generateDroolFileContent(
                                templateStringForRule,
                                templateStringForAgendaGroup,
                                templateStringForActivationGroup,
                                rule,
                                (Map) ruleMap.get(rule),
                                templateStringForErrorMessage,
                                templateStringForErrorAndPermissions,
                                parameters));
            }
        }
    }

    private String generateDroolFileContent(String templateStringForRule,
                                            String templateStringForAgendaGroup,
                                            String templateStringForActivationGroup,
                                            String customRule,
                                            Map placeHolderValues,
                                            String templateStringForErrorMessage, String templateStringForErrorAndPermissions, boolean parameters) {
        StringBuilder stringBuilder = new StringBuilder();
        String agendaGroup = getAgendaGroup();
        agendaGroup = "\"" + agendaGroup + "\"";

        Map map = new HashMap();
        map.putAll(placeHolderValues);
        map.put("agendaGroup", agendaGroup);

        StrSubstitutor sub = new StrSubstitutor(map);

        stringBuilder
                .append(sub.replace(templateStringForRule)).append("\n")
                .append(sub.replace(templateStringForAgendaGroup)).append("\n")
                .append(getActivationGroupString(templateStringForActivationGroup, map, sub))
                .append("when").append("\n")
                .append(getCustomRule(customRule, parameters, sub)).append("\n")
                .append(getTemplateStringForError()).append("\n")
                .append("then").append("\n")
                .append(sub.replace(templateStringForErrorMessage)).append("\n")
                .append(getOverridePermissions(templateStringForErrorAndPermissions, map, sub))
                .append("end").append("\n").append("\n");

        return stringBuilder.toString();
    }

    protected String getActivationGroupString(String templateStringForActivationGroup, Map map, StrSubstitutor sub) {
        if (null != map.get("activationGroup")) {
            return sub.replace(templateStringForActivationGroup);
        }
        return "";
    }

    private String getCustomRule(String customRule, boolean parameters, StrSubstitutor sub) {
        if (parameters) {
            return sub.replace(customRule);
        }
        return customRule;
    }

    private String getOverridePermissions(String templateStringForErrorAndPermissions, Map map, StrSubstitutor sub) {
        String replacedString = sub.replace(templateStringForErrorAndPermissions);
        String overridePermissions = !StringUtils.isEmpty((String) map.get("overridePermissions")) ? replacedString : "";
        return overridePermissions;
    }

    private String getTemplateStringForError() {
        String templateStringForError = "";
        URL error = getClass().getResource("error.txt");

        try {
            File errorFile = new File(error.toURI());
            templateStringForError = FileUtils.readFileToString(errorFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForError;
    }

    private String getTemplateStringForErrorAndPermissions() {
        String templateStringForOverridePermissions = "";
        URL errorMessage = getClass().getResource("override-permissions.txt");

        try {
            File errorMessageFile = new File(errorMessage.toURI());
            templateStringForOverridePermissions = FileUtils.readFileToString(errorMessageFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForOverridePermissions;
    }

    private String getTemplateStringForErrorMessage() {
        String templateStringForErrorMessage = "";
        URL errorMessage = getClass().getResource("error-message.txt");

        try {
            File errorMessageFile = new File(errorMessage.toURI());
            templateStringForErrorMessage = FileUtils.readFileToString(errorMessageFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForErrorMessage;
    }

    private String getTemplateStringForActivationGroup() {
        String templateStringForActivationGroup = "";
        URL activationGroup = getClass().getResource("activation-group.txt");
        try {
            File activationGroupFile = new File(activationGroup.toURI());
            templateStringForActivationGroup = FileUtils.readFileToString(activationGroupFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForActivationGroup;
    }

    private String getTemplateStringForAgendaGroup() {
        String templateStringForAgendaGroup = "";
        URL agendaGroup = getClass().getResource("agenda-group.txt");
        try {
            File agendaGroupFile = new File(agendaGroup.toURI());
            templateStringForAgendaGroup = FileUtils.readFileToString(agendaGroupFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForAgendaGroup;
    }

    private String getTemplateStringForRule() {
        String templateStringForRule = "";
        URL rule = getClass().getResource("rule.txt");
        try {
            File ruleFile = new File(rule.toURI());
            templateStringForRule = FileUtils.readFileToString(ruleFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForRule;
    }

    private String getTemplateStringForPackageImportTextFile() {
        String templateStringForPackageImportTextFile = "";
        URL packageImportText = getClass().getResource("package-import.txt");
        try {
            File packageImportTextFile = new File(packageImportText.toURI());
            templateStringForPackageImportTextFile = FileUtils.readFileToString(packageImportTextFile);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return templateStringForPackageImportTextFile;
    }

    public abstract String getFileName();

    protected abstract List<Map> getCustomRules();

    public abstract String getAgendaGroup();

    public abstract String getActivationGroup();

    public abstract List<Map> getCustomRulesWithParameters();

    public abstract boolean isInterested(String value);

    protected String getDroolBaseDirectory() {
        return ConfigContext.getCurrentContextConfig().getProperty("rules.directory");
    }
}