package fr.orsay.lri.varna.factories;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EmptyStackException;
import java.util.Hashtable;
import java.util.List;
import java.util.Stack;
import java.util.Vector;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;

import fr.orsay.lri.varna.exceptions.ExceptionExportFailed;
import fr.orsay.lri.varna.exceptions.ExceptionFileFormatOrSyntax;
import fr.orsay.lri.varna.exceptions.ExceptionLoadingFailed;
import fr.orsay.lri.varna.exceptions.ExceptionPermissionDenied;
import fr.orsay.lri.varna.exceptions.ExceptionUnmatchedClosingParentheses;
import fr.orsay.lri.varna.models.rna.ModeleBP;
import fr.orsay.lri.varna.models.rna.ModeleBackboneElement;
import fr.orsay.lri.varna.models.rna.ModeleBackboneElement.BackboneType;
import fr.orsay.lri.varna.models.rna.ModeleBase;
import fr.orsay.lri.varna.models.rna.RNA;
import fr.orsay.lri.varna.utils.RNAMLParser;

/**
 * BH JAVA FIX: mostly here we are just removing a lot of unnecessary stack traces when doing a drag-drop of a file
 * BH JAVA FIX: making sure the file reader is closed properly
 *  
 */
public class RNAFactory
{

  public enum RNAFileType
  {
    FILE_TYPE_STOCKHOLM, FILE_TYPE_TCOFFEE, FILE_TYPE_BPSEQ, FILE_TYPE_CT, FILE_TYPE_DBN, FILE_TYPE_RNAML, FILE_TYPE_UNKNOWN
  }

private static boolean isQuiet;

  public static ArrayList<RNA> loadSecStrRNAML(Reader r)
      throws ExceptionPermissionDenied, ExceptionLoadingFailed,
      ExceptionFileFormatOrSyntax
  {

    ArrayList<RNA> result = new ArrayList<RNA>();
    try
    {
      // System.setProperty("javax.xml.parsers.SAXParserFactory",
      // "com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl");
      SAXParserFactory saxFact = javax.xml.parsers.SAXParserFactory
          .newInstance();
      saxFact.setValidating(false);
      saxFact.setXIncludeAware(false);
      saxFact.setNamespaceAware(false);
      SAXParser sp = saxFact.newSAXParser();
      RNAMLParser RNAMLData = new RNAMLParser();
      sp.parse(new InputSource(r), RNAMLData);

      /*
       * XMLReader xr = XMLReaderFactory.createXMLReader(); RNAMLParser
       * RNAMLData = new RNAMLParser(); xr.setContentHandler(RNAMLData);
       * xr.setErrorHandler(RNAMLData); xr.setEntityResolver(RNAMLData);
       * xr.parse(new InputSource(r));
       */
      for (RNAMLParser.RNATmp rnaTmp : RNAMLData.getMolecules())
      {
        RNA current = new RNA();
        // Retrieving parsed data
        List<String> seq = rnaTmp.getSequence();
        // Creating empty structure of suitable size
        int[] str = new int[seq.size()];
        for (int i = 0; i < str.length; i++)
        {
          str[i] = -1;
        }
        current.setRNA(seq, str);
        Vector<RNAMLParser.BPTemp> allbpsTmp = rnaTmp.getStructure();
        ArrayList<ModeleBP> allbps = new ArrayList<ModeleBP>();
        for (int i = 0; i < allbpsTmp.size(); i++)
        {
          RNAMLParser.BPTemp bp = allbpsTmp.get(i);
          // System.err.println(bp);
          int bp5 = bp.pos5;
          int bp3 = bp.pos3;
          ModeleBase mb = current.getBaseAt(bp5);
          ModeleBase part = current.getBaseAt(bp3);
          ModeleBP newStyle = bp.createBPStyle(mb, part);
          allbps.add(newStyle);
        }

        current.applyBPs(allbps);
        result.add(current);
      }

    }
    catch (IOException ioe)
    {
      throw new ExceptionLoadingFailed(
          "Couldn't load file due to I/O or security policy issues.", "");
    }
    catch (Exception ge)
    {
    	if (!isQuiet) // BH
      ge.printStackTrace();
    }
    return result;
  }

  public static int[] parseSecStr(String _secStr)
      throws ExceptionUnmatchedClosingParentheses
  {
    Hashtable<Character, Stack<Integer>> stacks = new Hashtable<Character, Stack<Integer>>();
    int[] result = new int[_secStr.length()];
    int i = 0;
    try
    {
      for (i = 0; i < _secStr.length(); i++)
      {
        result[i] = -1;
        char c = _secStr.charAt(i);
        char c2 = Character.toUpperCase(c);
        if (!stacks.containsKey(c2))
        {
          stacks.put(c2, new Stack<Integer>());
        }
        switch (c)
        {
        case '<':
        case '{':
        case '(':
        case '[':
          stacks.get(c).push(i);
          break;
        case '>':
        {
          int j = stacks.get('<').pop();
          result[i] = j;
          result[j] = i;
          break;
        }
        case '}':
        {
          int j = stacks.get('{').pop();
          result[i] = j;
          result[j] = i;
          break;
        }
        case ')':
        {
          int j = stacks.get('(').pop();
          result[i] = j;
          result[j] = i;
          break;
        }
        case ']':
        {
          int j = stacks.get('[').pop();
          result[i] = j;
          result[j] = i;
          break;
        }
        case '.':
          break;
        default:
        {
          if (Character.isLetter(c) && Character.isUpperCase(c))
          {
            stacks.get(c).push(i);
          }
          else if (Character.isLetter(c) && Character.isLowerCase(c))
          {
            int j = stacks.get(Character.toUpperCase(c)).pop();
            result[i] = j;
            result[j] = i;
          }
        }
        }
      }
    }
    catch (EmptyStackException e)
    {
      throw new ExceptionUnmatchedClosingParentheses(i);
    }
    return result;
  }

  public static ArrayList<RNA> loadSecStrDBN(Reader r)
      throws ExceptionLoadingFailed, ExceptionPermissionDenied,
      ExceptionUnmatchedClosingParentheses, ExceptionFileFormatOrSyntax
  {
    boolean loadOk = false;
    ArrayList<RNA> result = new ArrayList<RNA>();
    RNA current = new RNA();
    try
    {
      BufferedReader fr = new BufferedReader(r);
      String line = fr.readLine();
      String title = "";
      String seqTmp = "";
      String strTmp = "";
      while ((line != null) && (strTmp.equals("")))
      {
        line = line.trim();
        if (!line.startsWith(">"))
        {
          if (seqTmp.equals(""))
          {
            seqTmp = line;
          }
          else
          {
            strTmp = line;
          }
        }
        else
        {
          title = line.substring(1).trim();
        }
        line = fr.readLine();
      }
      if (strTmp.length() != 0)
      {
        current.setRNA(seqTmp, strTmp);
        current.setName(title);
        loadOk = true;
      }
    }
    catch (IOException e)
    {
      throw new ExceptionLoadingFailed(e.getMessage(), "");
    }
    if (loadOk)
    {
      result.add(current);
    }
    return result;
  }

  public static ArrayList<RNA> loadSecStr(File f)
	      throws ExceptionFileFormatOrSyntax
	  {
	    try {
			return loadSecStr(new BufferedReader(new FileReader(f)), RNAFileType.FILE_TYPE_UNKNOWN);
		} catch (FileNotFoundException e) {
			throw new ExceptionFileFormatOrSyntax(f.toString());
		}
	  }

  public static ArrayList<RNA> loadSecStr(Reader r)
      throws ExceptionFileFormatOrSyntax
  {
    return loadSecStr(new BufferedReader(r), RNAFileType.FILE_TYPE_UNKNOWN);
  }

	public static ArrayList<RNA> loadSecStr(BufferedReader r, RNAFileType fileType) throws ExceptionFileFormatOrSyntax {
		try {
			switch (fileType) {
			case FILE_TYPE_DBN: {
				try {
					ArrayList<RNA> result = loadSecStrDBN(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
				}
			}
				break;
			case FILE_TYPE_CT: {
				try {
					ArrayList<RNA> result = loadSecStrCT(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
					if (!isQuiet) // BH
						e.printStackTrace();
				}
			}
				break;
			case FILE_TYPE_BPSEQ: {
				try {
					ArrayList<RNA> result = loadSecStrBPSEQ(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
					if (!isQuiet) // BH
						e.printStackTrace();
				}
			}
				break;
			case FILE_TYPE_TCOFFEE: {
				try {
					ArrayList<RNA> result = loadSecStrTCoffee(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
					if (!isQuiet) // BH
						e.printStackTrace();
				}
			}
				break;
			case FILE_TYPE_STOCKHOLM: {
				try {
					ArrayList<RNA> result = loadSecStrStockholm(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
					if (!isQuiet) // BH
						e.printStackTrace();
				}
			}
				break;
			case FILE_TYPE_RNAML: {
				try {
					ArrayList<RNA> result = loadSecStrRNAML(r);
					if (result.size() != 0)
						return result;
				} catch (Exception e) {
					if (!isQuiet) // BH
						e.printStackTrace();
				}
			}
				break;

			case FILE_TYPE_UNKNOWN: {
				try {
					r.mark(1000000);
					RNAFactory.RNAFileType[] types = RNAFactory.RNAFileType.values();
					isQuiet = true; // BH to not report errors when
									// drag-dropping
					ArrayList<RNA> result = null;
					RNAFactory.RNAFileType t = null;
					for (int i = 0; i < types.length; i++) {
						r.reset();
						t = types[i];
						if (t != RNAFactory.RNAFileType.FILE_TYPE_UNKNOWN) {
							try {
								result = loadSecStr(r, t);
								if (result.size() != 0) {
									break;
								}
							} catch (Exception e) {
								if (!isQuiet) // BH
									System.err.println(e.toString());
							}
						}
					}
					System.out.println(t); // BH
					isQuiet = false; // BH
					return result;
				} catch (IOException e2) {
					e2.printStackTrace();
				}
			}
			}
			throw new ExceptionFileFormatOrSyntax("Couldn't parse this file as " + fileType + ".");
		} finally { // BH !!
			try {
				if (!isQuiet)
					r.close();
			} catch (IOException e) {
				// ignore
			}
		}
	}

  public static RNAFileType guessFileTypeFromExtension(String path)
  {
    if (path.toLowerCase().endsWith("ml"))
    {
      return RNAFileType.FILE_TYPE_RNAML;
    }
    else if (path.toLowerCase().endsWith("dbn")
        || path.toLowerCase().endsWith("faa"))
    {
      return RNAFileType.FILE_TYPE_DBN;
    }
    else if (path.toLowerCase().endsWith("ct"))
    {
      return RNAFileType.FILE_TYPE_CT;
    }
    else if (path.toLowerCase().endsWith("bpseq"))
    {
      return RNAFileType.FILE_TYPE_BPSEQ;
    }
    else if (path.toLowerCase().endsWith("rfold"))
    {
      return RNAFileType.FILE_TYPE_TCOFFEE;
    }
    else if (path.toLowerCase().endsWith("stockholm")
        || path.toLowerCase().endsWith("stk"))
    {
      return RNAFileType.FILE_TYPE_STOCKHOLM;
    }

    return RNAFileType.FILE_TYPE_UNKNOWN;

  }

  public static ArrayList<RNA> loadSecStr(String path)
      throws ExceptionExportFailed, ExceptionPermissionDenied,
      ExceptionLoadingFailed, ExceptionFileFormatOrSyntax,
      ExceptionUnmatchedClosingParentheses, FileNotFoundException
  {
    FileReader fr = null;
    try
    {
      fr = new FileReader(path);
      RNAFileType type = guessFileTypeFromExtension(path);
      return loadSecStr(new BufferedReader(fr), type);
    }
    catch (ExceptionFileFormatOrSyntax e)
    {
      if (fr != null)
        try
        {
          fr.close();
        }
        catch (IOException e2)
        {
        }
      e.setPath(path);
      throw e;
    }
  }

  public static ArrayList<RNA> loadSecStrStockholm(BufferedReader r)
      throws IOException, ExceptionUnmatchedClosingParentheses
  {
    RNAAlignment a = StockholmIO.readAlignement(r);
    return a.getRNAs();
  }

  public static ArrayList<RNA> loadSecStrBPSEQ(Reader r)
      throws ExceptionPermissionDenied, ExceptionLoadingFailed,
      ExceptionFileFormatOrSyntax
  {
    boolean loadOk = false;
    ArrayList<RNA> result = new ArrayList<RNA>();
    RNA current = new RNA();
    try
    {
      BufferedReader fr = new BufferedReader(r);
      String line = fr.readLine();
      ArrayList<String> seqTmp = new ArrayList<String>();
      Hashtable<Integer, Vector<Integer>> strTmp = new Hashtable<Integer, Vector<Integer>>();

      int bpFrom;
      String base;
      int bpTo;
      int minIndex = -1;
      boolean noWarningYet = true;
      String title = "";
      String id = "";
      String filenameStr = "Filename:";
      String organismStr = "Organism:";
      String ANStr = "Accession Number:";
      while (line != null)
      {
        line = line.trim();
        String[] tokens = line.split("\\s+");
        ArrayList<Integer> numbers  = new ArrayList<Integer>(); 
        Hashtable<Integer,Integer> numberToIndex  = new Hashtable<Integer,Integer>(); 
        if ((tokens.length >= 3) && !tokens[0].contains("#")
            && !line.startsWith("Organism:") && !line.startsWith("Citation")
            && !line.startsWith("Filename:")
            && !line.startsWith("Accession Number:"))
        {
          base = tokens[1];
          seqTmp.add(base);
          bpFrom = (Integer.parseInt(tokens[0]));
          numbers.add(bpFrom);
          if (minIndex < 0)
            minIndex = bpFrom;

          if (seqTmp.size() < (bpFrom - minIndex + 1))
          {
            if (noWarningYet)
            {
              noWarningYet = false;
              /*
               * warningEmition( "Discontinuity detected between nucleotides " +
               * (seqTmp.size()) + " and " + (bpFrom + 1) +
               * "!\nFilling in missing portions with unpaired unknown 'X' nucleotides ..."
               * );
               */
            }
            while (seqTmp.size() < (bpFrom - minIndex + 1))
            {
              // System.err.println(".");
              seqTmp.add("X");
            }
          }
          for (int i = 2; i < tokens.length; i++)
          {
            bpTo = (Integer.parseInt(tokens[i]));
            if ((bpTo != 0) || (i != tokens.length - 1))
            {
              if (!strTmp.containsKey(bpFrom))
                strTmp.put(bpFrom, new Vector<Integer>());
              strTmp.get(bpFrom).add(bpTo);
            }
          }
        }
        else if (tokens[0].startsWith("#"))
        {
          int occur = line.indexOf("#");
          String tmp = line.substring(occur + 1);
          title += tmp.trim() + " ";
        }
        else if (tokens[0].startsWith(filenameStr))
        {
          int occur = line.indexOf(filenameStr);
          String tmp = line.substring(occur + filenameStr.length());
          title += tmp.trim();
        }
        else if (tokens[0].startsWith(organismStr))
        {
          int occur = line.indexOf(organismStr);
          String tmp = line.substring(occur + organismStr.length());
          if (title.length() != 0)
          {
            title = "/" + title;
          }
          title = tmp.trim() + title;
        }
        else if (line.contains(ANStr))
        {
          int occur = line.indexOf(ANStr);
          String tmp = line.substring(occur + ANStr.length());
          id = tmp.trim();
        }
        line = fr.readLine();
      }
      if (strTmp.size() != 0)
      {
        ArrayList<String> seq = seqTmp;
        int[] str = new int[seq.size()];
        for (int i = 0; i < seq.size(); i++)
        {
          str[i] = -1;
        }
        current.setRNA(seq, str, minIndex);
        ArrayList<ModeleBP> allbps = new ArrayList<ModeleBP>();
        for (int i : strTmp.keySet())
        {
          for (int j : strTmp.get(i))
          {
        	  if (i<=j)
        	  {
	            ModeleBase mb = current.getBaseAt(i - minIndex);
	            ModeleBase part = current.getBaseAt(j - minIndex);
	            ModeleBP newStyle = new ModeleBP(mb, part);
	            allbps.add(newStyle);
        	  }
          }
        }
        current.applyBPs(allbps);
        current.setName(title);
        current.setID(id);
        loadOk = true;
      }
    }
    catch (NumberFormatException e)
    {
    	if (!isQuiet) // BH SwingJS
      e.printStackTrace();
    }
    catch (IOException e)
    {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    catch (Exception e)
    {
      throw new ExceptionLoadingFailed(e.getMessage(), "");
    }
    if (loadOk)
      result.add(current);
    return result;
  }

  public static ArrayList<RNA> loadSecStrTCoffee(Reader r)
      throws ExceptionPermissionDenied, ExceptionLoadingFailed,
      ExceptionFileFormatOrSyntax
  {
    boolean loadOk = false;
    ArrayList<RNA> result = new ArrayList<RNA>();
    try
    {
      BufferedReader fr = new BufferedReader(r);
      String line = fr.readLine();
      ArrayList<String> seqs = new ArrayList<String>();
      ArrayList<String> ids = new ArrayList<String>();
      int numSeqs = -1;
      int currSeq = -1;
      RNA current = null;
      while (line != null)
      {
        if (!line.startsWith("!"))
        {
          String[] tokens = line.split("\\s+");
          // This may indicate new secondary structure
          if (line.startsWith("#"))
          {
            currSeq = Integer.parseInt(tokens[0].substring(1));
            int currSeq2 = Integer.parseInt(tokens[1]);
            // For TCoffee, a sec str is a matching between a seq and itself
            // => Disregard any alignment by filtering on the equality of sequence indices.
            if (currSeq == currSeq2)
            {
              current = new RNA();
              current.setName(ids.get(currSeq - 1));
              current.setSequence(seqs.get(currSeq - 1));
              result.add(current);
            }
            else
            {
              current = null;
            }
          }
          // Beginning of the file... 
          else if (current == null)
          {
            //... either this is the number of sequences...
            if (numSeqs < 0)
            {
              numSeqs = Integer.parseInt(tokens[0]);
            }
            //... or this is a sequence definition...
            else
            {
              String id = tokens[0];
              String seq = tokens[2];
              seqs.add(seq);
              ids.add(id);
            }
          }
          //Otherwise, this is a base-pair definition, related to the currently selected sequence
          else if (tokens.length == 3)
          {
            int from = Integer.parseInt(tokens[0]) - 1;
            int to = Integer.parseInt(tokens[1]) - 1;
            current.addBP(from, to);
          }
        }
        line = fr.readLine();
      }
      loadOk = true;
    }
    catch (NumberFormatException e)
    {
    	if (!isQuiet) // BH SwingJS
      e.printStackTrace();
    }
    catch (IOException e)
    {
    	if (!isQuiet) // BH SwingJS
    		e.printStackTrace();
    }
    if (!loadOk)
    {
      throw new ExceptionLoadingFailed("Parse Error", "");
    }
    return result;
  }

  public static ArrayList<RNA> loadSecStrCT(Reader r)
      throws ExceptionPermissionDenied, ExceptionLoadingFailed,
      ExceptionFileFormatOrSyntax
  {
    boolean loadOk = false;
    ArrayList<RNA> result = new ArrayList<RNA>();
    RNA current = new RNA();
    try
    {
      BufferedReader fr = new BufferedReader(r);
      String line = fr.readLine();
      ArrayList<String> seq = new ArrayList<String>();
      ArrayList<String> lbls = new ArrayList<String>();
      Vector<Integer> strTmp = new Vector<Integer>();
      Vector<Integer> newStrands = new Vector<Integer>();
      int bpFrom;
      String base;
      String lbl;
      int bpTo;
      boolean noWarningYet = true;
      int minIndex = -1;
      String title = "";
      while (line != null)
      {
        line = line.trim();
        String[] tokens = line.split("\\s+");
        if (tokens.length >= 6)
        {
          try
          {
            bpFrom = (Integer.parseInt(tokens[0]));
            bpTo = (Integer.parseInt(tokens[4]));
            if (minIndex == -1)
              minIndex = bpFrom;
            bpFrom -= minIndex;
            if (bpTo != 0)
              bpTo -= minIndex;
            else
              bpTo = -1;
            base = tokens[1];
            lbl = tokens[5];
            int before = Integer.parseInt(tokens[2]);
            int after = Integer.parseInt(tokens[3]);
            
            if (before==0 && !seq.isEmpty())
            {
            	newStrands.add(strTmp.size()-1);
            }
            if (bpFrom != seq.size())
            {
              if (noWarningYet)
              {
                noWarningYet = false;
                /*
                 * warningEmition( "Discontinuity detected between nucleotides "
                 * + (seq.size()) + " and " + (bpFrom + 1) +
                 * "!\nFilling in missing portions with unpaired unknown 'X' nucleotides ..."
                 * );
                 */
              }
              while (bpFrom > seq.size())
              {
                seq.add("X");
                strTmp.add(-1);
                lbls.add("");
              }
            }
            seq.add(base);
            strTmp.add(bpTo);
            lbls.add(lbl);
          }
          catch (NumberFormatException e)
          {
        	  if (strTmp.size()!=0)
        		  e.printStackTrace();
          }
        }
        if ((line.contains("ENERGY = ")) || line.contains("dG = "))
        {
          String[] ntokens = line.split("\\s+");
          if (ntokens.length >= 4)
          {
            String energy = ntokens[3];
            for (int i = 4; i < ntokens.length; i++)
            {
              title += ntokens[i] + " ";
            }
            title += "(E=" + energy + " kcal/mol)";
          }
        }
        line = fr.readLine();
      }
      if (strTmp.size() != 0)
      {
        int[] str = new int[strTmp.size()];
        for (int i = 0; i < strTmp.size(); i++)
        {
          str[i] = strTmp.elementAt(i).intValue();
        }
        current.setRNA(seq, str, minIndex);
        current.setName(title);
        for (int i = 0; i < current.getSize(); i++)
        {
          current.getBaseAt(i).setLabel(lbls.get(i));
        }
        for (int i : newStrands)
        {
        	current.getBackbone().addElement(new ModeleBackboneElement(i,BackboneType.DISCONTINUOUS_TYPE));
        }

        
        loadOk = true;
      }
    }
    catch (IOException e)
    {
    	e.printStackTrace();
      throw new ExceptionLoadingFailed(e.getMessage(), "");
    }
    catch (NumberFormatException e)
    {
    	if (!isQuiet) // BH SwingJS
    	e.printStackTrace();
      throw new ExceptionFileFormatOrSyntax(e.getMessage(), "");
    }
    if (loadOk)
      result.add(current);
    return result;
  }

}