package Visual_DVM_2021.Passes.All;
import Common.Constants;
import Common.Current;
import Common.Global;
import Common.UI.UI;
import Common.Utils.Utils;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMPackage.DVMPackage_json;
import TestingSystem.DVM.DVMTasks.DVMCompilationTask;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
import Visual_DVM_2021.Passes.Pass_2021;

import java.util.LinkedHashMap;
import java.util.Vector;
public class SaveCurrentDVMPackage extends Pass_2021<DVMPackage> {
    //--
    Vector<Configuration> configurations;
    Vector<Group> groups;
    Vector<Test> tests;
    //--
    Vector<String> configurationsNames;
    Vector<String> groupsNames;
    //--
    LinkedHashMap<Integer, Vector<Test>> testsByGroups;
    int tasks_count;
    Vector<DVMCompilationTask> tasks;
    //--
    @Override
    public String getIconPath() {
        return "/icons/Save.png";
    }
    @Override
    public String getButtonText() {
        return "";
    }
    public static String checkFlags(String flags_in) {
        if (!flags_in.contains("-shared-dvm")) {
            if (flags_in.isEmpty())
                return "-shared-dvm";
            else return flags_in + " -shared-dvm";
        } else
            return flags_in;
    }
    public static String checkEnvironments(String environmentsSet_in) {
        if (!environmentsSet_in.contains("DVMH_NO_DIRECT_COPY")) {
            if (environmentsSet_in.isEmpty())
                return "DVMH_NO_DIRECT_COPY=" + Utils.DQuotes("1");
            else
                return environmentsSet_in + " " + "DVMH_NO_DIRECT_COPY=" + Utils.DQuotes("1");
        } else
            return environmentsSet_in;
    }
    //--
    public Vector<DVMCompilationTask> createTasksCGT(
            Configuration configuration,
            Group group,
            Test test
    ) {
        Vector<DVMCompilationTask> compilationTasks = new Vector<>();
        for (String flags : configuration.getFlags()) {
            String checked_flags = checkFlags(flags);
            DVMCompilationTask dvmCompilationTask = new DVMCompilationTask(
                    configuration,
                    group,
                    test,
                    checked_flags
            );
            Vector<String> matrixes = configuration.getMatrixes(test.max_dim);
            Vector<String> environments = configuration.getEnvironments();
            for (String environmentSet : environments) {
                String checkedEnvironments = checkEnvironments(environmentSet);
                if (flags.trim().equalsIgnoreCase("-s")) {
                    dvmCompilationTask.runTasks.add(new DVMRunTask(
                            configuration,
                            group,
                            test,
                            "",
                            checked_flags,
                            checkedEnvironments,
                            configuration.getParamsText(),
                            target.kernels
                    ));
                    tasks_count++;
                } else
                    for (String matrix : matrixes) {
                        dvmCompilationTask.runTasks.add(new DVMRunTask(
                                configuration,
                                group,
                                test,
                                matrix,
                                checked_flags,
                                checkedEnvironments,
                                configuration.getParamsText(),
                                target.kernels));
                        tasks_count++;
                    }
            }
            compilationTasks.add(dvmCompilationTask);
        }
        return compilationTasks;
    }
    @Override
    protected boolean canStart(Object... args) throws Exception {
        target = null;
        configurations = new Vector<>();
        //---
        groups = new Vector<>();
        tests = new Vector<>();
        //---
        configurationsNames = new Vector<>();
        groupsNames = new Vector<>();
        //---
        tasks_count = 0;
        tasks = new Vector<>();
        testsByGroups = new LinkedHashMap<>();
        //---
        if (!Current.Check(Log, Current.DVMPackage)) return false;
        //--
        target = Current.getDVMPackage();
        if (target.state.isActive()) {
            Log.Writeln_("Возможно редактировать только неактивный пакет!");
            return false;
        }
        for (Configuration configuration : Global.testingServer.db.configurations.getCheckedItems()) {
            configurations.add(configuration);
            configurationsNames.add(configuration.description);
        }
        for (Group group : Global.testingServer.db.groups.getCheckedItems()) {
            groups.add(group);
            groupsNames.add(group.description);
            Vector<Test> groupTests = Global.testingServer.db.tests.getSelectedGroupTests(group);
            tests.addAll(groupTests);
            testsByGroups.put(group.id, groupTests);
        }
        //---
        //создание задач
        for (Configuration configuration : configurations) {
            configurations.add(configuration);
            for (Group group : groups) {
                Vector<Test> groupTests = testsByGroups.get(group.id);
                for (Test test: groupTests){
                    tasks.addAll(createTasksCGT(configuration, group, test));
                }
            }
        }
        //---
        if (tasks.isEmpty()) {
            Log.Writeln_("Не удалось добавить задачи.\n" +
                    "Для создания задач отметьте требуемые конфигурации,\n" +
                    "Отметьте группы, или отдельные тесты в отмеченной текущей группе");
            return false;
        }
        //---
        return UI.Question("Будет создано " + tasks_count + " задач. Продолжить");
    }
    @Override
    protected void body() throws Exception {
        //занесение информации об участвующих группах конфигурациях и тестах
        target.addConfigurations(configurations);
        target.addGroups(groups);
        target.addTests(tests);
        //--
        target.configurationsCount = configurations.size();
        target.groupsCount = groups.size();
        target.testsCount = tests.size();
        //--
        target.configurationsNames = String.join(";", configurationsNames);
        target.groupsNames = String.join(";", groupsNames);
        //---
        target.tasksCount=tasks_count;
        DVMPackage_json json = target.package_json;
        //инициализируем идентификаторы задач.
        for (DVMCompilationTask compilationTask : tasks) {
            //--
            compilationTask.id = json.getMaxTaskId();
            //-
            for (DVMRunTask runTask : compilationTask.runTasks) {
                runTask.id = json.getMaxTaskId();
                runTask.dvmcompilationtask_id = compilationTask.id;
            }
        }
        json.compilationTasks.addAll(tasks);
        //--
        if (target.id != Constants.Nan)
            Global.testingServer.db.Update(target);
    }
    @Override
    protected void showDone() throws Exception {
        Global.testingServer.db.dvmPackages.ShowUI(target.id);
        Global.testingServer.db.dvmRunTasks.ShowDVMPackage(target);
    }
}