package eu.old.eudat.migration;

import eu.eudat.commons.XmlHandlingService;
import eu.eudat.commons.enums.FieldDataExternalDatasetType;
import eu.eudat.commons.enums.FieldType;
import eu.eudat.commons.enums.FieldValidationType;
import eu.eudat.commons.types.descriptiontemplate.*;
import eu.eudat.commons.types.descriptiontemplate.fielddata.*;
import eu.eudat.convention.ConventionService;
import eu.eudat.data.DescriptionTemplateEntity;
import eu.eudat.model.DescriptionTemplate;
import eu.eudat.query.DescriptionTemplateQuery;
import eu.old.eudat.logic.utilities.builders.XmlBuilder;
import eu.old.eudat.models.data.components.commons.Multiplicity;
import eu.old.eudat.models.data.components.commons.Rule;
import eu.old.eudat.models.data.components.commons.datafield.*;
import eu.old.eudat.models.data.entities.xmlmodels.datasetprofiledefinition.*;
import gr.cite.tools.data.query.Ordering;
import gr.cite.tools.data.query.Paging;
import gr.cite.tools.data.query.QueryFactory;
import gr.cite.tools.exception.MyApplicationException;
import gr.cite.tools.logging.LoggerService;
import jakarta.persistence.EntityManager;
import jakarta.xml.bind.JAXBException;
import org.jetbrains.annotations.NotNull;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

import javax.management.InvalidApplicationException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.UUID;

@Service
public class DescriptionTemplateXmlMigrationService {

    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateXmlMigrationService.class));
    private final EntityManager entityManager;
    private final ConventionService conventionService;
    private final XmlHandlingService xmlHandlingService;
    private final QueryFactory queryFactory;

    private static final int PageSize = 500;
    private static final boolean TestMode = false;

    public DescriptionTemplateXmlMigrationService(EntityManager entityManager, ConventionService conventionService, XmlHandlingService xmlHandlingService, QueryFactory queryFactory) {
        this.entityManager = entityManager;
        this.conventionService = conventionService;
        this.xmlHandlingService = xmlHandlingService;
	    this.queryFactory = queryFactory;
    }

    public void migrate() throws IOException, NoSuchFieldException, IllegalAccessException, JAXBException, ParserConfigurationException, InstantiationException, SAXException, InvalidApplicationException, TransformerException {
        long total = this.queryFactory.query(DescriptionTemplateQuery.class).count();
        logger.debug("Migrate DescriptionTemplate Total : " + total);
        int page = 0;

        List<DescriptionTemplateEntity> items;
        do {
            DescriptionTemplateQuery query = this.queryFactory.query(DescriptionTemplateQuery.class);
            query.setOrder(new Ordering().addDescending(DescriptionTemplate._createdAt));
            query.setPage(new Paging(page * PageSize, PageSize));
            items = query.collect();
            
            if (items != null && !items.isEmpty()) {
                
                logger.debug("Migrate DescriptionTemplate " + page * PageSize + " of " + total);
                
                for (DescriptionTemplateEntity item : items) {
                    if (this.conventionService.isNullOrEmpty(item.getDefinition())) continue;
                    Document document = XmlBuilder.fromXml(item.getDefinition());
                    if (document == null){
                        logger.error("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
                        continue;
                    }
                    ViewStyleModel viewStyleModel = null;
                    try {
                        viewStyleModel = new ViewStyleModel().fromXml(document.getDocumentElement());
                    } catch (Exception ex){
                        logger.error("Migrate DescriptionTemplate " + item.getId() + " failed read xml");
                        continue;
                    }
                    item.setDefinition(this.xmlHandlingService.toXml(this.buildDefinitionEntity(viewStyleModel)));
                    this.entityManager.merge(item);
                }

                this.entityManager.flush();
                page++;
            }
        } while (items != null && !items.isEmpty() && !TestMode);
    }

    private @NotNull DefinitionEntity buildDefinitionEntity(ViewStyleModel persist) {
        DefinitionEntity data = new DefinitionEntity();
        if (persist == null)
            return data;
        if (!this.conventionService.isListNullOrEmpty(persist.getPages())) {
            data.setPages(new ArrayList<>());
            for (Page pagePersist : persist.getPages()) {
                data.getPages().add(this.buildPageEntity(pagePersist, persist.getSections()));
            }
        }

        return data;
    }

    private @NotNull SectionEntity buildSectionEntity(Section persist) {
        SectionEntity data = new SectionEntity();
        if (persist == null)
            return data;

        data.setId(persist.getId());
        data.setDescription(persist.getDescription());
        data.setExtendedDescription(persist.getExtendedDescription());
        data.setNumbering(persist.getNumbering());
        data.setOrdinal(persist.getOrdinal());
        data.setDefaultVisibility(persist.isDefaultVisibility());
        data.setMultiplicity(persist.getMultiplicity());
        data.setTitle(persist.getTitle());

        if (!this.conventionService.isListNullOrEmpty(persist.getSections())) {
            data.setSections(new ArrayList<>());
            for (Section sectionPersist : persist.getSections()) {
                data.getSections().add(this.buildSectionEntity(sectionPersist));
            }
        }

        if (!this.conventionService.isListNullOrEmpty(persist.getFieldSets())) {
            data.setFieldSets(new ArrayList<>());
            for (FieldSet fieldSetPersist : persist.getFieldSets()) {
                data.getFieldSets().add(this.buildFieldSetEntity(fieldSetPersist));
            }
        }

        return data;
    }

    private @NotNull FieldSetEntity buildFieldSetEntity(FieldSet persist) {
        FieldSetEntity data = new FieldSetEntity();
        if (persist == null)
            return data;

        data.setId(persist.getId());
        data.setOrdinal(persist.getOrdinal());
        data.setNumbering(persist.getNumbering());
        data.setTitle(persist.getTitle());
        data.setExtendedDescription(persist.getExtendedDescription());
        data.setAdditionalInformation(persist.getAdditionalInformation());
        data.setHasCommentField(persist.getHasCommentField());
        if (persist.getMultiplicity() != null) data.setMultiplicity(this.buildMultiplicityEntity(persist.getMultiplicity()));

        if (!this.conventionService.isListNullOrEmpty(persist.getFields())) {
            data.setFields(new ArrayList<>());
            for (Field fieldPersist : persist.getFields()) {
                data.getFields().add(this.buildFieldEntity(fieldPersist));
            }
        }
        return data;
    }

    private @NotNull FieldEntity buildFieldEntity(Field persist) {
        FieldEntity data = new FieldEntity();
        if (persist == null)
            return data;

        data.setId(persist.getId());
        data.setOrdinal(persist.getOrdinal());
        data.setSchematics(persist.getSchematics());
        data.setNumbering(persist.getNumbering());
        if (persist.getDefaultValue() != null) data.setDefaultValue(persist.getDefaultValue().getValue());
        if (persist.getValidations() != null) data.setValidations(persist.getValidations().stream().map(x-> {
            switch (x){
                case NONE -> {
                    return FieldValidationType.None;
                }
                case REQUIRED -> {
                    return FieldValidationType.Required;
                }
                case URL -> {
                    return FieldValidationType.Url;
                }
                default -> throw new MyApplicationException("Invalid type " + x);
            }
            
        }).toList());
        data.setIncludeInExport(persist.getExport());
        if (persist.getData() != null)
            data.setData(this.buildFieldDataEntity(persist.getData(), persist.getViewStyle().getRenderStyle()));

        if (persist.getVisible() != null && !this.conventionService.isListNullOrEmpty(persist.getVisible().getRules())) {
            data.setVisibilityRules(new ArrayList<>());
            for (Rule fieldPersist : persist.getVisible().getRules()) {
                data.getVisibilityRules().add(this.buildRuleEntity(fieldPersist));
            }
        }
        return data;
    }

    private BaseFieldDataEntity buildFieldDataEntity(FieldData persist, String renderStyle) {
        if (renderStyle.equals("checkBox")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.CHECK_BOX);
        }
        if (renderStyle.equals("validation")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.VALIDATION);
        }
        if (renderStyle.equals("textarea")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.TEXT_AREA);
        }
        if (renderStyle.equals("tags")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.TAGS);
        }
        if (renderStyle.equals("richTextarea")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.RICH_TEXT_AREA);
        }
        if (renderStyle.equals("freetext")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.FREE_TEXT);
        }
        if (renderStyle.equals("datePicker")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.DATE_PICKER);
        }
        if (renderStyle.equals("datasetIdentifier")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.DATASET_IDENTIFIER);
        }
        if (renderStyle.equals("currency")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.CURRENCY);
        }
        if (renderStyle.equals("taxonomies")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((TaxonomiesData)persist).getMultiAutoComplete(),FieldType.TAXONOMIES);
        }
        if (renderStyle.equals("services")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ServicesData)persist).getMultiAutoComplete(),FieldType.SERVICES);
        }
        if (renderStyle.equals("researchers")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ResearcherData)persist).getMultiAutoComplete(),FieldType.RESEARCHERS);
        }
        if (renderStyle.equals("registries")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((RegistriesData)persist).getMultiAutoComplete(),FieldType.REGISTRIES);
        }
        if (renderStyle.equals("pubRepositories")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.PUB_REPOSITORIES);
        }
        if (renderStyle.equals("publications")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((PublicationsData)persist).getMultiAutoComplete(),FieldType.PUB_REPOSITORIES);
        }
        if (renderStyle.equals("organizations")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((OrganizationsData)persist).getMultiAutoComplete(),FieldType.ORGANIZATIONS);
        }
        if (renderStyle.equals("licenses")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((LicensesData)persist).getMultiAutoComplete(),FieldType.LICENSES);
        }
        if (renderStyle.equals("journalRepositories")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.JOURNAL_REPOSITORIES);
        }
        if (renderStyle.equals("dataRepositories")){
            return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DataRepositoriesData)persist).getMultiAutoComplete(),FieldType.DATA_REPOSITORIES);
        }
        if (renderStyle.equals("booleanDecision")){
            return this.buildLabelDataEntity(persist.getLabel(), FieldType.BOOLEAN_DECISION);
        }
        if (renderStyle.equals("internalDmpEntities")){
            switch (((InternalDmpEntitiesData<?>)persist).getType()){
                case "dmps":
                    return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DMPsAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_DMP_ENTRIES_DMPS);
                case "datasets":
                    return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((DatasetsAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_DMP_ENTRIES_DATASETS);
                case "researchers":
                    return this.buildLabelAndMultiplicityDataEntity(persist.getLabel(), ((ResearchersAutoCompleteData)persist).getMultiAutoComplete(),FieldType.INTERNAL_DMP_ENTRIES_RESEARCHERS);
            }
        }

        if (renderStyle.equals("externalDatasets")){
            ExternalDatasetDataEntity data = new ExternalDatasetDataEntity();
            data.setLabel(persist.getLabel());
            data.setMultipleSelect(((ExternalDatasetsData)persist).getMultiAutoComplete());
            data.setType(FieldDataExternalDatasetType.of(((ExternalDatasetsData)persist).getType()));
            data.setFieldType(FieldType.EXTERNAL_DATASETS);
            return data;
        }



        if (renderStyle.equals("upload")){
            UploadDataEntity data = new UploadDataEntity();
            data.setLabel(persist.getLabel());
            data.setMaxFileSizeInMB(((UploadData)persist).getMaxFileSizeInMB());
            data.setTypes(new ArrayList<>());
            if (((UploadData)persist).getTypes() != null){
                for (UploadData.Option option : ((UploadData)persist).getTypes()){
                    UploadDataEntity.UploadDataOptionEntity optionEntity =new UploadDataEntity.UploadDataOptionEntity();
                    optionEntity.setValue(option.getValue());
                    optionEntity.setLabel(option.getLabel());
                    data.getTypes().add(optionEntity);
                }
            }
            data.setFieldType(FieldType.UPLOAD);
            return data;
        }

        if (renderStyle.equals("radiobox")){
            RadioBoxDataEntity data = new RadioBoxDataEntity();
            data.setLabel(persist.getLabel());
            data.setOptions(new ArrayList<>());
            if (((RadioBoxData)persist).getOptions() != null){
                for (RadioBoxData.Option option : ((RadioBoxData)persist).getOptions()){
                    RadioBoxDataEntity.RadioBoxDataOptionEntity optionEntity = new RadioBoxDataEntity.RadioBoxDataOptionEntity();
                    optionEntity.setValue(option.getValue());
                    optionEntity.setLabel(option.getLabel());
                    data.getOptions().add(optionEntity);
                }
            }
            data.setFieldType(FieldType.RADIO_BOX);
            return data;
        }

        if (renderStyle.equals("combobox")){
            switch (((ComboBoxData<?>)persist).getType()){
                case "wordlist":{
                    SelectDataEntity data = new SelectDataEntity();
                    data.setLabel(persist.getLabel());
                    data.setOptions(new ArrayList<>());
                    data.setMultipleSelect(((WordListData)persist).getMultiList());
                    if (((WordListData)persist).getOptions() != null){
                        for (ComboBoxData.Option option : ((WordListData)persist).getOptions()){
                            SelectDataEntity.OptionEntity optionEntity = new SelectDataEntity.OptionEntity();
                            optionEntity.setValue(option.getValue());
                            optionEntity.setLabel(option.getLabel());
                            data.getOptions().add(optionEntity);
                        }
                    }
                    data.setFieldType(FieldType.SELECT);
                    return data;
                }
                case "autocomplete":{
                    ExternalSelectDataEntity data = new ExternalSelectDataEntity();
                    data.setLabel(persist.getLabel());
                    data.setSources(new ArrayList<>());
                    data.setMultipleSelect(((AutoCompleteData)persist).getMultiAutoComplete());
                    if (((AutoCompleteData)persist).getAutoCompleteSingleDataList() != null){
                        for (AutoCompleteData.AutoCompleteSingleData autoCompleteSingleData : ((AutoCompleteData)persist).getAutoCompleteSingleDataList()){
                            ExternalSelectDataEntity.ExternalSelectSourceEntity autoCompleteSingleDataEntity = new ExternalSelectDataEntity.ExternalSelectSourceEntity();
                            autoCompleteSingleDataEntity.setOptionsRoot(autoCompleteSingleData.getOptionsRoot());
                            autoCompleteSingleDataEntity.setUrl(autoCompleteSingleData.getUrl());
                            autoCompleteSingleDataEntity.setMethod(autoCompleteSingleData.getMethod());
                            autoCompleteSingleDataEntity.setHasAuth(autoCompleteSingleData.getHasAuth());
                            if (autoCompleteSingleData.getHasAuth() && autoCompleteSingleData.getAuth()!= null) {
                                ExternalSelectDataEntity.ExternalSelectAuthDataEntity optionEntity = new ExternalSelectDataEntity.ExternalSelectAuthDataEntity();
                                optionEntity.setBody(autoCompleteSingleData.getAuth().getBody());
                                optionEntity.setMethod(autoCompleteSingleData.getAuth().getMethod());
                                optionEntity.setUrl(autoCompleteSingleData.getAuth().getUrl());
                                optionEntity.setType(autoCompleteSingleData.getAuth().getType());
                                optionEntity.setBody(autoCompleteSingleData.getAuth().getBody());
                                autoCompleteSingleDataEntity.setAuth(optionEntity);
                            }
                            if (autoCompleteSingleData.getAutoCompleteOptions() != null) {
                                ExternalSelectDataEntity.ExternalSelectSourceBindingEntity optionEntity = new ExternalSelectDataEntity.ExternalSelectSourceBindingEntity();
                                optionEntity.setValue(autoCompleteSingleData.getAutoCompleteOptions().getValue());
                                optionEntity.setLabel(autoCompleteSingleData.getAutoCompleteOptions().getLabel());
                                optionEntity.setSource(autoCompleteSingleData.getAutoCompleteOptions().getSource());
                                autoCompleteSingleDataEntity.setSourceBinding(optionEntity);
                            }
                            data.getSources().add(autoCompleteSingleDataEntity);
                        }
                    }
                    data.setFieldType(FieldType.EXTERNAL_SELECT);
                    return data;
                }
            }
        }
        throw new MyApplicationException("Can transform field data" + renderStyle);
    }

    private BaseFieldDataEntity buildLabelDataEntity(String label, FieldType fieldType) {
        LabelDataEntity data = new LabelDataEntity();
        data.setLabel(label);
        data.setFieldType(fieldType);
        return data;
    }

    private BaseFieldDataEntity buildLabelAndMultiplicityDataEntity(String label, Boolean multiAutoComplete, FieldType fieldType) {
        LabelAndMultiplicityDataEntity data = new LabelAndMultiplicityDataEntity();
        data.setLabel(label);
        data.setFieldType(fieldType);
        data.setMultipleSelect(multiAutoComplete);
        return data;
    }

    private @NotNull RuleEntity buildRuleEntity(Rule persist) {
        RuleEntity data = new RuleEntity();
        if (persist == null)
            return data;

        data.setTarget(persist.getTarget());
        data.setValue(persist.getValue());
        return data;
    }
    private @NotNull MultiplicityEntity buildMultiplicityEntity(Multiplicity persist) {
        MultiplicityEntity data = new MultiplicityEntity();
        if (persist == null)
            return data;

        data.setMax(persist.getMax());
        data.setMin(persist.getMin());
        data.setPlaceholder(persist.getPlaceholder());
        data.setTableView(persist.getTableView());
        return data;
    }



    private @NotNull PageEntity buildPageEntity(Page persist, List<Section> allSections) {
        PageEntity data = new PageEntity();
        if (persist == null)
            return data;

        data.setId(persist.getId());
        data.setOrdinal(persist.getOrdinal());
        data.setTitle(persist.getTitle());

        List<Section> sections = allSections.stream().filter(x-> this.isInPage(x, persist)).toList();
        if (!this.conventionService.isListNullOrEmpty(sections)) {
            data.setSections(new ArrayList<>());
            for (Section sectionPersist : sections) {
                data.getSections().add(this.buildSectionEntity(sectionPersist));
            }
        }
        return data;
    }
    
    private boolean isInPage(Section section, Page page){
        try {
            return UUID.fromString(section.getPage()).equals(UUID.fromString(page.getId()));
        } catch (Exception e){
            try {
                return Integer.parseInt(section.getPage().replace("page_", "")) == page.getOrdinal();
            } catch (Exception e1){
                return section.getPage().toLowerCase(Locale.ROOT).equals(page.getId().toLowerCase(Locale.ROOT));
            }
        }
    }
}