/*
 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
 * Copyright (C) $$Year-Rel$$ 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 jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;

import java.awt.Color;

/**
 * A base class for colour schemes which define a graduated colour range based
 * on
 * <ul>
 * <li>a minimum colour</li>
 * <li>a maximum colour</li>
 * <li>a score assigned to each residue</li>
 * </ul>
 */
public class ScoreColourScheme extends ResidueColourScheme
{
  String schemeName;

  double min;

  double max;

  Color minColour;

  Color maxColour;

  double[] scores;

  /**
   * Constructor
   * 
   * @param name
   * @param symbolIndex
   *          a lookup where the index is a char e.g. 'R' or 'r', and the value
   *          is its position in the colour table lookup
   * @param theScores
   *          per residue, with indices corresponding to those for colour lookup
   * @param minColour
   *          graduated colour at minimum score value
   * @param maxColour
   *          graduated colour at maximum score value
   */
  public ScoreColourScheme(String name, int[] symbolIndex, double[] theScores,
          Color minColour, Color maxColour)
  {
    super(symbolIndex);
    this.schemeName = name;
    this.minColour = minColour;
    this.maxColour = maxColour;

    setMinMax(theScores);
    computeColours(theScores);
  }

  /**
   * Calculates and saves a graduated score based colour for each residue
   * 
   * @param theScores
   */
  protected void computeColours(double[] theScores)
  {
    this.scores = theScores;

    int iSize = theScores.length;
    colors = new Color[theScores.length];
    for (int i = 0; i < iSize; i++)
    {
      colors[i] = getScoreColour(theScores[i]);
    }
  }

  /**
   * Computes a colour for a score by
   * <ul>
   * <li>first scaling the score linearly from 0 (minScore) to 1 (maxScore)</li>
   * <li>then interpolating rgb values from minColour to maxColour</li>
   * </ul>
   * This method is used to make colours for residue scores, but may also be
   * called to generate a colour for an intermediate score value (for example, a
   * column average).
   */
  public Color getScoreColour(double rawScore)
  {
    float score = (float) (rawScore - (float) min) / (float) (max - min);
    score = Math.max(score, 0f);
    score = Math.min(score, 1f);

    int r = minColour.getRed()
            + Math.round((maxColour.getRed() - minColour.getRed()) * score);
    int g = minColour.getGreen()
            + Math.round(
                    (maxColour.getGreen() - minColour.getGreen()) * score);
    int b = minColour.getBlue()
            + Math.round(
                    (maxColour.getBlue() - minColour.getBlue()) * score);

    Color c = new Color(r, g, b);
    return c;
  }

  /**
   * Inspects score values and saves the minimum and maximum
   * 
   * @param vals
   */
  void setMinMax(double[] vals)
  {
    double dMin = Double.MAX_VALUE;
    double dMax = -Double.MAX_VALUE;

    for (int i = 0; i < vals.length; i++)
    {
      dMin = Math.min(dMin, vals[i]);
      dMax = Math.max(dMax, vals[i]);
    }

    this.min = vals.length == 0 ? 0d : dMin;
    this.max = vals.length == 0 ? 0d : dMax;
  }

  @Override
  public Color findColour(char c, int j, SequenceI seq)
  {
    if (Comparison.isGap(c))
    {
      return Color.white;
    }
    return super.findColour(c);
  }

  @Override
  public String getSchemeName()
  {
    return schemeName;
  }

  /**
   * Returns a new instance of this colour scheme with which the given data may
   * be coloured
   */
  @Override
  public ColourSchemeI getInstance(AlignViewportI view,
          AnnotatedCollectionI coll)
  {
    return new ScoreColourScheme(schemeName, symbolIndex, scores, minColour,
            maxColour);
  }
}