package jalview.datamodel;

import jalview.util.MapList;

/**
 * Stores mapping between the columns of a protein alignment and a DNA alignment
 * and a list of individual codon to amino acid mappings between sequences.
 */

public class AlignedCodonFrame
{
  /**
   * array of nucleotide positions for aligned codons at column of aligned proteins.
   */
  public int[][] codons = null;
  /**
   * width of protein sequence alignement
   * implicit assertion that codons.length >= aaWidth
   */
  public int aaWidth=0;
  /**
   * initialise codon frame with a nominal alignment width
   * @param aWidth
   */
  public AlignedCodonFrame(int aWidth)
  {
    codons = new int[aWidth][];
    for (int res = 0; res < aWidth; res++)
      codons[res] = null;
  }

  /**
   * ensure that codons array is at least as wide as aslen residues
   * @param aslen
   * @return (possibly newly expanded) codon array
   */
  public int[][] checkCodonFrameWidth(int aslen)
  {
    if (codons.length <= aslen + 1)
    {
      // probably never have to do this ?
      int[][] c = new int[codons.length + 10][];
      for (int i = 0; i < codons.length; i++)
      {
        c[i] = codons[i];
        codons[i] = null;
      }
      codons = c;
    }
    return codons;
  }
  /**
   * @return width of aligned translated amino acid residues 
   */
  public int getaaWidth()
  {
    return aaWidth;
  }
  /**
   * increase aaWidth by one and insert a new aligned codon position space at aspos.
   * @param aspos
   */
  public void insertAAGap(int aspos, char gapCharacter)
  {            
    // this aa appears before the aligned codons at aspos - so shift them in each pair of mapped sequences
    aaWidth++;
    for (int sq=0;aaSeqs!=null && sq<aaSeqs.length; sq++) {
      aaSeqs[sq].insertCharAt(aspos, gapCharacter);
    }

    checkCodonFrameWidth(aspos);
    if (aspos<aaWidth)
    {
      aaWidth++;
      System.arraycopy(codons, aspos, codons, aspos+1, aaWidth-aspos);
      codons[aspos]=null; // clear so new codon position can be marked.
    }
  }

  public void setAaWidth(int aapos)
  {
    aaWidth = aapos;
  }
  /**
   * tied array of na Sequence objects.
   */
  SequenceI[] dnaSeqs=null;
  /**
   * tied array of protein sequence Objects
   */
  SequenceI[] aaSeqs=null;
  /**
   * tied array of MapLists where eac maps from the corresponding dnaSeqs element to corresponding aaSeqs element  
   */
  MapList[] dnaToProt=null;
  
  public void addMap(SequenceI dnaseq, SequenceI aaseq, MapList map)
  { 
    int nlen=1;
    if (dnaSeqs!=null)
    {
      nlen = dnaSeqs.length+1;
    }
    SequenceI[] ndna = new SequenceI[nlen];
    SequenceI[] naa = new SequenceI[nlen];
    MapList[] ndtp = new MapList[nlen];
    if (dnaSeqs!=null)
    {
      System.arraycopy(dnaSeqs,0,ndna, 0, dnaSeqs.length);
      System.arraycopy(aaSeqs,0,naa, 0, dnaSeqs.length);
      System.arraycopy(dnaToProt,0,ndtp, 0, dnaSeqs.length);
    }
    dnaSeqs = ndna;
    aaSeqs = naa;
    dnaToProt = ndtp;
    nlen--;
    dnaSeqs[nlen] = (dnaseq.getDatasetSequence()==null) ? dnaseq : dnaseq.getDatasetSequence();
    aaSeqs[nlen] = (aaseq.getDatasetSequence()==null) ? aaseq : aaseq.getDatasetSequence();
    dnaToProt[nlen] = map;
  }


  public SequenceI[] getdnaSeqs()
  {
    return dnaSeqs;
  }
  public SequenceI[] getAaSeqs()
  {
    return aaSeqs;
  }
  public MapList[] getdnaToProt()
  {
    return dnaToProt;
  }
  /**
   * 
   * @param sequenceRef
   * @return null or corresponding aaSeq entry for dnaSeq entry
   */
  public SequenceI getAaForDnaSeq(SequenceI dnaSeqRef)
  {
    if (dnaSeqs==null)
    {
      return null;
    }
    SequenceI dnads = dnaSeqRef.getDatasetSequence();
    for (int ds=0;ds<dnaSeqs.length; ds++)
    {
      if (dnaSeqs[ds]==dnaSeqRef || dnaSeqs[ds]==dnads)
        return aaSeqs[ds];
    }
    return null;
  }
  /**
   * 
   * @param sequenceRef
   * @return null or corresponding aaSeq entry for dnaSeq entry
   */
  public SequenceI getDnaForAaSeq(SequenceI aaSeqRef)
  {
    if (aaSeqs==null)
    {
      return null;
    }
    SequenceI aads = aaSeqRef.getDatasetSequence();
    for (int as=0;as<aaSeqs.length; as++)
    {
      if (aaSeqs[as]==aaSeqRef || aaSeqs[as]==aads)
        return dnaSeqs[as];
    }
    return null;
  }
  /**
   * test to see if codon frame involves seq in any way
   * @param seq a nucleotide or protein sequence
   * @return true if a mapping exists to or from this sequence to any translated sequence
   */
  public boolean involvesSequence(SequenceI seq)
  {
    return getAaForDnaSeq(seq)!=null || getDnaForAaSeq(seq)!=null;
  }
  /**
   * Add search results for regions in other sequences that translate or are translated from a particular position in seq 
   * @param seq
   * @param index position in seq
   * @param results where highlighted regions go
   */
  public void markMappedRegion(SequenceI seq, int index, SearchResults results)
  {
    int[] codon;
    SequenceI ds = seq.getDatasetSequence();
    for (int mi = 0; mi<aaSeqs.length; mi++)
    {
      if (dnaSeqs[mi]==seq || dnaSeqs[mi]==ds)
      {
        // DEBUG System.err.println("dna pos "+index);
        codon = dnaToProt[mi].locateInTo(index,index);
        if (codon!=null)
        {
          for (int i=0; i<codon.length; i+=2)
            {
              results.addResult(aaSeqs[mi], codon[i], codon[i+1]);
            }
        }
      } else
        if (aaSeqs[mi]==seq || aaSeqs[mi]==ds)
        {
          // DEBUG System.err.println("aa pos "+index);
          {
            codon = dnaToProt[mi].locateInFrom(index, index);
            if (codon!=null)
            {
            for (int i=0; i<codon.length; i+=2)
              {
                results.addResult(dnaSeqs[mi], codon[i], codon[i+1]);
              }
          }
        }
        }
    }
  }
}