package eu.eudat.model.builder.deposit;

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.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.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Optional;

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class DescriptionFieldDepositBuilder extends BaseDepositBuilder<DescriptionFieldDepositModel, FieldEntity> {

    private EnumSet<AuthorizationFlags> authorize = EnumSet.of(AuthorizationFlags.None);
    private eu.eudat.commons.types.descriptiontemplate.DefinitionEntity definition;
    private final FieldDataHelperServiceProvider fieldDataHelperServiceProvider;
    @Autowired
    public DescriptionFieldDepositBuilder(
		    ConventionService conventionService, FieldDataHelperServiceProvider fieldDataHelperServiceProvider
    ) {
        super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionFieldDepositBuilder.class)));
	    this.fieldDataHelperServiceProvider = fieldDataHelperServiceProvider;
    }

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

    public DescriptionFieldDepositBuilder setDefinition(DefinitionEntity definition) {
        this.definition = definition;
        return this;
    }

    @Override
    protected List<DepositBuilderItemResponse<DescriptionFieldDepositModel, 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<DepositBuilderItemResponse<DescriptionFieldDepositModel, FieldEntity>> models = new ArrayList<>();
        ObjectMapper objectMapper = new ObjectMapper();
        for (FieldEntity d : data) {
            DescriptionFieldDepositModel m = new DescriptionFieldDepositModel();
            if (definition != null){

                //TODO Update with the new logic of property definition 
                //List<eu.eudat.commons.types.descriptiontemplate.FieldEntity> fieldEntities = definition.getFieldById(d.getKey());
                List<eu.eudat.commons.types.descriptiontemplate.FieldEntity> fieldEntities = new ArrayList<>();
                if (!this.conventionService.isListNullOrEmpty(fieldEntities)){
                    eu.eudat.commons.types.descriptiontemplate.FieldEntity field = fieldEntities.getFirst();
                    m.setSchematics(field.getSchematics());
                    if (field.getData() != null) {
                        boolean isMultiValue = fieldDataHelperServiceProvider.get(field.getData().getFieldType()).isMultiValue(field.getData());
                        if (!isMultiValue) m.setValues(List.of(d.getTextValue()));
                        else {
	                        try {
                                //TODO: Find better Solution
		                        List<Object> values = objectMapper.readValue(d.getTextValue(), new TypeReference<List<Object>>() {});
                                m.setValues(values);
	                        } catch (JsonProcessingException e) {
		                        throw new RuntimeException(e);
	                        }

                        }
                        
                        switch (field.getData().getFieldType()) {
                            case SELECT -> m.setFieldType(FieldType.WORD_LIST);
                            case BOOLEAN_DECISION -> m.setFieldType(FieldType.BOOLEAN_DECISION);
                            case RADIO_BOX -> m.setFieldType(FieldType.RADIO_BOX);
                            case INTERNAL_ENTRIES_DMPS -> m.setFieldType(FieldType.INTERNAL_DMP_ENTRIES_DMPS);
                            case INTERNAL_ENTRIES_DESCRIPTIONS -> 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 REFERENCE_TYPES -> m.setFieldType(FieldType.REFERENCE_TYPES); //TODO new reference logic
                            case TAGS -> m.setFieldType(FieldType.TAGS);
                            case DATASET_IDENTIFIER -> m.setFieldType(FieldType.DATASET_IDENTIFIER);
                            case CURRENCY -> m.setFieldType(FieldType.CURRENCY);
                            case VALIDATION -> m.setFieldType(FieldType.VALIDATION);
                            default -> throw new MyApplicationException("unrecognized type " + field.getData().getFieldType());
                        }
                    }
                }
            }
            models.add(new DepositBuilderItemResponse<>(m, d));
        }

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

        return models;
    }

}