/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

package jalview.appletgui;

import java.util.*;

import java.awt.*;

import jalview.analysis.*;
import jalview.bin.*;
import jalview.datamodel.*;
import jalview.schemes.*;

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;


  boolean ignoreGapsInConsensusCalculation = false;

  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) + "",
                                      "", ' ', 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 = 0;
      if(ignoreGapsInConsensusCalculation)
        value = ((Float)hash.get("pid_nogaps")).floatValue();
      else
        value = ((Float)hash.get("pid_gaps")).floatValue();

      String maxRes = hash.get("maxResidue").toString();
      String mouseOver = hash.get("maxResidue") + " ";
      if (maxRes.length() > 1)
      {
        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)
    {
      // log.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;
  }

  public void setIgnoreGapsConsensus(boolean b)
  {
    ignoreGapsInConsensusCalculation = b;
    updateConsensus();
    if (globalColourScheme!=null)
    {
      globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
          ignoreGapsInConsensusCalculation);

    }

  }

  public boolean getIgnoreGapsConsensus()
  {
    return ignoreGapsInConsensusCalculation;
  }


}