package eu.eudat.model.builder.filetransformer;

import eu.eudat.authorization.AuthorizationFlags;
import eu.eudat.commons.JsonHandlingService;
import eu.eudat.commons.XmlHandlingService;
import eu.eudat.commons.types.descriptiontemplate.*;
import eu.eudat.commons.types.descriptiontemplate.fielddata.*;
import eu.eudat.convention.ConventionService;
import eu.eudat.file.transformer.enums.FieldDataExternalDatasetType;
import eu.eudat.file.transformer.enums.FieldType;
import eu.eudat.file.transformer.enums.FieldValidationType;
import eu.eudat.file.transformer.models.descriptiontemplate.definition.*;
import eu.eudat.file.transformer.models.descriptiontemplate.definition.fielddata.*;
import gr.cite.tools.data.builder.BuilderFactory;
import gr.cite.tools.data.query.QueryFactory;
import gr.cite.tools.exception.MyApplicationException;
import gr.cite.tools.logging.LoggerService;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Optional;

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class DescriptionTemplateDefinitionFileTransformerBuilder extends BaseFileTransformerBuilder<DefinitionFileTransformerModel, DefinitionEntity> {

    private final QueryFactory queryFactory;

    private final BuilderFactory builderFactory;
    private final JsonHandlingService jsonHandlingService;

    private final XmlHandlingService xmlHandlingService;
    private EnumSet<AuthorizationFlags> authorize = EnumSet.of(AuthorizationFlags.None);

    @Autowired
    public DescriptionTemplateDefinitionFileTransformerBuilder(
		    ConventionService conventionService,
		    QueryFactory queryFactory,
		    BuilderFactory builderFactory, JsonHandlingService jsonHandlingService, XmlHandlingService xmlHandlingService) {
        super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionTemplateDefinitionFileTransformerBuilder.class)));
        this.queryFactory = queryFactory;
        this.builderFactory = builderFactory;
        this.jsonHandlingService = jsonHandlingService;
	    this.xmlHandlingService = xmlHandlingService;
    }

    public DescriptionTemplateDefinitionFileTransformerBuilder authorize(EnumSet<AuthorizationFlags> values) {
        this.authorize = values;
        return this;
    }

    @Override
    protected List<FileTransformerBuilderItemResponse<DefinitionFileTransformerModel, DefinitionEntity>> buildInternal(List<DefinitionEntity> data) throws MyApplicationException {
        this.logger.debug("building for {}", Optional.ofNullable(data).map(List::size).orElse(0));
        if (data == null || data.isEmpty()) return new ArrayList<>();

        List<FileTransformerBuilderItemResponse<DefinitionFileTransformerModel, DefinitionEntity>> models = new ArrayList<>();
        for (DefinitionEntity d : data) {
            DefinitionFileTransformerModel m = new DefinitionFileTransformerModel();
            m.setPages(collectPages(d.getPages()));
            models.add(new FileTransformerBuilderItemResponse<>(m, d));
        }

        this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0));

        return models;
    }

    private List<PageFileTransformerModel> collectPages(List<PageEntity> data) {
        List<PageFileTransformerModel> result = new ArrayList<>();
        for (PageEntity d: data) {
            PageFileTransformerModel m = new PageFileTransformerModel();
            m.setId(d.getId());
            m.setOrdinal(d.getOrdinal());
            m.setTitle(d.getTitle());
            if (d.getSections() != null) m.setSections(collectSections(d.getSections()));
            result.add(m);
        }

        return result;
    }

    private List<SectionFileTransformerModel> collectSections(List<SectionEntity> data) {
        List<SectionFileTransformerModel> result = new ArrayList<>();
        for (SectionEntity d : data) {
            SectionFileTransformerModel m = new SectionFileTransformerModel();
            m.setId(d.getId());
            m.setDescription(d.getDescription());
            m.setTitle(d.getTitle());
            m.setOrdinal(d.getOrdinal());
            m.setDefaultVisibility(d.isDefaultVisibility());
            m.setExtendedDescription(d.getExtendedDescription());
            m.setMultiplicity(d.getMultiplicity());
            m.setNumbering(d.getNumbering());
            if (d.getSections() != null && !d.getSections().isEmpty()) {
                m.setSections(collectSections(d.getSections()));
            }
            if (d.getFieldSets() != null && !d.getFieldSets().isEmpty()) {
                m.setFieldSets(collectFieldSet(d.getFieldSets()));
            }
            result.add(m);
        }
        return result;
    }

    private List<FieldSetFileTransformerModel> collectFieldSet(List<FieldSetEntity> data) {
        List<FieldSetFileTransformerModel> result = new ArrayList<>();
        for (FieldSetEntity d : data) {
            FieldSetFileTransformerModel m = new FieldSetFileTransformerModel();
            m.setId(d.getId());
            m.setDescription(d.getDescription());
            m.setExtendedDescription(d.getExtendedDescription());
            m.setAdditionalInformation(d.getAdditionalInformation());
            m.setHasCommentField(d.getHasCommentField());
            m.setNumbering(d.getNumbering());
            m.setOrdinal(d.getOrdinal());
            m.setTitle(d.getTitle());
            //m.setMultiplicity(); //TODO: No multiplicity in this code (yet)
            m.setFields(convertFields(d.getFields()));
            result.add(m);
        }
        return result;
    }

    private List<FieldFileTransformerModel> convertFields(List<FieldEntity> data) {
        List<FieldFileTransformerModel> result = new ArrayList<>();
        for (FieldEntity d : data) {
            FieldFileTransformerModel m = new FieldFileTransformerModel();
            m.setId(d.getId());
            m.setSchematics(d.getSchematics());
            m.setNumbering(d.getNumbering());
            m.setOrdinal(d.getOrdinal());
            m.setDefaultValue(d.getDefaultValue());
            m.setIncludeInExport(d.getIncludeInExport());
            m.setValidations(d.getValidations().stream().map(fieldValidationType -> FieldValidationType.of(fieldValidationType.getValue())).toList());
            if (d.getVisibilityRules() != null && !d.getVisibilityRules().isEmpty()) {
                m.setVisibilityRules(convertVisibilityRules(d.getVisibilityRules()));
            }
            m.setData(convertData(d.getData()));
            result.add(m);
        }
        return result;
    }

    public List<RuleFileTransformerModel> convertVisibilityRules(List<RuleEntity> data) {
        List<RuleFileTransformerModel> result = new ArrayList<>();
        for (RuleEntity d : data) {
            RuleFileTransformerModel m = new RuleFileTransformerModel();
            m.setTarget(d.getTarget());
            m.setValue(d.getValue());
            result.add(m);
        }
        return result;
    }

    public BaseFieldDataFileTransformerModel convertData (BaseFieldDataEntity data) {
            BaseFieldDataFileTransformerModel m;
            switch (data) {
                case ExternalSelectDataEntity d -> {
                    m = new ExternalSelectDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((ExternalSelectDataFileTransformerModel)m).setMultipleSelect(d.getMultipleSelect());
                    ((ExternalSelectDataFileTransformerModel) m).setSources(convertAutoCompleteSingleData(d.getSources()));
                }
                case ExternalDatasetDataEntity d -> {
                    m = new ExternalDatasetDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((ExternalDatasetDataFileTransformerModel)m).setType(FieldDataExternalDatasetType.of(d.getType().getValue()));
                }
                case RadioBoxDataEntity d -> {
                    m = new RadioBoxDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((RadioBoxDataFileTransformerModel) m).setOptions(convertRadioBoxOptions(d.getOptions()));
                }
                case UploadDataEntity d -> {
                    m = new UploadDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((UploadDataFileTransformerModel) m).setMaxFileSizeInMB(d.getMaxFileSizeInMB());
                    ((UploadDataFileTransformerModel) m).setTypes(convertUploadDataOptions(d.getTypes()));
                }
                case SelectDataEntity d -> {
                    m = new SelectDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((SelectDataFileTransformerModel) m).setMultipleSelect(d.getMultipleSelect());
                    ((SelectDataFileTransformerModel) m).setOptions(d.getOptions().stream().map(this::convertComboBoxOption).toList());
                }
                case LabelAndMultiplicityDataEntity d -> {
                    m = new LabelAndMultiplicityDataFileTransformerModel();
                    m.setLabel(d.getLabel());
                    m.setFieldType(FieldType.of(d.getFieldType().getValue()));
                    ((LabelAndMultiplicityDataFileTransformerModel)m).setMultipleSelect(d.getMultipleSelect());
                }
                default -> {
                    m = new LabelDataFileTransformerModel();
                    m.setLabel(data.getLabel());
                    m.setFieldType(FieldType.of(data.getFieldType().getValue()));
                }
            }
        return m;
    }

    private List<RadioBoxDataFileTransformerModel.RadioBoxDataOptionFileTransformerModel> convertRadioBoxOptions(List<RadioBoxDataEntity.RadioBoxDataOptionEntity> data) {
        List<RadioBoxDataFileTransformerModel.RadioBoxDataOptionFileTransformerModel> result = new ArrayList<>();
        for (RadioBoxDataEntity.RadioBoxDataOptionEntity d : data) {
            RadioBoxDataFileTransformerModel.RadioBoxDataOptionFileTransformerModel m = new RadioBoxDataFileTransformerModel.RadioBoxDataOptionFileTransformerModel();
            m.setLabel(d.getLabel());
            m.setValue(d.getValue());
            result.add(m);
        }
        return result;
    }

    private List<ExternalSelectDataFileTransformerModel.ExternalSelectSourceFileTransformerModel> convertAutoCompleteSingleData(List<ExternalSelectDataEntity.ExternalSelectSourceEntity> data) {
        List<ExternalSelectDataFileTransformerModel.ExternalSelectSourceFileTransformerModel> result = new ArrayList<>();
        for (ExternalSelectDataEntity.ExternalSelectSourceEntity d : data) {
            ExternalSelectDataFileTransformerModel.ExternalSelectSourceFileTransformerModel m = new ExternalSelectDataFileTransformerModel.ExternalSelectSourceFileTransformerModel();
            m.setUrl(d.getUrl());
            m.setMethod(d.getMethod());
            m.setHasAuth(d.getHasAuth());
            m.setOptionsRoot(d.getOptionsRoot());
            if (d.getAuth() != null) {
                m.setAuth(convertAuthData(d.getAuth()));
            }
            m.setSourceBinding(convertComboBoxOption(d.getSourceBinding()));
            result.add(m);
        }
        return result;
    }

    private ExternalSelectDataFileTransformerModel.ExternalSelectSourceBindingFileTransformerModel convertComboBoxOption(ExternalSelectDataEntity.ExternalSelectSourceBindingEntity data) {
        ExternalSelectDataFileTransformerModel.ExternalSelectSourceBindingFileTransformerModel m = new ExternalSelectDataFileTransformerModel.ExternalSelectSourceBindingFileTransformerModel();
//        m.setUri(data.getUri()); 
        m.setSource(data.getSource());
        m.setLabel(data.getLabel());
        m.setValue(data.getValue());
        return m;
    }

    private ExternalSelectDataFileTransformerModel.ExternalSelectAuthDataFileTransformerModel convertAuthData(ExternalSelectDataEntity.ExternalSelectAuthDataEntity data) {
        ExternalSelectDataFileTransformerModel.ExternalSelectAuthDataFileTransformerModel m = new ExternalSelectDataFileTransformerModel.ExternalSelectAuthDataFileTransformerModel();
        m.setMethod(data.getMethod());
        m.setUrl(data.getUrl());
        m.setType(data.getType());
        m.setBody(data.getBody());
        m.setPath(data.getPath());
        return m;
    }

    private SelectDataFileTransformerModel.OptionFileTransformerModel convertComboBoxOption(SelectDataEntity.OptionEntity data) {
        SelectDataFileTransformerModel.OptionFileTransformerModel m = new SelectDataFileTransformerModel.OptionFileTransformerModel();
        m.setLabel(data.getLabel());
        m.setValue(data.getValue());
        return m;
    }

    private List<UploadDataFileTransformerModel.UploadDataOptionFileTransformerModel> convertUploadDataOptions(List<UploadDataEntity.UploadDataOptionEntity> data) {
        List<UploadDataFileTransformerModel.UploadDataOptionFileTransformerModel> result = new ArrayList<>();
        for (UploadDataEntity.UploadDataOptionEntity d : data) {
            UploadDataFileTransformerModel.UploadDataOptionFileTransformerModel m = new UploadDataFileTransformerModel.UploadDataOptionFileTransformerModel();
            m.setLabel(d.getLabel());
            m.setValue(d.getValue());
            result.add(m);
        }
        return result;
    }


}