/*
 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9)
 * Copyright (C) 2015 The Jalview Authors
 * 
 * This file is part of Jalview.
 * 
 * Jalview is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *  
 * Jalview is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 * PURPOSE.  See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
 * The Jalview Authors are detailed in the 'AUTHORS' file.
 */
package jalview.schemes;

import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;

import java.util.Collections;
import java.util.List;

import org.testng.annotations.Test;

public class ResiduePropertiesTest
{

  /**
   * Test 'standard' codon translations (no ambiguity codes)
   */
  @Test(groups = { "Functional" })
  public void testCodonTranslate()
  {
    // standard translation table order column 1/2/3/4
    assertEquals("F", ResidueProperties.codonTranslate("TTT"));
    assertEquals("F", ResidueProperties.codonTranslate("TTC"));
    assertEquals("L", ResidueProperties.codonTranslate("TTA"));
    assertEquals("L", ResidueProperties.codonTranslate("TTG"));
    assertEquals("L", ResidueProperties.codonTranslate("CTT"));
    assertEquals("L", ResidueProperties.codonTranslate("CTC"));
    assertEquals("L", ResidueProperties.codonTranslate("CTA"));
    assertEquals("L", ResidueProperties.codonTranslate("CTG"));
    assertEquals("I", ResidueProperties.codonTranslate("ATT"));
    assertEquals("I", ResidueProperties.codonTranslate("ATC"));
    assertEquals("I", ResidueProperties.codonTranslate("ATA"));
    assertEquals("M", ResidueProperties.codonTranslate("ATG"));
    assertEquals("V", ResidueProperties.codonTranslate("GTT"));
    assertEquals("V", ResidueProperties.codonTranslate("GTC"));
    assertEquals("V", ResidueProperties.codonTranslate("GTA"));
    assertEquals("V", ResidueProperties.codonTranslate("GTG"));
    assertEquals("S", ResidueProperties.codonTranslate("TCT"));
    assertEquals("S", ResidueProperties.codonTranslate("TCC"));
    assertEquals("S", ResidueProperties.codonTranslate("TCA"));
    assertEquals("S", ResidueProperties.codonTranslate("TCG"));
    assertEquals("P", ResidueProperties.codonTranslate("CCT"));
    assertEquals("P", ResidueProperties.codonTranslate("CCC"));
    assertEquals("P", ResidueProperties.codonTranslate("CCA"));
    assertEquals("P", ResidueProperties.codonTranslate("CCG"));
    assertEquals("T", ResidueProperties.codonTranslate("ACT"));
    assertEquals("T", ResidueProperties.codonTranslate("ACC"));
    assertEquals("T", ResidueProperties.codonTranslate("ACA"));
    assertEquals("T", ResidueProperties.codonTranslate("ACG"));
    assertEquals("A", ResidueProperties.codonTranslate("GCT"));
    assertEquals("A", ResidueProperties.codonTranslate("GCC"));
    assertEquals("A", ResidueProperties.codonTranslate("GCA"));
    assertEquals("A", ResidueProperties.codonTranslate("GCG"));
    assertEquals("Y", ResidueProperties.codonTranslate("TAT"));
    assertEquals("Y", ResidueProperties.codonTranslate("TAC"));
    assertEquals("STOP", ResidueProperties.codonTranslate("TAA"));
    assertEquals("STOP", ResidueProperties.codonTranslate("TAG"));
    assertEquals("H", ResidueProperties.codonTranslate("CAT"));
    assertEquals("H", ResidueProperties.codonTranslate("CAC"));
    assertEquals("Q", ResidueProperties.codonTranslate("CAA"));
    assertEquals("Q", ResidueProperties.codonTranslate("CAG"));
    assertEquals("N", ResidueProperties.codonTranslate("AAT"));
    assertEquals("N", ResidueProperties.codonTranslate("AAC"));
    assertEquals("K", ResidueProperties.codonTranslate("AAA"));
    assertEquals("K", ResidueProperties.codonTranslate("AAG"));
    assertEquals("D", ResidueProperties.codonTranslate("GAT"));
    assertEquals("D", ResidueProperties.codonTranslate("GAC"));
    assertEquals("E", ResidueProperties.codonTranslate("GAA"));
    assertEquals("E", ResidueProperties.codonTranslate("GAG"));
    assertEquals("C", ResidueProperties.codonTranslate("TGT"));
    assertEquals("C", ResidueProperties.codonTranslate("TGC"));
    assertEquals("STOP", ResidueProperties.codonTranslate("TGA"));
    assertEquals("W", ResidueProperties.codonTranslate("TGG"));
    assertEquals("R", ResidueProperties.codonTranslate("CGT"));
    assertEquals("R", ResidueProperties.codonTranslate("CGC"));
    assertEquals("R", ResidueProperties.codonTranslate("CGA"));
    assertEquals("R", ResidueProperties.codonTranslate("CGG"));
    assertEquals("S", ResidueProperties.codonTranslate("AGT"));
    assertEquals("S", ResidueProperties.codonTranslate("AGC"));
    assertEquals("R", ResidueProperties.codonTranslate("AGA"));
    assertEquals("R", ResidueProperties.codonTranslate("AGG"));
    assertEquals("G", ResidueProperties.codonTranslate("GGT"));
    assertEquals("G", ResidueProperties.codonTranslate("GGC"));
    assertEquals("G", ResidueProperties.codonTranslate("GGA"));
    assertEquals("G", ResidueProperties.codonTranslate("GGG"));
  }

  /**
   * Test a sample of codon translations involving ambiguity codes. Should
   * return a protein value where the ambiguity does not affect the translation.
   */
  @Test(groups = { "Functional" })
  public void testCodonTranslate_ambiguityCodes()
  {
    // Y is C or T
    assertEquals("C", ResidueProperties.codonTranslate("TGY"));
    // Phenylalanine first base variation
    assertEquals("L", ResidueProperties.codonTranslate("YTA"));

    // W is A or T
    assertEquals("L", ResidueProperties.codonTranslate("CTW"));
    assertNull(ResidueProperties.codonTranslate("TTW"));

    // S is G or C
    assertEquals("G", ResidueProperties.codonTranslate("GGS"));
    assertNull(ResidueProperties.codonTranslate("ATS"));

    // K is T or G
    assertEquals("S", ResidueProperties.codonTranslate("TCK"));
    assertNull(ResidueProperties.codonTranslate("ATK"));

    // M is C or A
    assertEquals("T", ResidueProperties.codonTranslate("ACM"));
    // Arginine first base variation
    assertEquals("R", ResidueProperties.codonTranslate("MGA"));
    assertEquals("R", ResidueProperties.codonTranslate("MGG"));
    assertNull(ResidueProperties.codonTranslate("TAM"));

    // D is A, G or T
    assertEquals("P", ResidueProperties.codonTranslate("CCD"));
    assertNull(ResidueProperties.codonTranslate("AAD"));

    // V is A, C or G
    assertEquals("V", ResidueProperties.codonTranslate("GTV"));
    assertNull(ResidueProperties.codonTranslate("TTV"));

    // H is A, C or T
    assertEquals("A", ResidueProperties.codonTranslate("GCH"));
    assertEquals("I", ResidueProperties.codonTranslate("ATH"));
    assertNull(ResidueProperties.codonTranslate("AGH"));

    // B is C, G or T
    assertEquals("P", ResidueProperties.codonTranslate("CCB"));
    assertNull(ResidueProperties.codonTranslate("TAB"));

    // R is A or G
    // additional tests for JAL-1685 (resolved)
    assertEquals("L", ResidueProperties.codonTranslate("CTR"));
    assertEquals("V", ResidueProperties.codonTranslate("GTR"));
    assertEquals("S", ResidueProperties.codonTranslate("TCR"));
    assertEquals("P", ResidueProperties.codonTranslate("CCR"));
    assertEquals("T", ResidueProperties.codonTranslate("ACR"));
    assertEquals("A", ResidueProperties.codonTranslate("GCR"));
    assertEquals("R", ResidueProperties.codonTranslate("CGR"));
    assertEquals("G", ResidueProperties.codonTranslate("GGR"));
    assertEquals("R", ResidueProperties.codonTranslate("AGR"));
    assertEquals("E", ResidueProperties.codonTranslate("GAR"));
    assertEquals("K", ResidueProperties.codonTranslate("AAR"));
    assertEquals("L", ResidueProperties.codonTranslate("TTR"));
    assertEquals("Q", ResidueProperties.codonTranslate("CAR"));
    assertEquals("STOP", ResidueProperties.codonTranslate("TAR"));
    assertEquals("STOP", ResidueProperties.codonTranslate("TRA"));
    // Arginine first and third base ambiguity
    assertEquals("R", ResidueProperties.codonTranslate("MGR"));
    assertNull(ResidueProperties.codonTranslate("ATR"));

    // N is any base; 8 proteins accept any base in 3rd position
    assertEquals("L", ResidueProperties.codonTranslate("CTN"));
    assertEquals("V", ResidueProperties.codonTranslate("GTN"));
    assertEquals("S", ResidueProperties.codonTranslate("TCN"));
    assertEquals("P", ResidueProperties.codonTranslate("CCN"));
    assertEquals("T", ResidueProperties.codonTranslate("ACN"));
    assertEquals("A", ResidueProperties.codonTranslate("GCN"));
    assertEquals("R", ResidueProperties.codonTranslate("CGN"));
    assertEquals("G", ResidueProperties.codonTranslate("GGN"));
    assertNull(ResidueProperties.codonTranslate("ATN"));
    assertNull(ResidueProperties.codonTranslate("ANT"));
    assertNull(ResidueProperties.codonTranslate("NAT"));
    assertNull(ResidueProperties.codonTranslate("ANN"));
    assertNull(ResidueProperties.codonTranslate("NNA"));
    assertNull(ResidueProperties.codonTranslate("NNN"));

    // some random stuff
    assertNull(ResidueProperties.codonTranslate("YWB"));
    assertNull(ResidueProperties.codonTranslate("VHD"));
    assertNull(ResidueProperties.codonTranslate("WSK"));
  }

  @Test(groups = { "Functional" })
  public void testGetResidues_nucleotide()
  {
    /*
     * Non-ambiguous only; we don't care about the order of the list, it is just
     * sorted here to make assertions reliable
     */
    List<String> residues = ResidueProperties.getResidues(true, false);
    Collections.sort(residues);
    assertEquals("[A, C, G, T, U]", residues.toString());

    /*
     * Including ambiguity codes I N R X Y
     */
    residues = ResidueProperties.getResidues(true, true);
    Collections.sort(residues);
    assertEquals("[A, C, G, I, N, R, T, U, X, Y]", residues.toString());
  }

  @Test(groups = { "Functional" })
  public void testGetResidues_peptide()
  {
    /*
     * Non-ambiguous only; we don't care about the order of the list, it is just
     * sorted here to make assertions reliable
     */
    List<String> residues = ResidueProperties.getResidues(false, false);
    Collections.sort(residues);
    assertEquals(
            "[ALA, ARG, ASN, ASP, CYS, GLN, GLU, GLY, HIS, ILE, LEU, LYS, MET, PHE, PRO, SER, THR, TRP, TYR, VAL]",
            residues.toString());

    /*
     * Including ambiguity codes ASX, GLX, XAA
     */
    residues = ResidueProperties.getResidues(false, true);
    Collections.sort(residues);
    assertEquals(
            "[ALA, ARG, ASN, ASP, ASX, CYS, GLN, GLU, GLX, GLY, HIS, ILE, LEU, LYS, MET, PHE, PRO, SER, THR, TRP, TYR, VAL, XAA]",
            residues.toString());
  }

  @Test(groups = { "Functional" })
  public void testGetCanonicalAminoAcid()
  {
    assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MET"));
    assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MSE"));
    assertEquals(null, ResidueProperties.getCanonicalAminoAcid(null));
  }

  @Test(groups = { "Functional" })
  public void testGetSingleCharacterCode()
  {
    assertEquals('0', ResidueProperties.getSingleCharacterCode(null));
    assertEquals('0', ResidueProperties.getSingleCharacterCode(null));
    assertEquals('0', ResidueProperties.getSingleCharacterCode(""));
    assertEquals('Q', ResidueProperties.getSingleCharacterCode("GLN"));
    assertEquals('Q', ResidueProperties.getSingleCharacterCode("Gln"));
    assertEquals('Q', ResidueProperties.getSingleCharacterCode("gln"));
  }
}