package com.example;

import java.io.Serializable;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.xml.bind.JAXBElement;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import net.sf.qallme.WebServiceTools;
import net.sf.qallme.gen.ws.AnnotatedSentence;
import net.sf.qallme.gen.ws.InternalServiceFault;
import net.sf.qallme.gen.ws.AnnotatedSentence.Annotation;
import net.sf.qallme.gen.ws.languageidentification.LanguageIdentifier;
import net.sf.qallme.gen.ws.languageidentification.LanguageIdentifierWS;
import net.sf.qallme.gen.ws.timeannotation.AnnotationRequest;
import net.sf.qallme.gen.ws.timeannotation.ObjectFactory;
import net.sf.qallme.gen.ws.timeannotation.TimeAnnotator;
import net.sf.qallme.gen.ws.timeannotation.TimeAnnotatorWS;

/**
 * Finds temporal expressions in texts and normalizes them.
 */
public class TemporalExpressionFinder {

	/** the WSDL location of the {@link LanguageIdentifier} to use */
	private static final URL LANGUAGE_IDENTIFIER_LOC;
	static {
		try {
			LANGUAGE_IDENTIFIER_LOC = new URL("http://localhost:8080/qmfdemo/"
					+ "languageidentification/LanguageIdentifierWS?wsdl");
		} catch (MalformedURLException e) {
			// should never happen
			throw new IllegalStateException(e);
		}
	}

	/** the WSDL locations of the available {@link TimeAnnotator}s */
	private static Map<String, URL> ANNOTATOR_LOCS;
	static {
		ANNOTATOR_LOCS = new HashMap<String, URL>(3);
		try {
			ANNOTATOR_LOCS.put("de", new URL("http://localhost:8080/qmfdemo/"
					+ "de-timeannotation/TimeAnnotatorWS?wsdl"));
			ANNOTATOR_LOCS.put("es", new URL("http://localhost:8080/qmfdemo/"
					+ "es-timeannotation/TimeAnnotatorWS?wsdl"));
			ANNOTATOR_LOCS.put("en", new URL("http://localhost:8080/qmfdemo/"
					+ "en-timeannotation/TimeAnnotatorWS?wsdl"));
		} catch (MalformedURLException e) {
			// should never happen
			throw new IllegalStateException(e);
		}
	}

	/** an object factory for creating requests to the {@link TimeAnnotator} WS */
	private static final ObjectFactory OBJ_FACTORY = new ObjectFactory();

	/**
	 * an object factory for creating {@link AnnotatedSentence}s in requests to
	 * the {@link TimeAnnotator} WS
	 */
	private static final net.sf.qallme.gen.ws.ObjectFactory OBJ_FACTORY2 = new net.sf.qallme.gen.ws.ObjectFactory();

	/** the internally used {@link LanguageIdentifier} */
	private final LanguageIdentifier langIdentifier;

	/** the internally used {@link TimeAnnotator}s */
	private final Map<String, TimeAnnotator> timeAnnotators;

	/** the temporal context to normalize temporal expressions against */
	private final XMLGregorianCalendar calendar;

	/**
	 * Constructs and initializes a new {@link TemporalExpressionFinder} with
	 * the temporal context being the current date and time.
	 * 
	 * @throws RuntimeException
	 *             if there is a problem creating any of the web service
	 *             connections
	 */
	public TemporalExpressionFinder() throws RuntimeException {
		// set the temporal context to the current date and time
		try {
			this.calendar = DatatypeFactory
					.newInstance()
					.newXMLGregorianCalendar(
							(GregorianCalendar) GregorianCalendar.getInstance());
		} catch (DatatypeConfigurationException e) {
			// should not happen
			throw new IllegalStateException(e);
		}

		// TODO: correctly initialize the web services here:
		this.langIdentifier = null;
		this.timeAnnotators = new HashMap<String, TimeAnnotator>(ANNOTATOR_LOCS
				.size());
	}

	/**
	 * Finds temporal expressions in texts and normalizes them.
	 * 
	 * @param args
	 *            the text strings from which to extract and normalize temporal
	 *            expressions
	 * @throws IllegalArgumentException
	 *             if any of the given texts is of an unsupported language
	 * @throws InternalServiceFault
	 *             if there is some problem with web service invocation
	 */
	public static void main(String[] args) throws IllegalArgumentException,
			InternalServiceFault {
		TemporalExpressionFinder finder = new TemporalExpressionFinder();

		// find and normalize all temporal expressions in the given texts:
		for (String text : args) {
			System.out.println("Normalized temporal expressions of: " + text);
			for (String timex : finder.find(text)) {
				System.out.print("\t– ");
				System.out.println(timex);
			}
			System.out.println();
		}
	}

	/**
	 * Finds temporal expressions in the given text and returns them as
	 * normalized TIMEX2 annotations.
	 * 
	 * @param text
	 *            the text in which to find temporal expressions
	 * @return normalized TIMEX2 annotations
	 * @throws IllegalArgumentException
	 *             if the the given text is of an unsupported language
	 * @throws InternalServiceFault
	 *             if there is some problem with web service invocation
	 */
	private List<String> find(String text) throws IllegalArgumentException,
			InternalServiceFault {
		// identify the language of the given text and make sure that we have a
		// temporal expression annotator for this language
		String lang = this.langIdentifier.getLanguage(text);
		TimeAnnotator annotator = this.timeAnnotators.get(lang);
		if (annotator == null)
			throw new IllegalArgumentException("Language not supported: "
					+ lang);

		return findAndNormalize(annotator, text);
	}

	/**
	 * Finds temporal expressions in the given text and returns them as
	 * normalized TIMEX2 annotations. The given annotator is used for finding
	 * and normalizing.
	 * 
	 * @param annotator
	 *            the annotator to use for finding and normalizing
	 * @param text
	 *            the text in which to find temporal expressions
	 * @return normalized TIMEX2 annotations
	 * @throws InternalServiceFault
	 *             if there is some problem with web service invocation
	 */
	private List<String> findAndNormalize(TimeAnnotator annotator, String text)
			throws InternalServiceFault {
		List<String> result = new ArrayList<String>();

		// TODO use the selected time annotator to create the result

		return result;
	}

}

public TemporalExpressionFinder() throws RuntimeException {
	// initialize connection to the LanguageIdentifier WS
	this.langIdentifier = WebServiceTools
			.instantiateServiceClientInterface(LanguageIdentifierWS.class,
					LANGUAGE_IDENTIFIER_LOC).getLanguageIdentifierPort();

	// initialize connections to the different TimeAnnotator WSs
	this.timeAnnotators = new HashMap<String, TimeAnnotator>(ANNOTATOR_LOCS
			.size());
	for (Entry<String, URL> annotLoc : ANNOTATOR_LOCS.entrySet())
		this.timeAnnotators.put(annotLoc.getKey(), WebServiceTools
				.instantiateServiceClientInterface(TimeAnnotatorWS.class,
						annotLoc.getValue()).getTimeAnnotatorPort());
}

@SuppressWarnings("unchecked")
private List<String> findAndNormalize(TimeAnnotator annotator, String text)
		throws InternalServiceFault {
	List<String> result = new ArrayList<String>();

	// create a request to the TimeAnnotator:
	AnnotatedSentence annotSent = OBJ_FACTORY2.createAnnotatedSentence();
	annotSent.getContent().add(text);
	AnnotationRequest request = OBJ_FACTORY.createAnnotationRequest();
	request.setAnnotatedSentence(annotSent);
	request.setTemporalContext(this.calendar);

	// run the TimeAnnotator WS
	annotSent = annotator.annotateTime(request);

	// extract the annotations from the TimeAnnotator’s response and return
	// them
	for (Serializable s : annotSent.getContent())
		if (s instanceof JAXBElement)
			result.add(((JAXBElement<Annotation>) s).getValue()
					.getCanonicalForm());
	return result;
}