package jalview.appletgui;

import java.awt.*;
import jalview.bin.*;
import jalview.analysis.*;
import jalview.datamodel.*;
import jalview.schemes.*;
import java.util.*;

public class AlignViewport
{
  int startRes;
  int endRes;

  int startSeq;
  int endSeq;

  boolean showFullId = true;
  boolean showText=true;
  boolean showColourText=false;
  boolean showBoxes=true;
  boolean wrapAlignment=false;
  boolean renderGaps = true;
  boolean showSequenceFeatures = false;
  boolean showAnnotation = true;
  boolean showConservation = true;
  boolean showQuality = true;
  boolean showConsensus = true;

  boolean colourAppliesToAllGroups = true;
  ColourSchemeI globalColourScheme = null;
  boolean conservationColourSelected = false;
  boolean abovePIDThreshold = false;

  SequenceGroup selectionGroup = new SequenceGroup();

  int             charHeight;
  int             charWidth;
  int             chunkWidth;
  int             chunkHeight;

  Font            font = new Font("SansSerif",Font.PLAIN,10);
  AlignmentI      alignment;

  ColumnSelection colSel = new ColumnSelection();

  int threshold;
  int increment;

  NJTree currentTree = null;

  boolean scaleAboveWrapped = true;
  boolean scaleLeftWrapped  = true;
  boolean scaleRightWrapped = true;

  public AlignViewport(AlignmentI al, JalviewLite applet)
  {
    setAlignment(al);
    this.startRes = 0;
    this.endRes = al.getWidth()-1;
    this.startSeq = 0;
    this.endSeq = al.getHeight()-1;
    setFont(font);


    if(applet!=null)
    {
      String param = applet.getParameter("showFullId");
      if (param != null)
        showFullId = Boolean.valueOf(param).booleanValue();

      param = applet.getParameter("showAnnotation");
      if (param != null)
        showAnnotation = Boolean.valueOf(param).booleanValue();

      param = applet.getParameter("showConservation");
      if (param != null)
        showConservation = Boolean.valueOf(param).booleanValue();

      param = applet.getParameter("showQuality");
      if (param != null)
        showQuality = Boolean.valueOf(param).booleanValue();

      param = applet.getParameter("showConsensus");
      if (param != null)
        showConsensus = Boolean.valueOf(param).booleanValue();
    }
    // We must set conservation and consensus before setting colour,
    // as Blosum and Clustal require this to be done
    updateConservation();
    updateConsensus();

    if(applet!=null && applet.getParameter("defaultColour")!=null)
    {
      globalColourScheme = ColourSchemeProperty.getColour(alignment,
          applet.getParameter("defaultColour"));
      if(globalColourScheme!=null)
        globalColourScheme.setConsensus( vconsensus );
   }
 }


 public void showSequenceFeatures(boolean b)
 {
   showSequenceFeatures = b;
 }

  public Vector vconsensus;
  AlignmentAnnotation consensus;
  AlignmentAnnotation conservation;
  AlignmentAnnotation quality;

  public int ConsPercGaps = 25; // JBPNote : This should be a scalable property!

  public void updateConservation()
  {
    Conservation cons = new jalview.analysis.Conservation("All",
        jalview.schemes.ResidueProperties.propHash, 3,
        alignment.getSequences(), 0,
        alignment.getWidth()-1);
    cons.calculate();
    cons.verdict(false, ConsPercGaps);
    cons.findQuality();
    int alWidth = alignment.getWidth();
    Annotation [] annotations = new Annotation[alWidth];
    Annotation [] qannotations = new Annotation[alWidth];
    String sequence = cons.getConsSequence().getSequence();
    float minR,minG,minB, maxR,maxG,maxB;
    minR = 0.3f;
    minG = 0.0f;
    minB = 0f;
    maxR = 1.0f-minR; maxG=0.9f-minG; maxB=0f-minB; // scalable range for colouring both Conservation and Quality
    float min = 0f;
    float max = 11f;
    float qmin = cons.qualityRange[0].floatValue();
    float qmax = cons.qualityRange[1].floatValue();

    for (int i = 0; i < alWidth; i++)
    {
      float value = 0;
      try
        {
          value = Integer.parseInt(sequence.charAt(i) + "");
        }
      catch (Exception ex)
        {
          if (sequence.charAt(i) == '*') value = 11;
          if (sequence.charAt(i) == '+') value = 10;
        }
      float vprop = value-min;
      vprop/=max;
      annotations[i] = new Annotation(sequence.charAt(i) + "",
                                      "Conservation graph", ' ', value, new Color(minR+maxR*vprop, minG+maxG*vprop, minB+maxB*vprop));
      // Quality calc
      value = ((Double) cons.quality.elementAt(i)).floatValue();
      vprop = value - qmin;
      vprop/=qmax;
      qannotations[i] = new Annotation(" ",
                                      String.valueOf(value), ' ', value, new Color(minR+maxR*vprop, minG+maxG*vprop, minB+maxB*vprop));
    }

    if(conservation==null)
    {
      conservation = new AlignmentAnnotation("Conservation",
                                             "Conservation of total alignment less than "+ConsPercGaps+"% gaps",
                                             annotations,
                                             0f, // cons.qualityRange[0].floatValue(),
                                             11f, // cons.qualityRange[1].floatValue()
                                             1);
      if(showConservation)
      alignment.addAnnotation(conservation);
      quality = new AlignmentAnnotation("Quality",
                                        "Alignment Quality based on Blosum62 scores",
                                        qannotations,
                                        cons.qualityRange[0].floatValue(),
                                        cons.qualityRange[1].floatValue(),
                                        1);
      if(showQuality)
        alignment.addAnnotation(quality);
    }
    else {
      conservation.annotations = annotations;
      quality.annotations = qannotations;
      quality.graphMax = cons.qualityRange[1].floatValue();
    }


  }

  public void updateConsensus()
  {
    Annotation [] annotations = new Annotation[alignment.getWidth()];

    // this routine prevents vconsensus becoming a new object each time
    // consenus is calculated. Important for speed of Blosum62
    // and PID colouring of alignment
    if(vconsensus == null)
        vconsensus = alignment.getAAFrequency();
    else
    {
        Vector temp = alignment.getAAFrequency();
        vconsensus.removeAllElements();
        Enumeration e = temp.elements();
        while(e.hasMoreElements())
        {
          vconsensus.addElement(e.nextElement());
        }
    }
    Hashtable hash = null;
    for (int i = 0; i<alignment.getWidth(); i++)
    {
        hash = (Hashtable) vconsensus.elementAt(i);
        float value = new Float(hash.get("maxCount").toString()).floatValue();
        value /= new Float(hash.get("size").toString()).floatValue();

        value *= 100;
        String maxRes = hash.get("maxResidue")+" ";
        String mouseOver = hash.get("maxResidue")+" ";
        if(maxRes.length()>2)
        {
          mouseOver = "["+maxRes+"] ";
          maxRes = "+ ";
        }

        mouseOver += (int)value+"%";
        annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);

    }

     if(consensus==null)
     {
       consensus = new AlignmentAnnotation("Consensus",
                                           "PID", annotations, 0f, 100f, 1);
       if(showConsensus)
         alignment.addAnnotation(consensus);
     }
     else
       consensus.annotations = annotations;

  }


  public SequenceGroup getSelectionGroup()
  {
    return selectionGroup;
  }

  public void setSelectionGroup(SequenceGroup sg)
  {
    selectionGroup = sg;
  }


 public boolean getConservationSelected()
 {
   return conservationColourSelected;
 }

 public void setConservationSelected(boolean b)
 {
   conservationColourSelected = b;
 }

 public boolean getAbovePIDThreshold()
 {
   return abovePIDThreshold;
 }

 public void setAbovePIDThreshold(boolean b)
 {
   abovePIDThreshold = b;
 }

  public int getStartRes() {
    return startRes;
  }

  public int getEndRes() {
    return endRes;
  }

  public int getStartSeq() {
    return startSeq;
  }

  public void setGlobalColourScheme(ColourSchemeI cs)
  {
     globalColourScheme = cs;
  }

  public ColourSchemeI getGlobalColourScheme()
  {
    return globalColourScheme;
  }


  public void setStartRes(int res) {
    this.startRes = res;
  }
  public void setStartSeq(int seq) {
    this.startSeq = seq;
  }
  public void setEndRes(int res) {
    if (res > alignment.getWidth()-1) {
      System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1));
       res = alignment.getWidth()-1;
    }
    if (res < 0) {
      res = 0;
    }
    this.endRes = res;
  }
  public void setEndSeq(int seq) {
    if (seq > alignment.getHeight()) {
      seq = alignment.getHeight();
    }
    if (seq < 0) {
      seq = 0;
    }
    this.endSeq = seq;
  }
  public int getEndSeq() {
    return endSeq;
  }

  public void setFont(Font f) {
    font = f;
    java.awt.Frame temp = new java.awt.Frame();
    temp.addNotify();
    java.awt.FontMetrics fm = temp.getGraphics().getFontMetrics(font);
    setCharHeight(fm.getHeight());
    setCharWidth(fm.charWidth('M'));
  }

  public Font getFont() {
    return font;
  }
  public void setCharWidth(int w) {
    this.charWidth = w;
  }
  public int getCharWidth() {
    return charWidth;
  }
  public void setCharHeight(int h) {
    this.charHeight = h;
  }
  public int getCharHeight() {
    return charHeight;
  }
  public void setChunkWidth(int w) {
    this.chunkWidth = w;
  }
  public int getChunkWidth() {
    return chunkWidth;
  }
  public void setChunkHeight(int h) {
    this.chunkHeight = h;
  }
  public int getChunkHeight() {
    return chunkHeight;
  }
  public AlignmentI getAlignment() {
    return alignment;
  }
  public void setAlignment(AlignmentI align) {
    this.alignment = align;
  }

  public void setWrapAlignment(boolean state) {
    wrapAlignment = state;
  }
  public void setShowText(boolean state) {
    showText = state;
  }

  public void setRenderGaps(boolean state){
    renderGaps = state;
  }


  public boolean getColourText()
  {
    return showColourText;
  }

  public void setColourText(boolean state)
  {
    showColourText = state;
  }

  public void setShowBoxes(boolean state) {
    showBoxes = state;
  }

  public boolean getWrapAlignment() {
      return wrapAlignment;
  }
  public boolean getShowText() {
    return showText;
  }
  public boolean getShowBoxes() {
    return showBoxes;
  }

  public char getGapCharacter() {
    return getAlignment().getGapCharacter();
  }
  public void setGapCharacter(char gap) {
    if (getAlignment() != null) {
      getAlignment().setGapCharacter(gap);
    }
  }
  public void setThreshold(int thresh) {
    threshold = thresh;
  }
  public int getThreshold() {
    return threshold;
  }
  public void setIncrement(int inc) {
    increment = inc;
  }
  public int getIncrement() {
    return increment;
  }
  public int getIndex(int y) {
    int y1     = 0;
    int starty = getStartSeq();
    int endy   = getEndSeq();

    for (int i = starty; i <= endy; i++) {
      if (i < alignment.getHeight() && alignment.getSequenceAt(i) != null) {
        int y2 = y1 + getCharHeight();

        if (y>=y1 && y <=y2) {
          return i;
        }
        y1  = y2;
      } else {
        return -1;
      }
    }
    return -1;
  }

  public ColumnSelection getColumnSelection() {
    return colSel;
  }

  public void resetSeqLimits(int height) {
    setEndSeq(height/getCharHeight());
  }
  public void setCurrentTree(NJTree tree) {
      currentTree = tree;
  }
  public NJTree getCurrentTree() {
    return currentTree;
  }


  public void setColourAppliesToAllGroups(boolean b)
  {   colourAppliesToAllGroups = b; }

  public boolean getColourAppliesToAllGroups()
  {return colourAppliesToAllGroups; }

  public boolean getShowFullId()
  {
    return showFullId;
  }

  public void setShowFullId(boolean b)
  {
    showFullId = b;
  }

  public boolean getShowAnnotation()
  {
    return showAnnotation;
  }

  public void setShowAnnotation(boolean b)
  {
    showAnnotation = b;
  }

  public boolean getScaleAboveWrapped()
  { return scaleAboveWrapped;}

  public boolean getScaleLeftWrapped()
  { return scaleLeftWrapped; }

  public boolean getScaleRightWrapped()
  { return scaleRightWrapped; }

  public void setScaleAboveWrapped(boolean b)
  { scaleAboveWrapped = b; }

  public void setScaleLeftWrapped(boolean b)
  { scaleLeftWrapped = b; }

  public void setScaleRightWrapped(boolean b)
  { scaleRightWrapped = b; }


}