package eu.eudat.controllers;

import eu.eudat.audit.AuditableAction;
import gr.cite.tools.validation.ValidationFilterAnnotation;
import eu.eudat.model.EntityDoi;
import eu.eudat.model.censorship.EntityDoiCensor;
import eu.eudat.model.censorship.deposit.DepositConfigurationCensor;
import eu.eudat.model.deposit.DepositConfiguration;
import eu.eudat.model.persist.deposit.DepositAuthenticateRequest;
import eu.eudat.model.persist.deposit.DepositRequest;
import eu.eudat.service.deposit.DepositService;
import gr.cite.tools.auditing.AuditService;
import gr.cite.tools.data.censor.CensorFactory;
import gr.cite.tools.fieldset.FieldSet;
import gr.cite.tools.logging.LoggerService;
import gr.cite.tools.logging.MapLogEntry;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.util.AbstractMap;
import java.util.List;
import java.util.Map;

@RestController
@CrossOrigin
@RequestMapping(value = {"/api/deposit/"})
public class DepositController {

    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DepositController.class));


    private final DepositService depositService;

    private final CensorFactory censorFactory;

    private final AuditService auditService;

    @Autowired
    public DepositController(DepositService depositService, CensorFactory censorFactory, AuditService auditService) {
        this.depositService = depositService;
        this.censorFactory = censorFactory;
        this.auditService = auditService;
    }

    @GetMapping("/repositories/available")
    public List<eu.eudat.model.deposit.DepositConfiguration> getAvailableRepos(FieldSet fieldSet) {
        logger.debug(new MapLogEntry("retrieving" + DepositConfiguration.class.getSimpleName()).And("fields", fieldSet));

        this.censorFactory.censor(DepositConfigurationCensor.class).censor(fieldSet, null);

        List<DepositConfiguration> model = this.depositService.getAvailableConfigurations(fieldSet);
        this.auditService.track(AuditableAction.Deposit_GetAvailableRepositories, Map.ofEntries(
                new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
        ));

        return model;
    }

    @PostMapping("/get-access-token")
    @ValidationFilterAnnotation(validator = DepositAuthenticateRequest.DepositAuthenticateRequestValidator.ValidatorName, argumentName = "model")
    public String getAccessToken(@RequestBody DepositAuthenticateRequest model) {
        logger.debug(new MapLogEntry("get access token" + DepositAuthenticateRequest.class.getSimpleName()).And("model", model));

        String accessToken = this.depositService.authenticate(model);
        this.auditService.track(AuditableAction.Deposit_GetAccessToken, Map.ofEntries(
                new AbstractMap.SimpleEntry<String, Object>("model", model)
        ));

        return accessToken;
    }

    @PostMapping("/deposit")
    @Transactional
    @ValidationFilterAnnotation(validator = DepositRequest.DepositRequestValidator.ValidatorName, argumentName = "model")
    public EntityDoi deposit(@RequestBody DepositRequest model) throws Exception {
        logger.debug(new MapLogEntry("persisting" + DepositRequest.class.getSimpleName()).And("model", model).And("fieldSet", model.getProject()));
        this.censorFactory.censor(EntityDoiCensor.class).censor(model.getProject(), null);

        EntityDoi persisted = this.depositService.deposit(model);
        this.auditService.track(AuditableAction.Deposit_Deposit, Map.ofEntries(
                new AbstractMap.SimpleEntry<String, Object>("model", model)
        ));

        return persisted;
    }

    @GetMapping("/repositories/{repositoryId}/logo")
    public String getLogo(@PathVariable("repositoryId") String repositoryId) {
        logger.debug(new MapLogEntry("get logo" + DepositConfiguration.class.getSimpleName()).And("repositoryId", repositoryId));

        String logo = this.depositService.getLogo(repositoryId);
        this.auditService.track(AuditableAction.Deposit_GetLogo, Map.ofEntries(
                new AbstractMap.SimpleEntry<String, Object>("repositoryId", repositoryId)
        ));

        return logo;
    }
}