package jalview.hmmer;

import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
import jalview.util.FileUtils;
import jalview.util.MessageManager;
import jalview.ws.params.ArgumentI;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Hashtable;
import java.util.List;
import java.util.Scanner;

public abstract class Search extends HmmerCommand
{

  static final String JACKHMMER = "jackhmmer";

  static final String HMMSEARCH = "hmmsearch";

  boolean realign = false;

  boolean trim = false;

  SequenceI[] seqs;

  String databaseName;

  boolean searchAlignment = true;

  Hashtable sequencesHash;

  public Search(AlignFrame alignFrame, List<ArgumentI> args)
  {
    super(alignFrame, args);
  }

  @Override
  public void run()
  {
  }

  /*
  void readOutputFile(File inputTableTemp) throws IOException
  {
    BufferedReader br = new BufferedReader(new FileReader(inputTableTemp));
  
  
    String line = "";
    while (!line.startsWith("//"))
    {
  
      while (!line.startsWith(">> ") && !line.startsWith("//"))
      {
        line = br.readLine();
      }
  
      if (line.startsWith("//"))
      {
        break;
      }
  
      Scanner scanner = new Scanner(line);
      String name = scanner.next();
      name = scanner.next();
  
      br.readLine();
      br.readLine();
  
      List<SequenceI> domains = new ArrayList<>();
  
      for (SequenceI seq : seqs)
      {
        if (seq.getName().contains(name))
        {
          domains.add(seq);
        }
      }
  
      if (domains.contains(getSequence()))
      {
        domains.remove(getSequence());
      }
  
      if (domains.size() > 0)
      {
        readOutputTable(br, domains);
      }
  
      line = br.readLine();
    }
  
  }
  
  
  /**
   * Reads in the scores table output by jackhmmer and adds annotation to
   * sequences for E-value and bit score
   * 
   * @param inputTableTemp
   * @throws IOException
   */
  /*
  void readOutputTable(BufferedReader br, List<SequenceI> seqs) throws IOException
  {
    String line = br.readLine();
  
    while (!"".equals(line) && line != null)
    {
      if ("  ------ inclusion threshold ------".equals(line))
      {
        line = br.readLine();
        continue;
      }
  
      Scanner scanner = new Scanner(line);
      scanner.next();
      scanner.next();
      String score = scanner.next();
  
      scanner.next();
  
      String evalue = scanner.next();
  
      scanner.next();
      scanner.next();
      scanner.next();
      scanner.next();
  
      int start = scanner.nextInt();
      int end = scanner.nextInt();
  
      SequenceI seq = null;
      for (SequenceI sequence : seqs)
      {
        if (sequence.getStart() >= start && sequence.getEnd() <= end)
        {
          seq = sequence;
          break;
        }
      }
  
      if (seq != null)
      {
        addScoreAnnotations(evalue, score, seq);
      }
  
      scanner.close();
      line = br.readLine();
    }
  }
  */

  void readDomainTable(File inputTableTemp, boolean includesQuery)
          throws IOException
  {
    BufferedReader br = new BufferedReader(new FileReader(inputTableTemp));

    String line = br.readLine();
    br.readLine();
    br.readLine();
    line = br.readLine();

    int index;

    if (includesQuery)
    {
      index = 1;
    }
    else
    {
      index = 0;
    }
    while (!line.startsWith("#"))
    {
      if (line.contains("inclusion threshold"))
      {
        line = br.readLine();
        continue;
      }

      Scanner scanner = new Scanner(line);
      String name = scanner.next();

      for (int i = 0; i < 10; i++)
      {
        scanner.next();
      }

      String evalue = scanner.next();
      scanner.next();
      String score = scanner.next();

      addScoreAnnotations(evalue, score, seqs[index]);
      index++;

      scanner.close();
      line = br.readLine();
    }
    br.close();
  }




  void addScoreAnnotations(String eValue, String bitScore, SequenceI seq)
  {
    String label = "Search Scores";
    String description = "Full sequence bit score and E-Value";

    try
    {
      AlignmentAnnotation annot = new AlignmentAnnotation(label,
              description, null);

      annot.label = label;
      annot.description = description;

      annot.setCalcId(JACKHMMER);

      double dEValue = Double.parseDouble(eValue);
      annot.setEValue(dEValue);

      double dBitScore = Double.parseDouble(bitScore);
      annot.setBitScore(dBitScore);

      annot.setSequenceRef(seq);
      seq.addAlignmentAnnotation(annot);

    } catch (NumberFormatException e)
    {
      System.err.println("Error parsing " + label + " from " + eValue
              + " & " + bitScore);
    }
  }

  void buildArguments(List<String> args, File searchOutputFile,
          File hitsAlignmentFile, File queryFile) throws IOException
  {
    args.add("--domtblout");
    args.add(getFilePath(searchOutputFile, true));
    args.add("-A");
    args.add(getFilePath(hitsAlignmentFile, true));

    File databaseFile = null;

    boolean useEvalueCutoff = false;
    boolean useScoreCutoff = false;
    String seqReportingEvalueCutoff = null;
    String domReportingEvalueCutoff = null;
    String seqReportingScoreCutoff = null;
    String domReportingScoreCutoff = null;
    String seqInclusionEvalueCutoff = null;
    String domInclusionEvalueCutoff = null;
    String seqInclusionScoreCutoff = null;
    String domInclusionScoreCutoff = null;
    databaseName = "Alignment";

    if (params != null)
    {
      for (ArgumentI arg : params)
      {
        String name = arg.getName();

        if (MessageManager.getString(REPORTING_CUTOFF_KEY).equals(name))
        {
          if (MessageManager.getString(CUTOFF_EVALUE)
                  .equals(arg.getValue()))
          {
            useEvalueCutoff = true;
          }
          else if (MessageManager.getString(CUTOFF_SCORE)
                  .equals(arg.getValue()))
          {
            useScoreCutoff = true;
          }
        }
        else if (MessageManager.getString(REPORTING_SEQ_EVALUE_KEY)
                .equals(name))
        {
          seqReportingEvalueCutoff = arg.getValue();
        }
        else if (MessageManager.getString(REPORTING_SEQ_SCORE_KEY)
                .equals(name))
        {
          seqReportingScoreCutoff = arg.getValue();
        }
        else if (MessageManager.getString(REPORTING_DOM_EVALUE_KEY)
                .equals(name))
        {
          domReportingEvalueCutoff = arg.getValue();
        }
        else if (MessageManager.getString(REPORTING_DOM_SCORE_KEY)
                .equals(name))
        {
          domReportingScoreCutoff = arg.getValue();
        }
        else if (MessageManager.getString(INCLUSION_SEQ_EVALUE_KEY)
                .equals(name))
        {
          seqInclusionEvalueCutoff = arg.getValue();
        }
        else if (MessageManager.getString(INCLUSION_SEQ_SCORE_KEY)
                .equals(name))
        {
          seqInclusionScoreCutoff = arg.getValue();
        }
        else if (MessageManager.getString(INCLUSION_DOM_EVALUE_KEY)
                .equals(name))
        {
          domInclusionEvalueCutoff = arg.getValue();
        }
        else if (MessageManager.getString(INCLUSION_DOM_SCORE_KEY)
                .equals(name))
        {
          domInclusionScoreCutoff = arg.getValue();
        }
        else if (MessageManager.getString(DATABASE_KEY).equals(name))
        {
          databaseFile = new File(arg.getValue());
          if (!arg.getValue().isEmpty())
          {
            searchAlignment = false;
          }
        }
        else if (MessageManager.getString(NUMBER_OF_ITERATIONS)
                .equals(name))
        {
          if (!arg.getValue().isEmpty())
          {
            args.add("-N");
            args.add(arg.getValue());
          }
        }
      }
    }

    if (useEvalueCutoff)
    {
      args.add("-E");
      args.add(seqReportingEvalueCutoff);
      args.add("--domE");
      args.add(domReportingEvalueCutoff);

      args.add("--incE");
      args.add(seqInclusionEvalueCutoff);
      args.add("--incdomE");
      args.add(domInclusionEvalueCutoff);
    }
    else if (useScoreCutoff)
    {
      args.add("-T");
      args.add(seqReportingScoreCutoff);
      args.add("--domT");
      args.add(domReportingScoreCutoff);

      args.add("--incT");
      args.add(seqInclusionEvalueCutoff);
      args.add("--incdomT");
      args.add(domInclusionEvalueCutoff);
    }

    // if (!dbFound || MessageManager.getString(THIS_ALIGNMENT_KEY)
    // .equals(dbPath))
    if (searchAlignment)
    {
      /*
       * no external database specified for search, so
       * export current alignment as 'database' to search
       */
      databaseFile = FileUtils.createTempFile("database", ".sto");
      AlignmentI al = af.getViewport().getAlignment();
      AlignmentI copy = new Alignment(al);

      deleteHmmSequences(copy);

      if (searchAlignment)
      {
        sequencesHash = stashSequences(copy.getSequencesArray());
      }

      exportStockholm(copy.getSequencesArray(), databaseFile, null);
    }

    args.add(getFilePath(queryFile, true));
    args.add(getFilePath(databaseFile, true));
  }
}