package at.gv.egiz.moazs.pipeline;


import at.gv.egiz.moazs.msg.MsgClient;
import at.gv.egiz.moazs.msg.MsgClientFactory;
import at.gv.egiz.moazs.tnvz.TnvzClient;
import at.gv.egiz.moazs.repository.DeliveryRepository;
import at.gv.egiz.moazs.scheme.Mzs2MsgConverter;
import at.gv.zustellung.app2mzs.xsd.DeliveryRequestType;
import at.gv.zustellung.app2mzs.xsd.DeliveryRequestType.Payload;
import at.gv.zustellung.msg.xsd.persondata.IdentificationType;
import at.gv.zustellung.tnvz.xsd.PersonResultType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;

import static at.gv.egiz.moazs.MoaZSException.moaZSException;
import static java.lang.String.join;
import static java.util.stream.Collectors.toSet;

@Component
@Profile("!cluster")
public class SameThreadDeliveryPipeline implements DeliveryPipeline {

    private final DeliveryRepository repository;
    private final TnvzClient tnvzClient;
    private final Mzs2MsgConverter converter;
    private final MsgClientFactory msgClientFactory;

    @Autowired
    public SameThreadDeliveryPipeline(DeliveryRepository repository,
                                      TnvzClient tnvzClient,
                                      Mzs2MsgConverter converter,
                                      MsgClientFactory msgClientFactory) {
        this.repository = repository;
        this.tnvzClient = tnvzClient;
        this.converter = converter;
        this.msgClientFactory = msgClientFactory;
    }

    @Override
    public void processRequest(String appDeliveryId) {

        var mzsRequest = repository.getDeliveryRequest(appDeliveryId).orElseThrow();
        var msgRequest = (mzsRequest.getConfig().isPerformQueryPersonRequest())
                ? converter.convert(mzsRequest, queryPerson(mzsRequest))
                : converter.convert(mzsRequest);

        var msgClient = msgClientFactory.create(msgRequest, mzsRequest.getConfig());
        var status = msgClient.send();
        repository.add(status);
    }

    private IdentificationType queryPerson(DeliveryRequestType request) {
        var result = tnvzClient.queryPerson(request.getSender(), request.getReceiver());

        if (result.getError() != null) {
            var error = result.getError();
            var info = error.getErrorInfo();
            var noteSent = (error.getPreAdviceNoteSent() != null) ? "sent" : "not sent";
            var template = "Receiver is not addressable. Code: %s ; Text: %s; Preadvice note was %s.";
            throw moaZSException(template, info.getCode(), info.getText(), noteSent);
        }

        var mismatchedTypes = findMimeTypeMismatches(result, request);

        if (!mismatchedTypes.isEmpty()) {
            var template = "Request contains attachment of type(s) %s, but receiver only accepts attachments of type(s) %s.";
            var acceptedTypesString = join(",", getAcceptedTypes(result));
            var mismatchedTypesString = join(",", mismatchedTypes);
            throw moaZSException(template, mismatchedTypesString, acceptedTypesString);
        }

        return result.getSuccess().getIdentification();
    }

    private Collection<String> findMimeTypeMismatches(PersonResultType result, DeliveryRequestType request) {
        var acceptedTypes = getAcceptedTypes(result);

        if (acceptedTypes.contains("*/*")) {
            return List.of();
        }

        var typesInRequest = request.getPayload().stream()
                .map(Payload::getMIMEType)
                .collect(toSet());

        typesInRequest.removeAll(acceptedTypes);

        return typesInRequest;
    }

    private List<String> getAcceptedTypes(PersonResultType result) {
        return result.getSuccess().getMimeTypeList().getMimeType();
    }

}