package eu.eudat.model.builder.filetransformer;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.authorization.AuthorizationFlags;
import eu.eudat.commons.types.description.FieldEntity;
import eu.eudat.commons.types.descriptiontemplate.DefinitionEntity;
import eu.eudat.convention.ConventionService;
import eu.eudat.depositinterface.enums.FieldType;
import eu.eudat.depositinterface.models.DescriptionFieldDepositModel;
import eu.eudat.file.transformer.models.descriptiontemplate.DescriptionTemplateFileTransformerModel;
import eu.eudat.file.transformer.models.descriptiontemplate.definition.*;
import eu.eudat.service.fielddatahelper.FieldDataHelperServiceProvider;
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.*;

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class DescriptionFieldFileTransformerBuilder extends BaseFileTransformerBuilder<DescriptionTemplateFileTransformerModel, FieldEntity> {

    private EnumSet<AuthorizationFlags> authorize = EnumSet.of(AuthorizationFlags.None);
    private DescriptionTemplateFileTransformerModel definition;
    private final FieldDataHelperServiceProvider fieldDataHelperServiceProvider;

    @Autowired
    public DescriptionFieldFileTransformerBuilder(
		    ConventionService conventionService, FieldDataHelperServiceProvider fieldDataHelperServiceProvider
    ) {
        super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionFieldFileTransformerBuilder.class)));
	    this.fieldDataHelperServiceProvider = fieldDataHelperServiceProvider;
    }

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

    public DescriptionFieldFileTransformerBuilder setDefinition(DescriptionTemplateFileTransformerModel definition) {
        this.definition = definition;
        return this;
    }

    @Override
    protected List<FileTransformerBuilderItemResponse<DescriptionTemplateFileTransformerModel, FieldEntity>> buildInternal(List<FieldEntity> 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<DescriptionFieldDepositModel, FieldEntity>> models = new ArrayList<>();
        ObjectMapper objectMapper = new ObjectMapper();
        for (FieldEntity d : data) {
           // DescriptionFieldDepositModel m = new DescriptionFieldDepositModel();
            if (definition != null){
                FieldFileTransformerModel fieldEntity = findFieldById(d.getKey());
                if (fieldEntity != null){
                    //m.setSchematics(fieldEntity.getSchematics());
                    if (fieldEntity.getData() != null) {
                        /*boolean isMultiValue = fieldDataHelperServiceProvider.get(eu.eudat.commons.enums.FieldType.of(fieldEntity.getData().getFieldType().getValue())).isMultiValue(fieldEntity.getData());
                        if (!isMultiValue) fieldEntity.getData().setValue(List.of(d.getValue());
                        else*/ {
                                fieldEntity.getData().setValue(d.getValue());
                        }
                        
                        /*switch (field.getData().getFieldType()) {
                            case AUTO_COMPLETE -> m.setFieldType(FieldType.AUTO_COMPLETE);
                            case WORD_LIST -> m.setFieldType(FieldType.WORD_LIST);
                            case BOOLEAN_DECISION -> m.setFieldType(FieldType.BOOLEAN_DECISION);
                            case RADIO_BOX -> m.setFieldType(FieldType.RADIO_BOX);
                            case INTERNAL_DMP_ENTRIES_RESEARCHERS -> m.setFieldType(FieldType.INTERNAL_DMP_ENTRIES_RESEARCHERS);
                            case INTERNAL_DMP_ENTRIES_DMPS -> m.setFieldType(FieldType.INTERNAL_DMP_ENTRIES_DMPS);
                            case INTERNAL_DMP_ENTRIES_DATASETS -> m.setFieldType(FieldType.INTERNAL_DMP_ENTRIES_DATASETS);
                            case CHECK_BOX -> m.setFieldType(FieldType.CHECK_BOX);
                            case FREE_TEXT -> m.setFieldType(FieldType.FREE_TEXT);
                            case TEXT_AREA -> m.setFieldType(FieldType.TEXT_AREA);
                            case RICH_TEXT_AREA -> m.setFieldType(FieldType.RICH_TEXT_AREA);
                            case UPLOAD -> m.setFieldType(FieldType.UPLOAD);
                            case DATE_PICKER -> m.setFieldType(FieldType.DATE_PICKER);
                            case EXTERNAL_DATASETS -> m.setFieldType(FieldType.EXTERNAL_DATASETS);
                            case DATA_REPOSITORIES -> m.setFieldType(FieldType.DATA_REPOSITORIES);
                            case JOURNAL_REPOSITORIES -> m.setFieldType(FieldType.JOURNAL_REPOSITORIES);
                            case PUB_REPOSITORIES -> m.setFieldType(FieldType.PUB_REPOSITORIES);
                            case LICENSES -> m.setFieldType(FieldType.LICENSES);
                            case PUBLICATIONS -> m.setFieldType(FieldType.PUBLICATIONS);
                            case REGISTRIES -> m.setFieldType(FieldType.REGISTRIES);
                            case SERVICES -> m.setFieldType(FieldType.SERVICES);
                            case TAGS -> m.setFieldType(FieldType.TAGS);
                            case RESEARCHERS -> m.setFieldType(FieldType.RESEARCHERS);
                            case ORGANIZATIONS -> m.setFieldType(FieldType.ORGANIZATIONS);
                            case DATASET_IDENTIFIER -> m.setFieldType(FieldType.DATASET_IDENTIFIER);
                            case CURRENCY -> m.setFieldType(FieldType.CURRENCY);
                            case VALIDATION -> m.setFieldType(FieldType.VALIDATION);
                            case TAXONOMIES ->  m.setFieldType(FieldType.TAXONOMIES);
                            default -> throw new MyApplicationException("unrecognized type " + field.getData().getFieldType());
                        }*/
                    }
                }
            }
            //models.add(new FileTransformerBuilderItemResponse<>(m, d));
        }

        for (PageFileTransformerModel page : definition.getDefinition().getPages()) {
            page.setSections(calculateSectionVisibility(page.getSections()));
        }

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

        return List.of(new FileTransformerBuilderItemResponse<>(definition, data.get(0)));
    }

    private FieldFileTransformerModel findFieldById(String id) {
        FieldFileTransformerModel result = null;
        List<PageFileTransformerModel> pages = definition.getDefinition().getPages();
        for (PageFileTransformerModel page: pages) {
            if (page.getSections() != null && !page.getSections().isEmpty()) {
                result = findSectionFieldById(id, page.getSections());
                if (result != null) {
                    break;
                }
            }
        }
        return result;
    }

    private FieldFileTransformerModel findSectionFieldById(String id, List<SectionFileTransformerModel> sections) {
        FieldFileTransformerModel result = null;
        for (SectionFileTransformerModel section: sections) {
            if (section.getSections() != null && !section.getSections().isEmpty()) {
                result = findSectionFieldById(id, section.getSections());
            }
            if (result == null) {
                List<FieldSetFileTransformerModel> fieldSets = section.getFieldSets();
                if (fieldSets != null && !fieldSets.isEmpty()) {
                    for (FieldSetFileTransformerModel fieldSet : fieldSets) {
                        List<FieldFileTransformerModel> fields = fieldSet.getFields();
                        if (fields != null && !fields.isEmpty()) {
                            for (FieldFileTransformerModel field : fields) {
                                if (field.getId().equals(id)) {
                                    result = field;
                                    break;
                                }
                            }
                        }
                        if (result != null) {
                            break;
                        }
                    }
                }
            }
        }
        return result;
    }

    private List<SectionFileTransformerModel> calculateSectionVisibility(List<SectionFileTransformerModel> sections) {
        List<SectionFileTransformerModel> result = new ArrayList<>();

        for (SectionFileTransformerModel section : sections) {
            if (section.getSections() != null && !section.getSections().isEmpty()) {
                section.setSections(calculateSectionVisibility(section.getSections()));
            }

            if (section.getFieldSets() != null && !section.getFieldSets().isEmpty()) {
                section.setFieldSets(calculateFieldSetVisibility(section.getFieldSets()));
            }

            if ((section.getSections() != null && !section.getSections().isEmpty()) || (section.getFieldSets() != null && !section.getFieldSets().isEmpty())) {
                result.add(section);
            }
        }

        return result;
    }

    private List<FieldSetFileTransformerModel> calculateFieldSetVisibility(List<FieldSetFileTransformerModel> fieldSets) {
        List<FieldSetFileTransformerModel> result = new ArrayList<>();
        for (FieldSetFileTransformerModel fieldSet : fieldSets) {
            if (fieldSet.getFields() != null && !fieldSet.getFields().isEmpty()) {
                fieldSet.setFields(calculateFieldVisibility(fieldSet.getFields()));
                if (fieldSet.getFields() != null && !fieldSet.getFields().isEmpty()) {
                    result.add(fieldSet);
                }
            }
        }
        return result;
    }

    private List<FieldFileTransformerModel> calculateFieldVisibility(List<FieldFileTransformerModel> fields) {
        List<FieldFileTransformerModel> result = new ArrayList<>();
        for (FieldFileTransformerModel field : fields) {
            if (field.getVisibilityRules() != null && !field.getVisibilityRules().isEmpty()) {
                Integer maxChecks = field.getVisibilityRules().size();
                Integer successfulChecks = 0;
                for (RuleFileTransformerModel rule : field.getVisibilityRules()) {
                    FieldFileTransformerModel targetField = findFieldByPages(definition.getDefinition().getPages(), rule.getTarget());
                    if (targetField.getData() != null ) {
                        successfulChecks = targetField.getData().getValue().equals(rule.getValue()) ? successfulChecks + 1 : successfulChecks;
                    }
                }
                if (successfulChecks.equals(maxChecks)) {
                    result.add(field);
                }
            } else {
                result.add(field);
            }
        }
        return result;
    }

    private FieldFileTransformerModel findFieldByPages(List<PageFileTransformerModel> pages, String fieldId) {
        FieldFileTransformerModel result = null;
        for (PageFileTransformerModel page : pages) {
            result = findFieldBySections(page.getSections(), fieldId);
            if (result != null) {
                break;
            }
        }
        return result;
    }

    private FieldFileTransformerModel findFieldBySections(List<SectionFileTransformerModel> sections, String fieldId) {
        FieldFileTransformerModel result = null;
        for (SectionFileTransformerModel section : sections) {
            if (section.getSections() != null && !section.getSections().isEmpty()) {
                result = findFieldBySections(section.getSections(), fieldId);
                if (result != null) {
                    break;
                }
            }

            if (section.getFieldSets() != null && !section.getFieldSets().isEmpty()) {
                result = findFieldByFieldSets(section.getFieldSets(), fieldId);
                if (result != null) {
                    break;
                }
            }
        }
        return result;
    }

    private FieldFileTransformerModel findFieldByFieldSets(List<FieldSetFileTransformerModel> fieldSets, String fieldId) {
        FieldFileTransformerModel result = null;
        for (FieldSetFileTransformerModel fieldSet: fieldSets) {
            result = findField(fieldSet.getFields(), fieldId);
            if (result != null) {
                break;
            }
        }
        return result;
    }

    private FieldFileTransformerModel findField(List<FieldFileTransformerModel> fields, String fieldId) {
        FieldFileTransformerModel result = null;
        for (FieldFileTransformerModel field: fields) {
            if (field.getId().equals(fieldId)) {
                result = field;
                break;
            }
        }
        return result;
    }

}