package jalview.analysis;

import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceI;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.testng.Assert;
import org.testng.annotations.Test;

public class SequenceIdMatcherTest
{
  private static SequenceI[] someseqs = {
      new Sequence("A|ComplexId", "dummy"),
      new Sequence("A|ComplexId|confused", "dummy"),
      new Sequence("A|ComplexId|bits_of", "dummy"),
      new Sequence("ComplexId", "dummy"),
      new Sequence("A|ComplexIdNot", "dummy"),
      new Sequence("A ComplexId Id", "dummy"),
      new Sequence("complexid", "dummy") };

  private static SequenceIdMatcher getMatcher()
  {
    return new SequenceIdMatcher(Arrays.asList(someseqs));
  }

  private static SequenceIdMatcher getWordMatcher()
  {
    return new SequenceIdMatcher(true, Arrays.asList(someseqs));
  }

  @Test(groups = { "Functional" })
  public void findSelfAndOthers()
  {
    for (SequenceI sq : SequenceIdMatcherTest.someseqs)
    {
      System.out.println("Searching with '" + sq.getName() + "'");
      SequenceI[] idmatches = getMatcher().findAllIdMatches(sq.getName());
      Assert.assertTrue(
              idmatches.length >= 1,
              "Couldn't recover at least one sequence for string '"
                      + sq.getName() + "'");
      for (SequenceI f : idmatches)
      {
        System.out.println("For '" + sq.getName() + "' found '"
                + f.getName() + "'");
      }

      SequenceI[] seqmatches = getMatcher().findIdMatch(
              new SequenceI[] { sq });
      Assert.assertEquals(1, seqmatches.length,
              "Expected to recover one sequence for sequence object called '"
                      + sq.getName() + "'");
      Assert.assertEquals(sq, seqmatches[0],
              "Expected to recover the sequence queried with findIdMatch(SequenceI[])");
      // TODO: complexid and ComplexId are identical with case-insensitive
      // matching. This assert fails because of this.
      // Assert.assertTrue(seqmatches.length == idmatches.length,
      // "Different matches found for '" + sq.getName() + "'");
      for (SequenceI sid : seqmatches)
      {
        boolean found = false;
        for (SequenceI sobj : idmatches)
        {
          if (sid == sobj)
          {
            found = true;
          }
        }
        Assert.assertTrue(
                found,
                "Different sequences recovered for Id "
                        + "and SequenceI (Couldn't find match for '"
                        + sid.getName() + "')");

      }
    }
  }

  @Test(groups = { "Functional" })
  public void testExactMatch()
  {
    SequenceI[] matches = getMatcher().findAllIdMatches("A|ComplexId");
    Assert.assertTrue(matches.length == 1,
            "Exact match failed for 'A|ComplexId'");
    matches = getMatcher().findAllIdMatches("A|ComplexId|confused");
    Assert.assertTrue(matches.length == 1,
            "Exact match failed for 'A|ComplexId|confused'");
    matches = getMatcher().findAllIdMatches("A|ComplexId|bits_of");
    Assert.assertTrue(matches.length == 1,
            "Exact match failed for 'A|ComplexId|bits_of'");
    matches = getMatcher().findAllIdMatches("A ComplexId Id");
    Assert.assertTrue(matches.length == 1,
            "Exact match failed for 'A Complex Id'");

  }

  @Test(groups = { "Functional" })
  public void testCaseInsensitiveMatch()
  {
    Assert.assertNotNull(getMatcher().findIdMatch("a|complexid"),
            "Couldn't retrieve a single case insensitive match.");
  }

  @Test(groups = { "Functional" })
  public void testWordSplit()
  {
    String[] words = new String[] { "several", "words", "separated",
        "fully" };
    String full = "";
    for (String word : words)
    {
      if (full.length() > 0)
      {
        full += "|";
      }
      full += word;
    }
    List<SeqIdName> bits = SequenceIdMatcher.getWordsFor(new Sequence(full,
            "dummy"));
    for (String word : words)
    {
      List<SeqIdName> equals = new ArrayList<SeqIdName>();
      for (SeqIdName bit : bits)
      {
        if (bit.equals(word))
        {
          equals.add(bit);
        }
      }
      Assert.assertTrue(equals.size() > 0,
              "Word generation has broken. Expected at least one match for '"
                      + word + "'");
    }
  }
  @Test(groups = { "Functional" })
  public void testFlankingMatch()
  {
    SequenceI[] match = getMatcher().findAllIdMatches("complexId");
    // should find two matches - one case exact, the other case inexact.
    Assert.assertNotNull(match, "Exact matches not found.");
    Assert.assertEquals(match.length, 2,
            "Expected two exact matches to be found.");
    SequenceI[] fmatch = getWordMatcher()
            .findAllIdMatches("complexId");
    // should find 6 distinct sequences
    Assert.assertNotNull(fmatch, "Flanking matches not found.");
    for (SequenceI f:fmatch)
    {
      System.out.println("Flanking 'complexId' match: '" + f.getName()
              + "'");
    }
    Assert.assertEquals(fmatch.length, 6,
            "Couldn't find all entries with IDs containing 'complexId' word match");

  }

  @Test(groups = { "Functional" })
  public void testPartialNotMatch()
  {
    SequenceI[] match = getWordMatcher().findAllIdMatches("complex");
    Assert.assertNull(match,
            "Partial match of 'complex' to any of sequences shouldn't yield a match.");
  }

}