/**
 * GenSpeakDemo: XML-based Generation plus Speech
 *
 * Graham Wilcock, University of Helsinki, 2002
 */

// JAXP classes
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException; 

// SAX classes
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.ParserAdapter;
import org.xml.sax.helpers.XMLReaderFactory;
import org.xml.sax.XMLReader;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;

// TraX classes
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.dom.DOMResult;

// Java I/O classes
import java.io.InputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.IOException;
import java.util.Locale;

// JSAPI classes for speech synthesis
import javax.speech.Central;
import javax.speech.Engine;
import javax.speech.synthesis.Synthesizer;
import javax.speech.synthesis.SynthesizerModeDesc;
import javax.speech.synthesis.SynthesizerProperties;
import javax.speech.synthesis.Voice;

  /**
   * GenSpeakDemo reads annotation graphs in XML
   * from files named as command-line arguments,
   * generates and prints Finnish and English responses,
   * and speaks the English responses via FreeTTS.
   * It creates a pipeline of XSL Transformers defined by
   * (1) AG-GetContent.xsl (content determination)
   * (2) AG-ResponsePlanner.xsl (response planning)
   * (3) FI- or EN-Lexicalization.xsl (lexicalization)
   * (4) FI- or EN-ReferringExps.xsl (referring expressions)
   * (5) FI- or EN-SurfaceRealizer.xsl (morphological realization).
   * The generated response is output as speech by 
   * (6) FreeTTS (speech synthesizer)
   */
public class GenSpeakDemo
{
    public static void main(String[] args)
	throws TransformerException, TransformerConfigurationException, 
	       SAXException, IOException	   
    {
	if (args.length == 0) {
	    System.out.println("Usage: java GenSpeakDemo <AG-files>");
	    System.exit(1);
	}

	System.out.println("\nGenSpeakDemo: Initializing Synthesizer...");
	Synthesizer synthesizer = null;
	try {
	    SynthesizerModeDesc unlimited = new SynthesizerModeDesc(
	      "Unlimited domain FreeTTS Speech Synthesizer from Sun Labs",
	       null, Locale.US, Boolean.FALSE, null);

	    synthesizer = Central.createSynthesizer(unlimited);
	    if (synthesizer == null) {
		String message = "Can't find synthesizer.\n" +
		  "You need a \"speech.properties\" file at " +
		  System.getProperty("user.home") + "\n";
		System.err.println(message);
		System.exit(1);
	    }
	    synthesizer.allocate();
	}
	catch (Exception e) {
	    e.printStackTrace();
	    System.exit(1);
	}

	for (int i=0; i<args.length; i++) {
	    String agraphFile = null;
	    if (args[i].endsWith(".xml"))
		agraphFile = args[i];
	    else
		agraphFile = "AG-Esimerkit/" + args[i] + ".xml";
	    System.out.println();
	    System.out.println("Generating from " + agraphFile);

    // Instantiate  a TransformerFactory.
  	TransformerFactory tFactory = TransformerFactory.newInstance();
    // Determine whether it supports SAXSource and SAXResult
    if (tFactory.getFeature(SAXSource.FEATURE) &&
	tFactory.getFeature(SAXResult.FEATURE))
    { 
      // Cast the TransformerFactory to SAXTransformerFactory.
      SAXTransformerFactory saxTFactory = ((SAXTransformerFactory) tFactory);	  
      // Create a TransformerHandler for each stylesheet.
      TransformerHandler fi_getcontent =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("AG-GetContent.xsl"));
      TransformerHandler fi_responseplanner =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("AG-ResponsePlanner.xsl"));
      TransformerHandler fi_lexicalization =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("FI-Lexicalization.xsl"));
      TransformerHandler fi_referringexps =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("FI-ReferringExps.xsl"));
      TransformerHandler fi_realization =
          saxTFactory.newTransformerHandler(new StreamSource
					    ("FI-SurfaceRealizer.xsl"));
      TransformerHandler en_getcontent =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("AG-GetContent.xsl"));
      TransformerHandler en_responseplanner =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("AG-ResponsePlanner.xsl"));
      TransformerHandler en_lexicalization =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("EN-Lexicalization.xsl"));
      TransformerHandler en_referringexps =
	  saxTFactory.newTransformerHandler(new StreamSource
					    ("EN-ReferringExps.xsl"));
      TransformerHandler en_realization =
          saxTFactory.newTransformerHandler(new StreamSource
					    ("EN-SurfaceRealizer.xsl"));
    

      String fi_responseString = null;
      String en_responseString = null;
	  
      // Prepare Finnish pipeline
      XMLReader fi_reader = XMLReaderFactory.createXMLReader();
      fi_reader.setContentHandler(fi_getcontent);
      fi_reader.setProperty("http://xml.org/sax/properties/lexical-handler",
			    fi_getcontent);
      fi_getcontent.setResult(new SAXResult(fi_responseplanner));
      fi_responseplanner.setResult(new SAXResult(fi_lexicalization));
      fi_lexicalization.setResult(new SAXResult(fi_referringexps));
      fi_referringexps.setResult(new SAXResult(fi_realization));
      StringWriter fi_sw = new StringWriter();
      fi_realization.setResult(new StreamResult(fi_sw));

      // Execute Finnish pipeline
      fi_reader.parse(agraphFile);
      fi_responseString = fi_sw.toString();
      System.out.println();
      System.out.println(fi_responseString);
 
      // Prepare English pipeline
      XMLReader en_reader = XMLReaderFactory.createXMLReader();
      en_reader.setContentHandler(en_getcontent);
      en_reader.setProperty("http://xml.org/sax/properties/lexical-handler",
			    en_getcontent);
      en_getcontent.setResult(new SAXResult(en_responseplanner));
      en_responseplanner.setResult(new SAXResult(en_lexicalization));
      en_lexicalization.setResult(new SAXResult(en_referringexps));
      en_referringexps.setResult(new SAXResult(en_realization));
      StringWriter en_sw = new StringWriter();
      en_realization.setResult(new StreamResult(en_sw));

      // Execute English pipeline
      en_reader.parse(agraphFile);
      en_responseString = en_sw.toString();
      System.out.println();
      System.out.println(en_responseString);

      // speak the English string
      try {
	  synthesizer.resume();
	    
	  // kevin16 16khz unlimited-domain diphone voice
	  Voice kevin16 = new Voice("kevin16", 
		Voice.GENDER_DONT_CARE, Voice.AGE_DONT_CARE, null);
	  synthesizer.getSynthesizerProperties().setVoice(kevin16);
	  synthesizer.speak(en_responseString, null);
	  synthesizer.waitEngineState(Synthesizer.QUEUE_EMPTY);
      }
      catch (Exception e) {
	  e.printStackTrace();
	  System.exit(1);
      }
    }
    //    synthesizer.deallocate();
	};
	System.exit(0);
    }
}