package com.ycl.scheme;

import com.ycl.scheme.entity.BlockCode;
import com.ycl.scheme.entity.Keyword;
import com.ycl.scheme.entity.Scheme;
import com.ycl.scheme.service.SchemeService;
import groovy.lang.GroovyClassLoader;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


@Component

public class SchemeRunnerBuilder {

    private static final String packageName = SchemeRunnerBuilder.class.getPackage().getName();

    private static final String BLOCK_SPLIT_KEY = "数据源";

    private static final String SOURCE_KEY = "数据源";

    private static final String EXPRESSION_KEY = "条件";

    private static final String RESULT_KEY = "结果";


    private  List<Keyword> keywordTemplates;




    private SchemeService schemeService;


    public  SchemeRunnerBuilder(SchemeService schemeService) {
        this.schemeService = schemeService;
    }

    public void build(Scheme scheme) {
        this.keywordTemplates = schemeService.findKeywordTemplates();

        List<BlockText> blockTexts = splitBlock(scheme.getInputText());

        List<BlockCode> blockCodes = this.createBlockCode(blockTexts);

        StringBuilder csb = new StringBuilder();
        csb.append("package " + packageName + ";\n");
        csb.append("import java.util.List;\n");
        csb.append("import java.util.ArrayList;\n");
        csb.append("import java.util.ArrayList;\n");
        csb.append("import com.ycl.scheme.service.SchemeService;\n");
        csb.append("import com.ycl.scheme.AbstractSchemeRunner;\n");
        csb.append("import  java.time.LocalDateTime;\n");
        csb.append("import  java.time.LocalDate;\n");
        csb.append("");
        csb.append("class scheme_" + scheme.getId() + " extends AbstractSchemeRunner {\n");
        csb.append("SchemeService service;\n");
        csb.append("    @Override\n");
        csb.append("    void run(SchemeService service){\n");
        csb.append("        this.service = service;\n");
        csb.append("        "+ this.getConditionText(blockCodes));
//        String cod = this.getCondition(bl);
        String body = "";
        String conditionLine = "        if(";
        for (int i=0;i<blockCodes.size();i++) {
            BlockCode blockCode = blockCodes.get(i);
            conditionLine +=blockCode.getName();
            if(i+1 < blockCodes.size()){
                conditionLine += blockCode.getLogic();
            }else{
                conditionLine +="){\n";
            }
            body += blockCode.getCode();
        }

        csb.append("            service.doAction(" + scheme.getId() + ")\n");
        csb.append("    }\n");

        csb.append("}\n");
        csb.append("\n");
        csb.append(body);
        csb.append("}\n");

        String code = csb.toString();

        scheme.setOutCode(code);

        AbstractSchemeRunner runner = this.createRunner(code);
        scheme.setRunner(runner);



        System.out.println(scheme.getOutCode());
    }

    private boolean  buildTest(){

        return true;
    }

    private String getConditionText(List<BlockCode> blockCodes){
        StringBuilder csb= new StringBuilder();
        csb.append(" if(");

        for(int i=0;i<blockCodes.size();i++){
            BlockCode bc = blockCodes.get(i);
            String logic = "";
            if(i<blockCodes.size()-1){
                logic=bc.getLogic();
            }else{
                logic ="";
            }
            csb.append(bc.getName()+"() " + logic );
        }

        csb.append("){\n");

        return csb.toString();

    }

    private List<BlockCode> createBlockCode(List<BlockText> blockTexts){
        List<BlockCode> blockCodes = new ArrayList<>();
        for(int i=0;i<blockTexts.size();i++){
            BlockText text = blockTexts.get(i);
            BlockCode code = new BlockCode();
            AbstractBlockCodeBuilder builder = null;
            if(StringUtils.isBlank(text.getResult().trim())){
                builder = new CanalTriggerBuilder(text,this.keywordTemplates,i);

            }else{
                builder = new SqlQueryBuilder(text,this.keywordTemplates,i);
            }
            code =builder.build();
            blockCodes.add(code);
        }

        return blockCodes;
    }




    private List<BlockText> splitBlock(String script) {

        String[] blocks = script.split(BLOCK_SPLIT_KEY);

        List<String> res = new ArrayList<>();
        List<BlockText> blockTexts = new ArrayList<>();
        for (String s : blocks) {
            if (StringUtils.isNotBlank(s)) {
                BlockText blockText = new BlockText();
                s = BLOCK_SPLIT_KEY + s;

//                String regex1 = SOURCE_KEY + "\\s*:\\s*(.*?)" +EXPRESSION_KEY;
                String regex1 = SOURCE_KEY + "\\s*:\\s*(.*?)\\s*" + EXPRESSION_KEY;
                String regex2 = EXPRESSION_KEY + "\\s*:\\s*(.*?)\\s*" + RESULT_KEY;
                String regex3 = RESULT_KEY + "\\s*:\\s*(.*?)\\s*\n";

                Pattern p1 = Pattern.compile(regex1);
                Matcher matcher1 = p1.matcher(s);
                if (matcher1.find()) {
                    String m1 = matcher1.group(1);
                    blockText.setSource(m1);
                } else {
                    throw new RuntimeException("数据源的定义");
                }

                Pattern p2 = Pattern.compile(regex2);
                Matcher matcher2 = p2.matcher(s);
                if (matcher2.find()) {
                    String m2 = matcher2.group(1);
                    blockText.setExpression(m2);
                } else {
                    throw new RuntimeException("没有找到条件的定义");
                }

                Pattern p3 = Pattern.compile(regex3);
                Matcher matcher3 = p3.matcher(s);
                if (matcher3.find()) {
                    int idx = matcher3.end();
                    String m3 = matcher3.group(1);
                    blockText.setResult(m3);

                    String logic = s.substring(idx).trim();
                    blockText.setLogic(logic);
                } else {
                    throw new RuntimeException("没有找到结果的定义");
                }

                blockTexts.add(blockText);
            }
        }

        return blockTexts;
    }

    public AbstractSchemeRunner createRunner(String code){
        AbstractSchemeRunner runner =null;
        try{
            GroovyClassLoader classLoader = new GroovyClassLoader();

            Class<AbstractSchemeRunner> runnerClass = classLoader.parseClass(code);

            runner = runnerClass.newInstance();

            return runner;
        }catch (Exception e){
            System.out.println(e.getMessage());
            System.out.println(code);

            throw  new RuntimeException("构建groovy类时发生错误");
        }

    }

}