/*
 * This work is Open Source and licensed by the European Commission under the conditions of the European Public License
 * v1.1 (http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1); any use of this file implies acceptance of
 * the conditions of this license. Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing permissions and limitations under the License. --- Test
 * cases for marshalling complex attributes. Implemented are two testcases for marshalling and unmarshalling. These
 * testcases are for canonical residenc address and has bank account.
 */

package eu.stork.peps.tests;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;

import org.joda.time.DateTime;
import org.junit.Test;

import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.CanonicalAddressType;
import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.HasAccountInBankType;
import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.MandateContentType;
import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.MandateType;
import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.ObjectFactory;
import eu.stork.peps.complex.attributes.eu.stork.names.tc.stork._1_0.assertion.RepresentationPersonType;

/**
 * @author Advania Examples on how to use the jaxb marshaller. The classes are created from the StorkcomplexAttributes.xsd schema located in resources.
 * @version $Revision: 1.00 $, $Date: 2014-17-02 11:15:00 $
 *
 */

public class ComplexAttributesMarshalling {

	MandateContentType mtObject = new MandateContentType();
	RepresentationPersonType rpObject = new RepresentationPersonType();
	RepresentationPersonType rptObject = new RepresentationPersonType();

	void initMandateValues() {
		// Fill in the information ...
		mtObject.setIsChained(false);
		// mtObject.setIsJoined("IsJoined");
		mtObject.setTypeOfPower("The Force");
		mtObject.setIsChained(false);
		// ... fill in info for the representative
		rpObject.setTextRegisteredAddress("Address at some street");
		rpObject.setDateOfBirth(DateTime.now().toString());
		rpObject.setEIdentifier("123456");
		rpObject.setGivenName("Name of some person");
		rpObject.setLegalForm("Type of person");
		// .... fill in the info for the represented
		rptObject.setTextRegisteredAddress("Another Address at some street");
		rptObject.setDateOfBirth(DateTime.now().toString());
		rptObject.setEIdentifier("654321");
		rptObject.setGivenName("Another Name of some person");
		rptObject.setLegalForm("Yet another type of person");
	}

	/**
	 * Test marshalling canonical address <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <canonicalResidenceAddress xmlns="urn:eu:stork:names:tc:STORK:1.0:assertion">
	 * <countryCodeAddress>IS</countryCodeAddress> <state>Reykjavik</state> <municipalityCode>RVK</municipalityCode> <town>Reykjavik</town> <postalCode>101</postalCode>
	 * <streetName>Laugavegur</streetName> <streetNumber>1</streetNumber> <apartmentNumber>10</apartmentNumber> </canonicalResidenceAddress>
	 */
	@Test
	public void testMarshallCanonicalResidencAddress() {
		try {
			final CanonicalAddressType object = new CanonicalAddressType();
			object.setApartmentNumber("10");
			object.setCountryCodeAddress("IS");
			object.setMunicipalityCode("RVK");
			object.setPostalCode("101");
			object.setState("Reykjavik");
			object.setStreetName("Laugavegur");
			object.setStreetNumber("1");
			object.setTown("Reykjavik");

			final JAXBContext context = JAXBContext.newInstance(CanonicalAddressType.class);
			final Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
			final ObjectFactory objf = new ObjectFactory();

			m.marshal(objf.createCanonicalResidenceAddress(object), new FileOutputStream("CanonicalAddressType.xml"));
			m.marshal(objf.createCanonicalResidenceAddress(object), System.out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testForDiana() {
		initMandateValues();

		try {
			// Create the marshallers'

			final JAXBContext mandateTypeContext = JAXBContext.newInstance(MandateType.class);
			final Marshaller mandateMarshaller = mandateTypeContext.createMarshaller();
			final Unmarshaller mandateUnmarshaller = mandateTypeContext.createUnmarshaller();

			// final JAXBContext MandateContentTypecontext = JAXBContext.newInstance(MandateContentType.class);
			// final Marshaller mandM = MandateContentTypecontext.createMarshaller();
			//
			// final JAXBContext RepresentationPersonTypecontext =
			// JAXBContext.newInstance(RepresentationPersonType.class);
			// final Marshaller repM = RepresentationPersonTypecontext.createMarshaller();
			//

			final ObjectFactory objf = new ObjectFactory();
			MandateType mandate = new MandateType();
			RepresentationPersonType representative = new RepresentationPersonType();
			representative.setDateOfBirth("1990-01-01");
			representative.setGivenName("Bilbo");
			representative.setSurname("Baggins");
			representative.setEIdentifier("IT/IT/12345678990");
			mandate.setRepresentative(representative);

			RepresentationPersonType represented = new RepresentationPersonType();
			represented.setTextRegisteredAddress("Via....");
			represented.setELPIdentifier("IT/1111111");
			represented.setLegalName("Shire Corp.");
			mandate.setRepresented(represented);

			MandateContentType mandateContent1 = new MandateContentType();
			// OriginalMandateType omt1 = new OriginalMandateType();
			// omt1.setMimeType("text/plain");
			// omt1.setValue("Chief executive officer".getBytes());
			mandateContent1.setOriginalMandate("Chief executive officer".getBytes());
			mandateContent1.setOriginalMandateType("text/plain");
			MandateContentType mandateContent2 = new MandateContentType();
			// mandateContent2.setOriginalMandate(omt1);
			mandateContent2.setOriginalMandate("Chief executive officer2".getBytes());
			mandateContent2.setOriginalMandateType("text/plain");
			mandate.getMandateContent().add(mandateContent1);
			mandate.getMandateContent().add(mandateContent2);

			// create a hashmap
			// HashMap<String, String> complexMandate = new HashMap<String, String>();

			// marshall the mandatecontent
			StringWriter sw = new StringWriter();
			mandateMarshaller.marshal(objf.createMandate(mandate), sw);

			System.out.print(sw.toString());

			// add it to the hashmap
			// complexMandate.put("representative", sw.toString());
			// sw.flush();
			//
			// // continue with the rest of the objects.
			// repM.marshal(objf.createRepresentationPerson(rpObject), sw);
			// System.out.print(sw.toString());
			// complexMandate.put("representative", sw.toString());
			// sw.flush();
			//
			// MandateType mandateType = new MandateType();
			//
			// repM.marshal(objf.createRepresentationPerson(rptObject), sw);
			// System.out.print(sw.toString());
			// complexMandate.put("represented", sw.toString());
			// sw.flush();
			//
			// // add the complex values to the attr.list.
			// PersonalAttribute pal = new PersonalAttribute();
			//
			// pal.setName("mandateContent");
			// pal.setIsRequired(pal.isRequired());
			// pal.setStatus(STORKStatusCode.STATUS_AVAILABLE.toString());
			// pal.setComplexValue(complexMandate);
			//
			// System.out.println(pal.toString());
		} catch (JAXBException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testMandateContent() {
		initMandateValues();
		try {
			final MandateType object = new MandateType();
			// Make the object ....
			object.getMandateContent().add(mtObject);
			object.setRepresented(rpObject);
			object.setRepresentative(rptObject);

			final JAXBContext context = JAXBContext.newInstance(MandateType.class);
			// Create the marshaller
			final Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
			final ObjectFactory objf = new ObjectFactory();
			// Various types of output
			m.marshal(objf.createMandate(object), new FileOutputStream("MandateContentType.xml"));
			m.marshal(objf.createMandate(object), System.out);

			StringWriter sw = new StringWriter();
			m.marshal(objf.createMandate(object), sw);

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Test unmarshalling canonical address <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <canonicalResidenceAddress xmlns="urn:eu:stork:names:tc:STORK:1.0:assertion">
	 * <countryCodeAddress>IS</countryCodeAddress> <state>Reykjavik</state> <municipalityCode>RVK</municipalityCode> <town>Reykjavik</town> <postalCode>101</postalCode>
	 * <streetName>Laugavegur</streetName> <streetNumber>1</streetNumber> <apartmentNumber>10</apartmentNumber> </canonicalResidenceAddress>
	 */
	@Test
	public void testUnmarshallCanonicalAddress() {
		JAXBContext uContext;
		try {
			uContext = JAXBContext.newInstance(CanonicalAddressType.class);
			final Unmarshaller u = uContext.createUnmarshaller();
			final File file = new File("CanonicalAddressType.xml");

			final JAXBElement<CanonicalAddressType> root = u.unmarshal(new StreamSource(file), CanonicalAddressType.class);
			final CanonicalAddressType foo = root.getValue();

			final String A = foo.getStreetName();
			final String B = foo.getStreetNumber();

			System.out.println("Streetname: " + A);
			System.out.println("Streetnumber: " + B);

		} catch (final JAXBException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Test marshalling has bank account <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <hasAccountInBank xmlns="urn:eu:stork:names:tc:STORK:1.0:assertion"> <bankName>Arion</bankName>
	 * <AQAA>3</AQAA> </hasAccountInBank>
	 */
	@Test
	public void testMarshallHasBankAccount() {
		try {
			final HasAccountInBankType object = new HasAccountInBankType();
			object.setAQAA(3);
			object.setBankName("Arion Bank");
			final JAXBContext context = JAXBContext.newInstance(HasAccountInBankType.class);
			final Marshaller m = context.createMarshaller();
			final ObjectFactory o = new ObjectFactory();
			m.marshal(o.createHasAccountInBank(object), new FileOutputStream("hasbankaccount.xml"));
			m.marshal(o.createHasAccountInBank(object), System.out);

		} catch (FileNotFoundException e) {
			e.printStackTrace();

		} catch (Exception e) {
			e.printStackTrace();

		}
	}

	/**
	 * Test unmarshalling has bank account <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <hasAccountInBank xmlns="urn:eu:stork:names:tc:STORK:1.0:assertion"> <bankName>Arion</bankName>
	 * <AQAA>3</AQAA> </hasAccountInBank>
	 */
	@Test
	public void testUnmarshallHasBankAccount() {
		try {
			final JAXBContext context = JAXBContext.newInstance(HasAccountInBankType.class);
			final Unmarshaller um = context.createUnmarshaller();
			final File file = new File("hasbankaccount.xml");
			final JAXBElement<HasAccountInBankType> root = um.unmarshal(new StreamSource(file), HasAccountInBankType.class);
			final HasAccountInBankType foo = root.getValue();
			System.out.println(foo.getBankName());
		} catch (final JAXBException e) {
			e.printStackTrace();
		}
	}

}