package jalview.analysis;

import static org.testng.Assert.assertNotNull;
import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;

import jalview.analysis.scoremodels.FeatureDistanceModel;
import jalview.analysis.scoremodels.PIDModel;
import jalview.analysis.scoremodels.ScoreModels;
import jalview.analysis.scoremodels.SimilarityParams;
import jalview.api.analysis.ScoreModelI;
import jalview.api.analysis.SimilarityParamsI;
import jalview.api.analysis.ViewBasedAnalysisI;
import jalview.datamodel.AlignmentView;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
import jalview.io.DataSourceType;
import jalview.io.FileLoader;
import jalview.math.MatrixI;

import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class PCATest
{

  private static final String TESTSEQS = ">s1\nAFRK\n>s2\nAFSS\n>s3\nAFTL\n>s4\nARSL\n";
  private AlignFrame af;

  @Test(groups = "Functional")
  public void testComputeSimilarity_blosum62()
  {
    setUp();
    SimilarityParamsI params = new SimilarityParams(true, false, true,
            false);
    AlignmentView view = af.getViewport().getAlignmentView(false);
    ScoreModelI blosum62 = ScoreModels.getInstance().getBlosum62();
    PCA pca = new PCA(view, blosum62, params);

    MatrixI result = pca.computeSimilarity();
    assertNotNull(result);

    /*
     * AFRK^AFRK = 4+6+5+5 = 20
     * AFRK^AFSS = 4+6+-1+0 = 9
     * AFRK^AFTL = 4+6+-1+-2 = 7
     * AFRK^ARSL = 4+-3+-1+-2 = -2
     */
    assertArrayEquals(result.getRow(0), new double[] { 20, 9, 7, -2 },
            0.00001d);
  }

  @BeforeTest(alwaysRun = true)
  public void setUp()
  {
    af = new FileLoader().LoadFileWaitTillLoaded(TESTSEQS,
            DataSourceType.PASTE);
  }

  @Test(groups = "Functional")
  public void testComputeSimilarity_PID()
  {
    setUp();
    SimilarityParamsI params = new SimilarityParams(true, false, true,
            false);
    AlignmentView view = af.getViewport().getAlignmentView(false);
    ScoreModelI pid = new PIDModel();
    PCA pca = new PCA(view, pid, params);
  
    MatrixI result = pca.computeSimilarity();
    assertNotNull(result);
  
    /*
     * AFRK^AFRK = 4 scaled to width
     * AFRK^AFSS = 2
     * AFRK^AFTL = 2
     * AFRK^ARSL = 1
     */
    assertArrayEquals(new double[] { 4d, 2d, 2d, 1d },
            result.getRow(0), 0.00001d);
  }

  @Test(groups = "Functional")
  public void testComputeSimilarity_featureDistances()
  {
    setUp();
    SimilarityParamsI params = new SimilarityParams(true, false, true,
            false);
    AlignmentView view = af.getViewport().getAlignmentView(false);
    ScoreModelI featureModel = new FeatureDistanceModel();
    PCA pca = new PCA(view, featureModel, params);
  
    MatrixI result = pca.computeSimilarity();
  
    /*
     * no features = no scores!
     */
    assertArrayEquals(new double[] { 0d, 0d, 0d, 0d },
            result.getRow(0), 0.00001d);

    SequenceI[] seqs = af.getViewport().getAlignment().getSequencesArray();
    seqs[0].addSequenceFeature(new SequenceFeature("Cath", "", 1, 4, 0f,
            null));
    seqs[1].addSequenceFeature(new SequenceFeature("Cath", "", 1, 4, 0f,
            null));
    seqs[2].addSequenceFeature(new SequenceFeature("Pfam", "", 1, 4, 0f,
            null));
    seqs[3].addSequenceFeature(new SequenceFeature("Pfam", "", 2, 3, 0f,
            null));

    af.getFeatureRenderer().findAllFeatures(true);
    ((ViewBasedAnalysisI) featureModel)
            .configureFromAlignmentView(af.alignPanel);

    /*
     * feature distance scores are (average number of features not shared):
     * diagonal: 0
     * seq1^seq2 0
     * seq1^seq3 8 / 4 = 2
     * seq1^seq4 6 / 4 = 1.5
     * seq2^seq3 8 / 4 = 2
     * seq2^seq4 6 / 3 = 1.5
     * seq3^seq4 2 / 4 = 0.5
     * so
     * { 0, 0, 2, 1.5
     *   0, 0, 2, 1.5
     *   2, 2, 0, 0.5
     *   1.5, 1.5, 0.5, 0 
     *  }
     * subtract each value from the max value to get similarity scores
     */
    result = pca.computeSimilarity();
    // assertArrayEquals(new double[] { 2d, 2d, 0d, 0.5d }, result.getRow(0),
    // 0.00001d);
    // assertArrayEquals(new double[] { 2d, 2d, 0d, 0.5d }, result.getRow(1),
    // 0.00001d);
    // assertArrayEquals(new double[] { 0d, 0d, 2d, 1.5d }, result.getRow(2),
    // 0.00001d);
    // assertArrayEquals(new double[] { 0.5d, 0.5d, 1.5d, 2d },
    // result.getRow(3), 0.00001d);

    /*
     * JAL-2424 bug means instead we get distance scores of
     *  8 / 5 = 1.6
     *  6 / 5 = 1.2
     *  2 / 5 = 0.4
     * so (until bug is fixed)
     * { 0, 0, 1.6, 1.2
     *   0, 0, 1.6, 1.2
     *   1.6, 1.6, 0, 0.4
     *   1.2, 1.2, 0.4, 0 
     *  }
     */
    assertArrayEquals(new double[] { 1.6d, 1.6d, 0d, 0.4d },
            result.getRow(0),
            0.00001d);
    assertArrayEquals(new double[] { 1.6d, 1.6d, 0d, 0.4d },
            result.getRow(1),
            0.00001d);
    assertArrayEquals(new double[] { 0d, 0d, 1.6d, 1.2d },
            result.getRow(2),
            0.00001d);
    assertArrayEquals(new double[] { 0.4d, 0.4d, 1.2d, 1.6d },
            result.getRow(3), 0.00001d);
  }
}