package eu.eudat.migration.services;

import eu.eudat.logic.managers.AdminManager;
import eu.eudat.logic.managers.MetricsManager;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.migration.dao.TemplateRepository;
import eu.eudat.migration.dao.UserRepository;
import eu.eudat.migration.entities.*;
import eu.eudat.models.data.admin.components.datasetprofile.Field;
import eu.eudat.models.data.admin.components.datasetprofile.FieldSet;
import eu.eudat.models.data.admin.components.datasetprofile.Page;
import eu.eudat.models.data.admin.components.datasetprofile.Section;
import eu.eudat.models.data.admin.composite.DatasetProfile;
import eu.eudat.models.data.components.commons.DefaultValue;
import eu.eudat.models.data.components.commons.Multiplicity;
import eu.eudat.models.data.components.commons.ViewStyle;
import eu.eudat.models.data.components.commons.Visibility;
import eu.eudat.models.data.datasetprofile.DatasetProfileOverviewModel;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.data.dmp.DataManagementPlanEditorModel;
import eu.eudat.models.data.user.composite.PagedDatasetProfile;
import eu.eudat.types.MetricNames;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.*;
import java.util.stream.Collectors;

@Service
@ConditionalOnProperty(prefix = "roadmap", name = "database.url")
public class DMPRoadmapService {
    /** DMPRoadmap Repositories*/
    private final TemplateRepository templateRepository;
    private final UserRepository userRepository;
    /** Argos beans */
    private final ApiContext apiContext;
    private final MetricsManager metricsManager;
    /** Data */
    private final List<DatasetProfile> datasetProfiles = new ArrayList<>();
    private final List<DataManagementPlanEditorModel> dmps = new ArrayList<>();
    private final List<DatasetWizardModel> datasets = new ArrayList<>();
    /** Metadata */
    private final Map<Long, UUID> groups = new HashMap<>();

    @Autowired
    public DMPRoadmapService(TemplateRepository templateRepository, UserRepository userRepository, ApiContext apiContext, MetricsManager metricsManager) {
        this.templateRepository = templateRepository;
        this.userRepository = userRepository;
        this.apiContext = apiContext;
        this.metricsManager = metricsManager;
    }

    public void migrate() {
        List<Template> templates = templateRepository.findAll();
        List<User> users = userRepository.findAll();
        templates.forEach(template -> {
            DatasetProfile datasetProfile = buildDatasetProfile(template);
            this.datasetProfiles.add(datasetProfile);
            // this.createProfile(datasetProfile, template);
            template.getPlans().forEach(plan -> {
                DataManagementPlanEditorModel dmpModel = this.buildDMP(plan, null);
                this.dmps.add(dmpModel);
            });
        });
        users.forEach(user -> {

        });
    }

    @Transactional
    void createProfile(DatasetProfile profile, Template template) {
        DatasetProfile shortenProfile = profile.toShort();
        eu.eudat.data.entities.DatasetProfile datasetProfile = AdminManager.generateViewStyleDefinition(shortenProfile, this.apiContext);
        if(groups.get(template.getFamilyId()) == null) {
            groups.put(template.getFamilyId(), UUID.randomUUID());
        }
        datasetProfile.setGroupId(groups.get(template.getFamilyId()));
        datasetProfile.setVersion(template.getVersion());
        datasetProfile = this.apiContext.getOperationsContext().getDatabaseRepository().
                getDatasetProfileDao().createOrUpdate(datasetProfile);
        metricsManager.increaseValue(MetricNames.DATASET_TEMPLATE, 1, MetricsManager.datasetTemplateStatus.get(datasetProfile.getStatus()));
    }

    private DataManagementPlanEditorModel buildDMP(Plan plan, eu.eudat.data.entities.DatasetProfile datasetProfile) {
        DataManagementPlanEditorModel dmpModel = new DataManagementPlanEditorModel();
        return dmpModel;
    }

    private DatasetWizardModel buildDataset(Plan plan, eu.eudat.data.entities.DatasetProfile datasetProfile) {
        DatasetWizardModel datasetModel = new DatasetWizardModel();
        datasetModel.setDataRepositories(new ArrayList<>());
        if(datasetProfile != null) {
            /* TODO Dataset Definition */
            PagedDatasetProfile datasetProfileDefinition = new PagedDatasetProfile();
            datasetModel.setDatasetProfileDefinition(datasetProfileDefinition);
            /* TODO DMP */
            DatasetProfileOverviewModel profile = new DatasetProfileOverviewModel();
            profile.setId(datasetProfile.getId());
            profile.setLabel(datasetProfile.getLabel());
            datasetModel.setProfile(profile);
        }
        datasetModel.setDescription(plan.getDescription());
        datasetModel.setExternalDatasets(new ArrayList<>());
        datasetModel.setLabel(plan.getTitle());
        datasetModel.setRegistries(new ArrayList<>());
        datasetModel.setServices(new ArrayList<>());
        datasetModel.setTags(new ArrayList<>());
        return datasetModel;
    }

    private DatasetProfile buildDatasetProfile(Template template) {
        DatasetProfile datasetProfile = new DatasetProfile();
        datasetProfile.setLabel(template.getTitle());
        datasetProfile.setDescription(template.getDescription());
        datasetProfile.setLanguage(template.getLocale());
        datasetProfile.setStatus((short) 1);
        datasetProfile.setVersion((short) 0);
        datasetProfile.setUsers(new ArrayList<>());
        this.buildPages(template, datasetProfile);
        return datasetProfile;
    }

    private DatasetProfile buildPages(Template template, DatasetProfile datasetProfile) {
        List<Page> pages = new ArrayList<>();
        List<Section> sections = new ArrayList<>();
        template.getPhases().forEach(phase -> {
            Page page = new Page();
            page.setId(String.valueOf(UUID.randomUUID()));
            page.setOrdinal(Math.toIntExact(phase.getNumber()) - 1);
            page.setTitle(phase.getTitle());
            pages.add(page);
            sections.addAll(buildSections(phase.getSections(), page.getId()));
        });
        datasetProfile.setPages(pages);
        datasetProfile.setSections(sections);
        return datasetProfile;
    }

    private List<Section> buildSections(List<eu.eudat.migration.entities.Section> sections, String pageId) {
        return sections.stream().map(s -> {
            Section section = new Section();
            section.setId(String.valueOf(UUID.randomUUID()));
            section.setPage(pageId);
            section.setTitle(s.getTitle());
            section.setDescription(s.getDescription());
            section.setOrdinal(Math.toIntExact(s.getNumber()) - 1);
            section.setDefaultVisibility(true);
            section.setMultiplicity(false);
            section.setSections(new ArrayList<>());
            section.setFieldSets(buildFieldSets(s.getQuestions()));
            return section;
        }).collect(Collectors.toList());
    }

    private List<FieldSet> buildFieldSets(List<Question> questions) {
        return questions.stream().map(question -> {
            FieldSet fieldSet = new FieldSet();
            fieldSet.setId(String.valueOf(UUID.randomUUID()));
            fieldSet.setTitle(question.getText());
            fieldSet.setDescription(buildDescription(question.getThemes()));
            fieldSet.setOrdinal(Math.toIntExact(question.getNumber()) - 1);
            fieldSet.setMultiplicity(buildMultiplicity());
            fieldSet.setHasCommentField(question.getOptionCommentDisplay());
            fieldSet.setFields(buildFields(question));
            return fieldSet;
        }).collect(Collectors.toList());
    }

    private String buildDescription(Set<Theme> themes) {
        StringBuilder sb = new StringBuilder();
        themes.forEach(theme -> {
            if(theme.getTitle() != null) {
                sb.append("<b>").append(theme.getTitle()).append("</b><br>");
            }
            if(theme.getDescription() != null) {
                sb.append("<p>").append(theme.getDescription()).append("</p>");
            }
            if(theme.getGuidances().size() > 0) {
                theme.getGuidances().forEach(guidance -> {
                    sb.append("<b>").append(guidance.getGuidanceGroup().getName()).append("</b><br>");
                    sb.append("<p>").append(guidance.getText()).append("</p>");
                });
            }
        });
        return sb.toString();
    }

    private Multiplicity buildMultiplicity() {
        Multiplicity multiplicity = new Multiplicity();
        multiplicity.setPlaceholder("");
        return multiplicity;
    }

    private List<Field> buildFields(Question question) {
        Field field = new Field();
        field.setId(String.valueOf(UUID.randomUUID()));
        field.setOrdinal(0);
        field.setDefaultValue(buildDefaultValue(question.getDefaultValue()));
        field.setValue(field.getDefaultValue().getValue());
        field.setValidations(buildValidators());
        field.setVisible(buildVisibility());
        field.setViewStyle(buildViewStyle(question.getQuestionFormat()));
        field.setData(buildData(question));
        return Collections.singletonList(field);
    }

    private DefaultValue buildDefaultValue(String value) {
        DefaultValue defaultValue = new DefaultValue();
        defaultValue.setType("String");
        defaultValue.setValue((value != null)?value:"");
        return defaultValue;
    }

    private List<Integer> buildValidators() {
        return Collections.singletonList((int) Field.ValidationType.REQUIRED.getValue());
    }

    private Visibility buildVisibility() {
        Visibility visibility = new Visibility();
        visibility.setRules(new ArrayList<>());
        visibility.setStyle("");
        return visibility;
    }

    private ViewStyle buildViewStyle(QuestionFormat questionFormat) {
        ViewStyle viewStyle = new ViewStyle();
        viewStyle.setCssClass("");
        switch (questionFormat.getFormattype()) {
            case TEXT_FIELD:
                viewStyle.setRenderStyle("freetext");
                break;
            case TEXTAREA:
                viewStyle.setRenderStyle("richTextarea");
                break;
            case CHECKBOX:
                viewStyle.setRenderStyle("checkBox");
                break;
            case RADIOBUTTON:
                viewStyle.setRenderStyle("radiobox");
                break;
            case DATE:
                viewStyle.setRenderStyle("datePicker");
                break;
            case DROPDOWN:
            case MULTI_SELECT:
                viewStyle.setRenderStyle("combobox");
                break;
            default:
                break;
        }
        return viewStyle;
    }

    private Map<String, Object> buildData(Question question) {
        Map<String, Object> object = new HashMap<>();
        object.put("label", "");
        if(question.getQuestionFormat().getOptionBased()) {
            object.put("options", question.getOptions().stream().map(questionOption -> {
                Map<String, Object> option = new HashMap<>();
                option.put(questionOption.getText(), questionOption.getText());
                return option;
            }).collect(Collectors.toList()));
        }
        if(question.getQuestionFormat().getFormattype() == QuestionFormat.FormatType.DROPDOWN ||
        question.getQuestionFormat().getFormattype() == QuestionFormat.FormatType.MULTI_SELECT) {
            object.put("type", "wordlist");
            object.put("multiList", question.getQuestionFormat().getFormattype() == QuestionFormat.FormatType.MULTI_SELECT);
        }
        return object;
    }

    public List<DatasetProfile> getDatesetProfiles() {
        return datasetProfiles;
    }

    public List<DataManagementPlanEditorModel> getDmps() {
        return dmps;
    }

    public List<DatasetWizardModel> getDatasets() {
        return datasets;
    }

    public List<Template> getTemplates() {
        return templateRepository.findAll();
    }

    public List<User> getUsers() {
        return userRepository.findAll();
    }
}