/*
 *                  BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 * 
 * Created on Nov 20, 2005
 *
 */
package org.biojava.dasobert.das;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.biojava.dasobert.dasregistry.Das1Source;
import org.biojava.dasobert.eventmodel.SequenceEvent;
import org.biojava.dasobert.eventmodel.SequenceListener;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.XMLReader;
import java.util.*;

/**
 * a thread that gets the sequence from a DAS server
 * 
 * @author Andreas Prlic
 * 
 */
public class SequenceThread extends Thread
{

  Das1Source[] sequenceServers;

  String sp_accession;

  List seqListeners;

  String version;

  static Logger logger = Logger.getLogger("org.biojava.spice");

  public SequenceThread(String sp_accession, Das1Source ds)
  {
    super();
    Das1Source[] dss = new Das1Source[1];
    dss[0] = ds;
    this.sp_accession = sp_accession;
    this.sequenceServers = dss;
    clearSequenceListeners();
    version = "";
  }

  public SequenceThread(String sp_accession, Das1Source[] ds)
  {
    super();

    this.sp_accession = sp_accession;
    this.sequenceServers = ds;
    clearSequenceListeners();
  }

  public void clearSequenceListeners()
  {
    seqListeners = new ArrayList();
  }

  public void addSequenceListener(SequenceListener lis)
  {
    seqListeners.add(lis);
  }

  public void run()
  {
    getSequence();
  }

  public void getSequence()
  {

    boolean gotSequence = false;

    for (int i = 0; i < sequenceServers.length; i++)
    {

      if (gotSequence)
        break;

      Das1Source ds = sequenceServers[i];
      String url = ds.getUrl();
      char lastChar = url.charAt(url.length() - 1);
      if (!(lastChar == '/'))
        url += "/";
      String dascmd = url + "sequence?segment=";
      String connstr = dascmd + sp_accession;

      try
      {
        version = "";

        String sequence = retrieveSequence(connstr);
        // bug in aristotle das source?
        sequence.replaceAll(" ", "");
        gotSequence = true;
        // set the sequence ...

        triggerNewSequence(sp_accession, sequence, ds, version);

        return;
      } catch (Exception ex)
      {
        ex.printStackTrace();
        logger.warning(ex.getMessage());

        // triggerException(ex);

      }
    }

    logger
            .log(
                    Level.WARNING,
                    "could not retreive UniProt sequence from any available DAS sequence server");

    triggerNoSequence(sp_accession);

  }

  // private void triggerException(Exception e){
  // Iterator iter = seqListeners.iterator();
  // while (iter.hasNext()){
  // SequenceListener li = (SequenceListener)iter.next();
  // li.exceptionOccured(e);
  // }
  // }

  private void triggerNewSequence(String sp_accession, String sequence,
          Das1Source source, String version)
  {

    Iterator iter = seqListeners.iterator();
    while (iter.hasNext())
    {
      SequenceListener li = (SequenceListener) iter.next();
      // SequenceEvent event = new SequenceEvent(sequence);
      SequenceEvent event = new SequenceEvent(sp_accession, sequence,
              version);
      event.setSource(source);
      li.newSequence(event);
    }
  }

  private void triggerNoSequence(String ac)
  {

    Iterator iter = seqListeners.iterator();
    while (iter.hasNext())
    {
      SequenceListener li = (SequenceListener) iter.next();
      li.noObjectFound(ac);
    }

  }

  /**
   * retrieve the Sequence from a DAS server.
   * 
   * @param connstr -
   *                the DAS - request string. e.g.
   *                http://www.ebi.ac.uk/das-srv/uniprot/das/aristotle/sequence?segment=P00280
   * @return the requested Sequence
   * @throws Exception
   */
  public String retrieveSequence(String connstr) throws Exception
  {

    // logger.finest("trying: " + connstr) ;
    URL dasUrl = new URL(connstr);
    // DAS_httpConnector dhtp = new DAS_httpConnector() ;
    logger.info("requesting sequence from " + connstr);
    InputStream dasInStream = open(dasUrl);

    SAXParserFactory spfactory = SAXParserFactory.newInstance();

    // never do this
    // String vali = System.getProperty("XMLVALIDATION");
    String vali = "false";
    boolean validate = false;
    if ((vali != null) && (vali.equals("true")))
      validate = true;
    spfactory.setValidating(validate);

    SAXParser saxParser = null;

    try
    {
      saxParser = spfactory.newSAXParser();
    } catch (ParserConfigurationException e)
    {
      // e.printStackTrace();
      logger.log(Level.FINER, "Uncaught exception", e);
    }

    XMLReader xmlreader = saxParser.getXMLReader();

    try
    {
      xmlreader.setFeature("http://xml.org/sax/features/validation",
              validate);
    } catch (SAXException e)
    {
      logger.finer("Cannot set validation to " + validate);
      logger.log(Level.FINER, "Uncaught exception", e);
    }

    try
    {
      xmlreader
              .setFeature(
                      "http://apache.org/xml/features/nonvalidating/load-external-dtd",
                      validate);
    } catch (SAXNotRecognizedException e)
    {
      // e.printStackTrace();
      logger.finer("Cannot set load-external-dtd to" + validate);
      logger.log(Level.FINER, "Uncaught exception", e);
      // System.err.println("Cannot set load-external-dtd to" + validate);
    }

    // DAS_DNA_Handler cont_handle = new DAS_DNA_Handler() ;
    DAS_Sequence_Handler cont_handle = new DAS_Sequence_Handler();
    xmlreader.setContentHandler(cont_handle);
    xmlreader.setErrorHandler(new org.xml.sax.helpers.DefaultHandler());
    InputSource insource = new InputSource();
    insource.setByteStream(dasInStream);

    xmlreader.parse(insource);
    String sequence = cont_handle.get_sequence();
    version = cont_handle.getVersion();
    // logger.finest("Got sequence from DAS: " +sequence);

    logger.exiting(this.getClass().getName(), "retreiveSequence", sequence);
    return sequence;
  }

  private InputStream open(URL url)
  {
    {

      InputStream inStream = null;
      try
      {

        HttpURLConnection huc = null;

        huc = DAS_FeatureRetrieve.openHttpURLConnection(url);

        logger.finest(huc.getResponseMessage());

        inStream = huc.getInputStream();

      } catch (Exception ex)
      {
        ex.printStackTrace();
        logger.log(Level.WARNING, "exception occured", ex);
      }

      return inStream;
    }

  }

}