package at.gv.egovernment.moa.id.protocols.stork2;

import at.gv.egovernment.moa.id.auth.exception.AuthenticationException;
import at.gv.egovernment.moa.id.auth.exception.MOAIDException;
import at.gv.egovernment.moa.id.config.auth.AuthConfigurationProvider;
import at.gv.egovernment.moa.id.config.auth.OAAuthParameter;
import at.gv.egovernment.moa.id.data.IAuthData;
import at.gv.egovernment.moa.id.data.SLOInformationInterface;
import at.gv.egovernment.moa.id.moduls.IAction;
import at.gv.egovernment.moa.id.moduls.IRequest;
import at.gv.egovernment.moa.logging.Logger;
import eu.stork.peps.auth.commons.IPersonalAttributeList;
import eu.stork.peps.auth.commons.PersonalAttribute;
import eu.stork.peps.auth.commons.PersonalAttributeList;
import eu.stork.peps.auth.commons.STORKAttrQueryResponse;
import eu.stork.peps.complex.attributes.CanonicalAddressType;
import eu.stork.peps.complex.attributes.MandateContentType;
import eu.stork.peps.complex.attributes.MandateType;
import eu.stork.peps.complex.attributes.RepresentationPersonType;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Marshaller;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.namespace.QName;
import java.io.StringWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;

/**
 *
 */
public class MandateRetrievalRequest implements IAction {

    private IAuthData authData;
    private MOASTORKRequest moaStorkRequest;

    public SLOInformationInterface processRequest(IRequest req, HttpServletRequest httpReq, HttpServletResponse httpResp, IAuthData authData) throws MOAIDException {
        Logger.debug("Entering AttributeRequest for MandateProvider");
        httpResp.reset();
        OAAuthParameter oaParam = AuthConfigurationProvider.getInstance().getOnlineApplicationParameter(req.getOAURL());
        if (oaParam == null)
            throw new AuthenticationException("stork.12", new Object[]{req.getOAURL()});

        MOASTORKResponse moaStorkResponse = new MOASTORKResponse();
        STORKAttrQueryResponse attrResponse = new STORKAttrQueryResponse();

        this.authData = authData;

        if ((req instanceof MOASTORKRequest)) {
            this.moaStorkRequest = (MOASTORKRequest) req;

        } else {
            return null; // TODO
        }


        if (moaStorkRequest.isAttrRequest() && moaStorkRequest.getStorkAttrQueryRequest() != null) {
            MandateContainer mandateContainer = null;

            try {
                mandateContainer = new CorporateBodyMandateContainer(new String(authData.getMISMandate().getMandate(), "UTF-8"));
            } catch (Exception ex) {
                try {
                    mandateContainer = new PhyPersonMandateContainer(new String(authData.getMISMandate().getMandate(), "UTF-8"));
                } catch (Exception ex2) {
                    Logger.error("Could not extract data and create mandate container.");
                    throw new MOAIDException("stork.16", new Object[]{}); // TODO
                }
            }

            if (mandateContainer instanceof CorporateBodyMandateContainer) {

            } else if (mandateContainer instanceof PhyPersonMandateContainer) {

            }


//            moaStorkResponse.setPersonalAttributeList(populateAttributes());

            //moaStorkResponse.setCountry(moaStorkRequest.getSpCountry());

            IPersonalAttributeList sourceAttributeList = moaStorkRequest.getStorkAttrQueryRequest().getPersonalAttributeList();

            IPersonalAttributeList attributeList = new PersonalAttributeList();

            for (PersonalAttribute currentAttribute : sourceAttributeList) {
                Logger.debug("Evaluating currentattribute " + currentAttribute.getName());
                if (currentAttribute.getName().equals("mandateContent")) {
                    MandateContentType mandateContent = getMandateContent(mandateContainer, currentAttribute);
                    attributeList.add(marshallComplexAttribute(currentAttribute, mandateContent));

                    // final Marshaller marshaller = JAXBContext.newInstance(MandateContentType.class).createMarshaller();
                    // marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

                    // StringWriter stringWriter = new StringWriter();

                    // marshaller.marshal(new JAXBElement<MandateContentType>(new QName("urn:eu:stork:names:tc:STORK:1.0:assertion", "mandateContent"), MandateContentType.class, null, mandateContent), stringWriter);

                    // ArrayList<String> value = new ArrayList<String>();
                    // value.add(stringWriter.toString());

                    // PersonalAttribute  mandateContentAttribute = new PersonalAttribute("mandateContent", false, value, "Available");

                    // attributeList.add(mandateContentAttribute);
                } else if (currentAttribute.getName().equals("representative")) {  //  TODO CHECK
                    RepresentationPersonType representative = getRepresentative(mandateContainer, currentAttribute);
                    attributeList.add(marshallComplexAttribute(currentAttribute, representative));

                    //attributeList.add(getRepresentative(mandateContainer, currentAttribute));
                } else if (currentAttribute.getName().equals("represented")) {
                    //attributeList.add(getRepresented(mandateContainer, currentAttribute));
                    RepresentationPersonType represented = getRepresented(mandateContainer, currentAttribute);
                    attributeList.add(marshallComplexAttribute(currentAttribute, represented));

                } else if (currentAttribute.getName().equals("mandate")) {
                    //attributeList.add(getMandateType(mandateContainer, currentAttribute));
                    MandateType mandateType = getMandateType(mandateContainer, currentAttribute);
                    attributeList.add(marshallComplexAttribute(currentAttribute, mandateType));

                } else if (currentAttribute.getName().equals("legalName")) {
                    String legalName = getLegalName(mandateContainer, currentAttribute);
                    PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(legalName), "Available");
                    attributeList.add(personalAttribute);
                } else if (currentAttribute.getName().equals("eLPIdentifier")) {
                    String eLPIdentifier = geteLPIdentifier(mandateContainer, currentAttribute);
                    PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(eLPIdentifier), "Available");
                    attributeList.add(personalAttribute);
                }

            }

            attrResponse.setPersonalAttributeList(attributeList);
            moaStorkResponse.setSTORKAttrResponse(attrResponse);

            Logger.debug("Attributes " + moaStorkResponse.getStorkAttrQueryResponse().getPersonalAttributeList().size());

            // Prepare extended attributes
            Logger.debug("Preparing data container");

            // create fresh container
            DataContainer container = new DataContainer();

            // - fill in the request we extracted above
            container.setRequest(moaStorkRequest);

            // - fill in the partial response created above
            container.setResponse(moaStorkResponse);

            container.setRemoteAddress(httpReq.getRemoteAddr());

            Logger.debug("Data container prepared");

            // ask for consent if necessary
            if (oaParam.isRequireConsentForStorkAttributes())
                new ConsentEvaluator().requestConsent(container, httpResp, oaParam);
            else
                new ConsentEvaluator().generateSTORKResponse(httpResp, container);
        }


        return null;  //
    }

    private String geteLPIdentifier(MandateContainer mandateContainer, PersonalAttribute currentAttribute) throws MOAIDException {
        RepresentationPersonType represented = getRepresented(mandateContainer, currentAttribute);
        if (mandateContainer instanceof CorporateBodyMandateContainer) {
            return represented.getELPIdentifier();
        } else {
            Logger.error("Cannot provide eLPIdentifier for natural person.");
            throw new MOAIDException("stork.16", new Object[]{}); // TODO
        }

    }

    private PersonalAttribute marshallComplexAttribute(PersonalAttribute currentAttribute, Object obj) {    // TODO refactor


        StringWriter stringWriter = new StringWriter();
        try {
            if (obj instanceof MandateContentType) {
                final Marshaller marshaller = JAXBContext.newInstance(MandateContentType.class).createMarshaller();
                marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
                marshaller.marshal(new JAXBElement<MandateContentType>(new QName("urn:eu:stork:names:tc:STORK:1.0:assertion", currentAttribute.getName()), MandateContentType.class, null, (MandateContentType) obj), stringWriter);
            } else if (obj instanceof MandateType) {
                final Marshaller marshaller = JAXBContext.newInstance(MandateType.class).createMarshaller();
                marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
                marshaller.marshal(new JAXBElement<MandateType>(new QName("urn:eu:stork:names:tc:STORK:1.0:assertion", currentAttribute.getName()), MandateType.class, null, (MandateType) obj), stringWriter);
            } else if (obj instanceof RepresentationPersonType) {
                final Marshaller marshaller = JAXBContext.newInstance(RepresentationPersonType.class).createMarshaller();
                marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
                marshaller.marshal(new JAXBElement<RepresentationPersonType>(new QName("urn:eu:stork:names:tc:STORK:1.0:assertion", currentAttribute.getName()), RepresentationPersonType.class, null, (RepresentationPersonType) obj), stringWriter);
            }

        } catch (Exception ex) {
            Logger.error("Could not marshall atrribute: " + currentAttribute.getName() + ", " + ex.getMessage());
            return new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), new ArrayList<String>(), "NotAvailable");
        }
        ArrayList<String> value = new ArrayList<String>();
        value.add(stringWriter.toString());

        PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), value, "Available");

        return personalAttribute;
    }


    private String mapPowersType(MandateContainer mandateContainer) {    // TODO
        return "";
    }

    private String mapCompanyType(MandateContainer mandateContainer) {    // TODO
        return "";
    }

    private MandateType getMandateType(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
        MandateType mandateType = new MandateType();
        RepresentationPersonType representative = getRepresentative(mandateContainer, sourceAttribute);
        RepresentationPersonType represented = getRepresented(mandateContainer, sourceAttribute);
        MandateContentType mandateContent = getMandateContent(mandateContainer, sourceAttribute);
        mandateType.setRepresenting(representative);
        mandateType.setRepresented(represented);
        mandateType.setMandateContent(mandateContent);
        Logger.debug("Complex attribute extracted: " + sourceAttribute.getName());
        return mandateType;
    }

    private String getLegalName(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
        RepresentationPersonType represented = getRepresented(mandateContainer, sourceAttribute);
        if (mandateContainer instanceof CorporateBodyMandateContainer) {
            return represented.getName();
        } else {
            Logger.error("Cannot provide legalName for natural person.");
            throw new MOAIDException("stork.16", new Object[]{}); // TODO
        }
    }


    private RepresentationPersonType getRepresentative(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) {
        RepresentationPersonType representative = new RepresentationPersonType();

        representative.setEIdentifier(""); // TODO CALCULATE
        representative.setGivenName(mandateContainer.getPhysicalRepresentativeGivenName());
        representative.setSurname(mandateContainer.getPhysicalRepresentativeFamilyName());
        representative.setDateOfBirth(mandateContainer.getPhysicalRepresentativeBirthDate());

        Logger.debug("Complex attribute extracted: " + sourceAttribute.getName());
        return representative;
    }

    private RepresentationPersonType getRepresented(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) {
        RepresentationPersonType represented = new RepresentationPersonType();

        if (mandateContainer instanceof CorporateBodyMandateContainer) {
            CorporateBodyMandateContainer corporateBodyMandateContainer = (CorporateBodyMandateContainer) mandateContainer;
            represented.setELPIdentifier(corporateBodyMandateContainer.getCorpMandatorIdentificationValue());
            represented.setName(corporateBodyMandateContainer.getCorpMandatorFullName());
            represented.setAddress("");
            represented.setCanonicalAddress(new CanonicalAddressType());
            represented.setType(mapCompanyType(mandateContainer));     // TODO
        } else if (mandateContainer instanceof PhyPersonMandateContainer) {
            PhyPersonMandateContainer phyPersonMandateContainer = (PhyPersonMandateContainer) mandateContainer;
            represented.setEIdentifier(""); // TODO CALCULATE
            represented.setGivenName(phyPersonMandateContainer.getPhyPersMandatorGivenName());
            represented.setSurname(phyPersonMandateContainer.getPhyPersMandatorFamilyName());
            represented.setDateOfBirth(phyPersonMandateContainer.getPhyPersMandatorBirthDate());
        }

        Logger.debug("Complex attribute extracted: " + sourceAttribute.getName());

        return represented;
    }


    private MandateContentType getMandateContent(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
        MandateContentType mandateContent = new MandateContentType();
        try {
            XMLGregorianCalendar validFrom = DatatypeFactory.newInstance().newXMLGregorianCalendar(mandateContainer.getMandateValidFrom());

            XMLGregorianCalendar validTo = DatatypeFactory.newInstance().newXMLGregorianCalendar(mandateContainer.getMandateValidTo());
            mandateContent.setValidFrom(validFrom);
            mandateContent.setValidTo(validTo);
        } catch (DatatypeConfigurationException dte) {
            Logger.error("Error converting data from mandate");
            throw new MOAIDException("stork.16", new Object[]{}); // TODO
        }

        mandateContent.setTransactionLimit(BigInteger.valueOf(0)); // TODO
        mandateContent.setTransactionLimitCurrency("");// TODO
        mandateContent.setIsJoint("");
        mandateContent.setIschained(false);
        mandateContent.setTypePower(mapPowersType(mandateContainer));
        Logger.debug("Complex attribute extracted: " + sourceAttribute.getName());
        return mandateContent;
    }

    public boolean needAuthentication(IRequest req, HttpServletRequest httpReq, HttpServletResponse httpResp) {
        return true;  //
    }

    public String getDefaultActionName() {
        return STORKProtocol.MANDATERETRIEVALREQUEST;
    }
}