package jalview.datamodel;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

import jalview.schemes.NucleotideColourScheme;

import org.testng.annotations.Test;

public class SequenceGroupTest
{
  @Test(groups={"Functional"})
  public void testAddSequence()
  {
    SequenceGroup sg = new SequenceGroup();
    assertTrue(sg.getSequences().isEmpty());

    SequenceI seq1 = new Sequence("seq1", "abc");
    SequenceI seq2 = new Sequence("seq2", "abc");
    SequenceI seq3 = new Sequence(seq1);

    sg.addSequence(null, false);
    assertTrue(sg.getSequences().isEmpty());
    sg.addSequence(seq1, false);
    assertEquals(sg.getSequences().size(), 1);
    assertTrue(sg.getSequences().contains(seq1));
    // adding the same sequence again does nothing
    sg.addSequence(seq1, false);
    assertEquals(sg.getSequences().size(), 1);
    assertTrue(sg.getSequences().contains(seq1));
    sg.addSequence(seq2, false);
    sg.addSequence(seq2, false);
    sg.addSequence(seq3, false);
    assertEquals(sg.getSequences().size(), 3);
    assertTrue(sg.getSequences().contains(seq1));
    assertTrue(sg.getSequences().contains(seq2));
    assertTrue(sg.getSequences().contains(seq3));
  }

  @Test(groups={"Functional"})
  public void testAddOrRemove()
  {
    SequenceGroup sg = new SequenceGroup();
    assertTrue(sg.getSequences().isEmpty());
  
    SequenceI seq1 = new Sequence("seq1", "abc");
    SequenceI seq2 = new Sequence("seq2", "abc");
    SequenceI seq3 = new Sequence(seq1);
  
    sg.addOrRemove(seq1, false);
    assertEquals(sg.getSequences().size(), 1);
    sg.addOrRemove(seq2, false);
    assertEquals(sg.getSequences().size(), 2);
    sg.addOrRemove(seq3, false);
    assertEquals(sg.getSequences().size(), 3);
    assertTrue(sg.getSequences().contains(seq1));
    assertTrue(sg.getSequences().contains(seq2));
    assertTrue(sg.getSequences().contains(seq3));
    sg.addOrRemove(seq1, false);
    assertEquals(sg.getSequences().size(), 2);
    assertFalse(sg.getSequences().contains(seq1));
  }

  @Test(groups={"Functional"})
  public void testGetColourScheme()
  {
    SequenceGroup sg = new SequenceGroup();
    assertNotNull(sg.getGroupColourScheme());
    assertNull(sg.getColourScheme());

    sg.setGroupColourScheme(null);
    assertNull(sg.getColourScheme());

    NucleotideColourScheme scheme = new NucleotideColourScheme();
    sg.setColourScheme(scheme);
    assertSame(scheme, sg.getColourScheme());
  }

  @Test(groups={"Functional"})
  public void testSetContext()
  {
    SequenceGroup sg1 = new SequenceGroup();
    SequenceGroup sg2 = new SequenceGroup();
    SequenceGroup sg3 = new SequenceGroup();
    assertNull(sg1.getContext());
    sg1.setContext(null);
    assertNull(sg1.getContext());
    try
    {
      sg1.setContext(sg1); // self-reference :-O
      fail("Expected exception");
    } catch (IllegalArgumentException e)
    {
      // expected
      assertNull(sg1.getContext());
    }
    sg1.setContext(sg2);
    assertSame(sg2, sg1.getContext());
    sg2.setContext(sg3);
    try
    {
      sg3.setContext(sg1); // circular reference :-O
      fail("Expected exception");
    } catch (IllegalArgumentException e)
    {
      // expected
      assertNull(sg3.getContext());
    }
  }

  @Test(groups = { "Functional" })
  public void testContains()
  {
    /* 
     * essentially the same tests as AlignmentI.findGroup 
     * but from a particular group's perspective
     */

    SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
    SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
    AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
    /*
     * add a group consisting of just "DEF"
     */
    SequenceGroup sg1 = new SequenceGroup();
    sg1.addSequence(seq1, false);
    sg1.setStartRes(3);
    sg1.setEndRes(5);

    /*
     * test sequence membership
     */
    assertTrue(sg1.contains(seq1));
    assertFalse(sg1.contains(seq2));

    /*
     * test sequence+position
     */

    assertFalse(sg1.contains(seq1, 2)); // position not in group
    assertFalse(sg1.contains(seq1, 6)); // position not in group
    assertFalse(sg1.contains(seq2, 5)); // sequence not in group
    assertTrue(sg1.contains(seq1, 3)); // yes
    assertTrue(sg1.contains(seq1, 4));
    assertTrue(sg1.contains(seq1, 5));

    /*
     * add a group consisting of 
     * EF--
     * KLMN
     */
    SequenceGroup sg2 = new SequenceGroup();
    sg2.addSequence(seq1, false);
    sg2.addSequence(seq2, false);
    sg2.setStartRes(4);
    sg2.setEndRes(7);
    a.addGroup(sg2);

    /*
     * if a residue is in more than one group, method returns
     * the first found (in order groups were added)
     */
    assertTrue(sg2.contains(seq1, 4));
    assertTrue(sg2.contains(seq1, 5));

    /*
     * seq2 only belongs to the second group
     */
    assertTrue(sg2.contains(seq2, 4));
    assertTrue(sg2.contains(seq2, 5));
    assertTrue(sg2.contains(seq2, 6));
    assertTrue(sg2.contains(seq2, 7));
    assertFalse(sg2.contains(seq2, 3));
    assertFalse(sg2.contains(seq2, 8));
    sg2.setEndRes(8);
    assertTrue(sg2.contains(seq2, 8));
    sg2.deleteSequence(seq2, false);
    assertFalse(sg2.contains(seq2));

  }
}