package jalview.datamodel;

import jalview.analysis.AlignSeq;

public class SeqCigar
    extends CigarSimple
{

  private SequenceI refseq=null;
  /**
   * Reference dataset sequence for the cigar string
   * @return SequenceI
   */
  public SequenceI getRefSeq() {
    return refseq;
  }
  /**
   * Returns sequence as a string with cigar operations applied to it
   * @return String
   */
  public String getSequenceString(char GapChar)
  {
    return (length==0) ? "" : (String) getSequenceAndDeletions(refseq.getSequence(), GapChar)[0];
  }

  /**
   * recreates a gapped and edited version of RefSeq or null for an empty cigar string
   * @return SequenceI
   */
  public SequenceI getSeq(char GapChar) {
    Sequence seq;
    if (refseq==null || length==0)
      return null;
    Object[] edit_result=getSequenceAndDeletions(refseq.getSequence(), GapChar);
    if (edit_result==null)
      throw new Error("Implementation Error - unexpected null from getSequenceAndDeletions");

    seq = new Sequence(refseq.getName(), (String) edit_result[0], refseq.getStart()+((int[]) edit_result[1])[0], refseq.getStart()+((int[]) edit_result[1])[2]);
    seq.setDatasetSequence(refseq);
    return seq;
  }
  /*
  We don't allow this - refseq is given at construction time only
   public void setSeq(SequenceI seq) {
    this.seq = seq;
  }
  */
  /**
   * internal constructor - sets seq to a gapless sequence derived from seq
   * and prepends any 'D' operations needed to get to the first residue of seq.
   * @param seq SequenceI
   * @return true if gaps are present in seq
   */
  private boolean _setSeq(SequenceI seq) {
    boolean hasgaps=false;

    if (seq==null)
      throw new Error("Implementation Error - _setSeq(null)");

    // Find correct sequence to reference and add initial hidden offset
    SequenceI ds = seq.getDatasetSequence();
    if (ds==null) {
      ds = new Sequence(seq.getName(),
                        AlignSeq.extractGaps(jalview.util.Comparison.GapChars, new String(seq.getSequence())),
                        seq.getStart(),
                        seq.getEnd());
    }
    // check that we haven't just duplicated an ungapped sequence.
      if (ds.getLength()==seq.getLength()) {
        ds = seq;
      } else {
        hasgaps = true;
      }
    this.refseq = ds;
    // Adjust offset
    if (ds.getStart()<seq.getStart()) {
      addDeleted(seq.getStart()-ds.getStart());
    }
    return hasgaps;
  }
  /**
   * directly initialise a cigar object with a sequence of range, operation pairs and a sequence to apply it to.
   * operation and range should be relative to the seq.getStart()'th residue of the dataset seq resolved from seq.
   * @param seq SequenceI
   * @param operation char[]
   * @param range int[]
   */
  public SeqCigar(SequenceI seq, char operation[], int range[]) {
    super();
    if (seq==null)
      throw new Error("Implementation Bug. Null seq !");
    if (operation.length!=range.length) {
      throw new Error("Implementation Bug. Cigar Operation list!= range list");
    }

    if (operation!=null) {
      this.operation = new char[operation.length+_inc_length];
      this.range = new int[operation.length+_inc_length];

      if (_setSeq(seq)) {
        throw new Error("NOT YET Implemented: Constructing a Cigar object from a cigar string and a gapped sequence.");
      }
      for (int i = this.length, j=0; j < operation.length; i++,j++)
      {
        char op = operation[j];
        if (op != M && op != I && op != D)
        {
          throw new Error(
              "Implementation Bug. Cigar Operation '"+j+"' '"+op+"' not one of '"+M+"', '"+I+"', or '"+D+"'.");
        }
        this.operation[i] = op;
        this.range[i] = range[j];
      }
      this.length+=operation.length;
    } else {
      this.operation = null;
      this.range = null;
      this.length=0;
      if (_setSeq(seq)) {
        throw new Error("NOT YET Implemented: Constructing a Cigar object from a cigar string and a gapped sequence.");
      }
    }
  }
  /**
   * add range matched residues to cigar string
   * @param range int
   */
  public void addMatch(int range) {
    this.addOperation(M, range);
  }
  /**
   * Deleted regions mean that there will be discontinuous sequence numbering in the
   * sequence returned by getSeq(char).
   * @return true if there are non-terminal deletions
   */
  public boolean hasDeletedRegions() {
    for (int i=1, l=length-1; i<l; i++) {
      if (operation[i]==D)
        return true;
    }
    return false;
  }
  protected static void addSequenceOps(CigarBase cigar, SequenceI seq, int startpos, int endpos) {
  char op = '\0';
  int range = 0;
  int p = 0, res = seq.getLength();
  startpos++;
  endpos++;
  while (p<res)
  {
    boolean isGap = jalview.util.Comparison.isGap(seq.getCharAt(p++));
    if ( (startpos <= p) && (p < endpos))
    {
      if (isGap)
      {
        if (range > 0 && op != I)
        {
          cigar.addOperation(op, range);
          range = 0;
        }
        op = I;
        range++;
      }
      else
      {
        if (range > 0 && op != M)
        {
          cigar.addOperation(op, range);
          range = 0;
        }
        op = M;
        range++;
      }
    }
    else
    {
      if (!isGap)
      {
        if (range > 0 && op != D)
        {
          cigar.addOperation(op, range);
          range = 0;
        }
        op = D;
        range++;
      }
      else
      {
        // do nothing - insertions are not recorded in flanking regions.
      }
    }
  }
  if (range > 0)
  {
    cigar.addOperation(op, range);
  }
  }
  /**
   * create a cigar string for given sequence
   * @param seq SequenceI
   */
  public SeqCigar(SequenceI seq) {
    super();
    if (seq == null)
      throw new Error("Implementation error for new Cigar(SequenceI)");
    if (_setSeq(seq))
    {
        // there is still work to do
      addSequenceOps(this, seq, 0, seq.getLength());
    }
  }
  public SeqCigar(SequenceI seq, int start, int end) {
    super();
    if (seq == null)
      throw new Error("Implementation error for new Cigar(SequenceI)");
    if (_setSeq(seq))
    {
      // there is still work to do
      addSequenceOps(this, seq, start, end);
    }
  }

  /**
   * Create a cigar object from a cigar string like '[<I|D|M><range>]+'
   * Will fail if the given seq already contains gaps (JBPNote: future implementation will fix)
   * @param seq SequenceI object resolvable to a dataset sequence
   * @param cigarString String
   * @return Cigar
   */
  public static SeqCigar parseCigar(SequenceI seq, String cigarString)
      throws Exception
  {
    Object[] opsandrange = parseCigarString(cigarString);
    return new SeqCigar(seq, (char[]) opsandrange[0], (int[]) opsandrange[1]);
  }
  /**
   * non rigorous testing
   */
  /**
   *
   * @param seq Sequence
   * @param ex_cs_gapped String
   * @return String
   */
  public static String testCigar_string(Sequence seq, String ex_cs_gapped) {
    SeqCigar c_sgapped = new SeqCigar(seq);
    String cs_gapped = c_sgapped.getCigarstring();
    if (!cs_gapped.equals(ex_cs_gapped))
      System.err.println("Failed getCigarstring: incorect string '"+cs_gapped+"' != "+ex_cs_gapped);
    return cs_gapped;
  }
  public static boolean testSeqRecovery(SeqCigar gen_sgapped, SequenceI s_gapped) {
    SequenceI gen_sgapped_s = gen_sgapped.getSeq('-');
    if (!gen_sgapped_s.getSequence().equals(s_gapped.getSequence())) {
      System.err.println("Couldn't reconstruct sequence.\n" +
                         gen_sgapped_s.getSequence() + "\n" +
                         s_gapped.getSequence());
      return false;
    }
    return true;
  }
  public static void main(String argv[]) throws Exception {
    Sequence s=new Sequence("MySeq", "asdfktryasdtqwrtsaslldddptyipqqwaslchvhttt",39,80);
    String orig_gapped;
    Sequence s_gapped=new Sequence("MySeq", orig_gapped="----asdf------ktryas---dtqwrtsasll----dddptyipqqwa----slchvhttt", 39,80);
    String ex_cs_gapped="4I4M6I6M3I11M4I12M4I9M";
    s_gapped.setDatasetSequence(s);
    String sub_gapped_s;
    Sequence s_subsequence_gapped=new Sequence("MySeq", sub_gapped_s="------ktryas---dtqwrtsasll----dddptyipqqwa----slchvh", 43,77);

    s_subsequence_gapped.setDatasetSequence(s);
    SeqCigar c_null = new SeqCigar(s);
    String cs_null = c_null.getCigarstring();
    if (cs_null.length()>0)
      System.err.println("Failed getCigarstring: Unexpected cigar operations:"+cs_null);
    testCigar_string(s_gapped, ex_cs_gapped);
    SeqCigar gen_sgapped = SeqCigar.parseCigar(s, ex_cs_gapped);
    if (!gen_sgapped.getCigarstring().equals(ex_cs_gapped))
      System.err.println("Failed parseCigar("+ex_cs_gapped+")->getCigarString()->'"+gen_sgapped.getCigarstring()+"'");
    testSeqRecovery(gen_sgapped, s_gapped);
    // Test dataset resolution
    SeqCigar sub_gapped = new SeqCigar(s_subsequence_gapped);
    if (!testSeqRecovery(sub_gapped, s_subsequence_gapped))
        System.err.println("Failed recovery for subsequence of dataset sequence");
    // width functions
    if (sub_gapped.getWidth()!=sub_gapped_s.length())
      System.err.println("Failed getWidth()");

    sub_gapped.getFullWidth();
    if (sub_gapped.hasDeletedRegions())
      System.err.println("hasDeletedRegions is incorrect.");
    // Test start-end region SeqCigar
    SeqCigar sub_se_gp= new SeqCigar(s_subsequence_gapped, 8, 48);
    if (sub_se_gp.getWidth()!=40)
      System.err.println("SeqCigar(seq, start, end) not properly clipped alignsequence.");
    System.out.println("Original sequence align:\n"+sub_gapped_s+"\nReconstructed window from 8 to 48\n"+"XXXXXXXX"+sub_se_gp.getSequenceString('-')+"...."+"\nCigar String:"+sub_se_gp.getCigarstring()+"");
  }

}