package jalview.io;

import static org.junit.Assert.*;
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import org.junit.Test;

public class StockholmFileTest
{

  public static void main(String argv[])
  {
    try {
      new StockholmFileTest().pfamFileIO();
    
    } catch (Exception x)
    {
      x.printStackTrace();
    }
  }
  static String PfamFile = "examples/PF00111_seed.stk", RfamFile="examples/RF00031_folded.stk";

  @Test
  public void pfamFileIO() throws Exception
  {
      test(new File(PfamFile));
      AppletFormatAdapter af = new AppletFormatAdapter();
      AlignmentI al = af.readFile(PfamFile, af.FILE, new IdentifyFile().Identify(PfamFile, af.FILE));
      int numpdb=0;
      for (SequenceI sq:al.getSequences())
      {
        if (sq.getPDBId()!=null)
        {
          numpdb+=sq.getPDBId().size();
        }
      }
      assertTrue("PF00111 seed alignment has at least 1 PDB file, but the reader found none.",numpdb>0);
  }
  @Test
  public void rfamFileIO() throws Exception
  {
      test(new File(RfamFile));
  }

  private void test(File f)
  {
    System.out.println("Reading file: " + f);
    String ff = f.getPath();
    try
    {
      Alignment al = new AppletFormatAdapter().readFile(ff, AppletFormatAdapter.FILE,
              new IdentifyFile().Identify(ff, AppletFormatAdapter.FILE));
      
      for (int i = 0; i < al.getSequencesArray().length; ++i)
      {
        al.getSequenceAt(i).setDatasetSequence(al.getSequenceAt(i));
      }
      AlignFile stFile = new StockholmFile(al);
      stFile.setSeqs(al.getSequencesArray());

      String stockholmoutput = stFile.print();
      Alignment al_input = new AppletFormatAdapter().readFile(stockholmoutput,
              AppletFormatAdapter.PASTE, "STH");
      if (al != null && al_input != null)
      {
        System.out.println("Alignment contains: " + al.getHeight()
                + " and " + al_input.getHeight() + " sequences; "
                + al.getWidth() + " and " + al_input.getWidth()
                + " columns.");
        AlignmentAnnotation[] aa_new = al_input.getAlignmentAnnotation();
        AlignmentAnnotation[] aa_original = al.getAlignmentAnnotation();

        // check Alignment annotation
        if (aa_new != null && aa_original != null)
        {
          System.out.println("Alignment contains: " + aa_new.length
                  + "  and " + aa_original.length
                  + " alignment annotation(s)");
          for (int i = 0; i < aa_original.length; i++)
          {
            assertTrue("Different alignment annotation",equalss(aa_original[i], aa_new[i]));
              
          }
        }

        // check sequences, annotation and features
        SequenceI[] seq_original = new SequenceI[al.getSequencesArray().length];
        seq_original = al.getSequencesArray();
        SequenceI[] seq_new = new SequenceI[al_input.getSequencesArray().length];
        seq_new = al_input.getSequencesArray();
        SequenceFeature[] sequenceFeatures_original, sequenceFeatures_new;
        AlignmentAnnotation annot_original, annot_new;
        //
        for (int i = 0; i < al.getSequencesArray().length; i++)
        {
          String name = seq_original[i].getName();
          int start = seq_original[i].getStart();
          int end = seq_original[i].getEnd();
          System.out.println("Check sequence: " + name + "/" + start + "-"
                  + end);

          // search equal sequence
          for (int in = 0; in < al_input.getSequencesArray().length; in++)
          {
            if (name.equals(seq_new[in].getName())
                    && start == seq_new[in].getStart()
                    && end == seq_new[in].getEnd())
            {
              String ss_original = seq_original[i].getSequenceAsString();
              String ss_new = seq_new[in].getSequenceAsString();
              assertTrue("The sequences " + name + "/" + start
                      + "-" + end + " are not equal", ss_original.equals(ss_new));
              
              assertTrue("Sequence Features were not equivalent", (seq_original[i].getSequenceFeatures()==null && seq_new[in].getSequenceFeatures()==null) || (seq_original[i].getSequenceFeatures()!=null && seq_new[in].getSequenceFeatures()!=null));
              // compare sequence features
              if (seq_original[i].getSequenceFeatures() != null
                      && seq_new[in].getSequenceFeatures() != null)
              {
                System.out.println("There are feature!!!");
                sequenceFeatures_original = new SequenceFeature[seq_original[i]
                        .getSequenceFeatures().length];
                sequenceFeatures_original = seq_original[i]
                        .getSequenceFeatures();
                sequenceFeatures_new = new SequenceFeature[seq_new[in]
                        .getSequenceFeatures().length];
                sequenceFeatures_new = seq_new[in].getSequenceFeatures();

                assertTrue("different number of features", seq_original[i].getSequenceFeatures().length == seq_new[in]
                        .getSequenceFeatures().length);
                
                for (int feat = 0; feat < seq_original[i]
                        .getSequenceFeatures().length; feat++)
                {
                  assertTrue("Different features",sequenceFeatures_original[feat]
                          .equals(sequenceFeatures_new[feat]));
                }
              }

              // compare alignment annotation
              if (al.getSequenceAt(i).getAnnotation() != null
                      && al_input.getSequenceAt(in).getAnnotation() != null)
              {
                for (int j = 0; j < al.getSequenceAt(i).getAnnotation().length; j++)
                {
                  if (al.getSequenceAt(i).getAnnotation()[j] != null
                          && al_input.getSequenceAt(in).getAnnotation()[j] != null)
                  {
                    annot_original = al.getSequenceAt(i).getAnnotation()[j];
                    annot_new = al_input.getSequenceAt(in).getAnnotation()[j];
                    assertTrue("Different annotation", equalss(annot_original, annot_new));
                  }
                }
              }
              else if (al.getSequenceAt(i).getAnnotation() == null
                      && al_input.getSequenceAt(in).getAnnotation() == null)
              {
                System.out.println("No annotations");
              }
              else if (al.getSequenceAt(i).getAnnotation() != null
                      && al_input.getSequenceAt(in).getAnnotation() == null)
              {
                assertTrue("Annotations differed between sequences ("+al.getSequenceAt(i).getName()+") and ("+al_input.getSequenceAt(i).getName()+")", false);
              }
              break;
            }
          }
        }
      }
      else
      {
        assertTrue("Couldn't read alignment", false);
      }
    } catch (Exception e)
    {
      e.printStackTrace();
      assertTrue("Couln't format the alignment for output file.", false);
    }
  }

  /*
   * compare annotations
   */
  private boolean equalss(AlignmentAnnotation annot_or,
          AlignmentAnnotation annot_new)
  {
    if (annot_or.annotations.length != annot_new.annotations.length)
    {
      return false;
    }
    for (int i = 0; i < annot_or.annotations.length; i++)
    {
      if (annot_or.annotations[i] != null
              && annot_new.annotations[i] != null)
      {
        // Jim's comment - shouldn't the conditional here be using || not && for all these clauses ?
        if (!annot_or.annotations[i].displayCharacter
                .equals(annot_new.annotations[i].displayCharacter)
                && annot_or.annotations[i].secondaryStructure != annot_new.annotations[i].secondaryStructure
                && !annot_or.annotations[i].description
                        .equals(annot_new.annotations[i].description))
        {
          return false;
        }
      }
      else if (annot_or.annotations[i] == null
              && annot_new.annotations[i] == null)
      {
        continue;
      }
      else
      {
        return false;
      }
    }
    return true;
  }
}