package jalview.schemes;

import jalview.api.ColorI;
import jalview.api.FeatureColourI;
import jalview.datamodel.SequenceFeature;
import jalview.util.Format;

import java.awt.Color;
import java.util.StringTokenizer;

/**
 * A class that wraps either a simple colour or a graduated colour
 */
public class FeatureColour implements FeatureColourI
{
  private static final String BAR = "|";

  final private ColorI colour;

  final private ColorI minColour;

  final private ColorI maxColour;

  private boolean graduatedColour;

  private boolean colourByLabel;

  private float threshold;

  private float base;

  private float range;

  private boolean belowThreshold;

  private boolean aboveThreshold;

  private boolean thresholdIsMinOrMax;

  private boolean isHighToLow;

  private boolean autoScaled;

  final private float minRed;

  final private float minGreen;

  final private float minBlue;

  final private float deltaRed;

  final private float deltaGreen;

  final private float deltaBlue;

  /**
   * Parses a Jalview features file format colour descriptor
   * [label|][mincolour|maxcolour
   * |[absolute|]minvalue|maxvalue|thresholdtype|thresholdvalue] Examples:
   * <ul>
   * <li>red</li>
   * <li>a28bbb</li>
   * <li>25,125,213</li>
   * <li>label</li>
   * <li>label|||0.0|0.0|above|12.5</li>
   * <li>label|||0.0|0.0|below|12.5</li>
   * <li>red|green|12.0|26.0|none</li>
   * <li>a28bbb|3eb555|12.0|26.0|above|12.5</li>
   * <li>a28bbb|3eb555|abso|12.0|26.0|below|12.5</li>
   * </ul>
   * 
   * @param descriptor
   * @return
   * @throws IllegalArgumentException
   *           if not parseable
   */
  public static FeatureColour parseJalviewFeatureColour(String descriptor)
  {
    StringTokenizer gcol = new StringTokenizer(descriptor, "|", true);
    float min = Float.MIN_VALUE;
    float max = Float.MAX_VALUE;
    boolean labelColour = false;

    String mincol = gcol.nextToken();
    if (mincol == "|")
    {
      throw new IllegalArgumentException(
              "Expected either 'label' or a colour specification in the line: "
                      + descriptor);
    }
    String maxcol = null;
    if (mincol.toLowerCase().indexOf("label") == 0)
    {
      labelColour = true;
      mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null);
      // skip '|'
      mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null);
    }

    if (!labelColour && !gcol.hasMoreTokens())
    {
      /*
       * only a simple colour specification - parse it
       */
      Color colour = UserColourScheme.getColourFromString(descriptor);
      if (colour == null)
      {
        throw new IllegalArgumentException("Invalid colour descriptor: "
                + descriptor);
      }
      return new FeatureColour(new Colour(colour));
    }

    /*
     * autoScaled == true: colours range over actual score range; autoScaled ==
     * false ('abso'): colours range over min/max range
     */
    boolean autoScaled = false;
    String tok = null, minval, maxval;
    if (mincol != null)
    {
      // at least four more tokens
      if (mincol.equals("|"))
      {
        mincol = "";
      }
      else
      {
        gcol.nextToken(); // skip next '|'
      }
      maxcol = gcol.nextToken();
      if (maxcol.equals("|"))
      {
        maxcol = "";
      }
      else
      {
        gcol.nextToken(); // skip next '|'
      }
      tok = gcol.nextToken();
      gcol.nextToken(); // skip next '|'
      if (tok.toLowerCase().indexOf("abso") != 0)
      {
        minval = tok;
        autoScaled = true;
      }
      else
      {
        minval = gcol.nextToken();
        gcol.nextToken(); // skip next '|'
      }
      maxval = gcol.nextToken();
      if (gcol.hasMoreTokens())
      {
        gcol.nextToken(); // skip next '|'
      }
      try
      {
        if (minval.length() > 0)
        {
          min = new Float(minval).floatValue();
        }
      } catch (Exception e)
      {
        throw new IllegalArgumentException(
                "Couldn't parse the minimum value for graduated colour ("
                        + descriptor + ")");
      }
      try
      {
        if (maxval.length() > 0)
        {
          max = new Float(maxval).floatValue();
        }
      } catch (Exception e)
      {
        throw new IllegalArgumentException(
                "Couldn't parse the maximum value for graduated colour ("
                        + descriptor + ")");
      }
    }
    else
    {
      // add in some dummy min/max colours for the label-only
      // colourscheme.
      mincol = "FFFFFF";
      maxcol = "000000";
    }

    /*
     * construct the FeatureColour
     */
    FeatureColour featureColour;
    try
    {
      featureColour = new FeatureColour(new Colour(new UserColourScheme(
              mincol).findColour('A')), new Colour(new UserColourScheme(
              maxcol).findColour('A')), min, max);
      featureColour.setColourByLabel(labelColour);
      featureColour.setAutoScaled(autoScaled);
      // add in any additional parameters
      String ttype = null, tval = null;
      if (gcol.hasMoreTokens())
      {
        // threshold type and possibly a threshold value
        ttype = gcol.nextToken();
        if (ttype.toLowerCase().startsWith("below"))
        {
          featureColour.setBelowThreshold(true);
        }
        else if (ttype.toLowerCase().startsWith("above"))
        {
          featureColour.setAboveThreshold(true);
        }
        else
        {
          if (!ttype.toLowerCase().startsWith("no"))
          {
            System.err.println("Ignoring unrecognised threshold type : "
                    + ttype);
          }
        }
      }
      if (featureColour.hasThreshold())
      {
        try
        {
          gcol.nextToken();
          tval = gcol.nextToken();
          featureColour.setThreshold(new Float(tval).floatValue());
        } catch (Exception e)
        {
          System.err.println("Couldn't parse threshold value as a float: ("
                  + tval + ")");
        }
      }
      if (gcol.hasMoreTokens())
      {
        System.err
                .println("Ignoring additional tokens in parameters in graduated colour specification\n");
        while (gcol.hasMoreTokens())
        {
          System.err.println("|" + gcol.nextToken());
        }
        System.err.println("\n");
      }
      return featureColour;
    } catch (Exception e)
    {
      throw new IllegalArgumentException(e.getMessage());
    }
  }

  /**
   * Default constructor
   */
  public FeatureColour()
  {
    this((ColorI) null);
  }

  /**
   * Constructor given a simple colour
   * 
   * @param c
   */
  public FeatureColour(ColorI c)
  {
    minColour = new Colour(Color.WHITE);
    maxColour = new Colour(Color.BLACK);
    minRed = 0f;
    minGreen = 0f;
    minBlue = 0f;
    deltaRed = 0f;
    deltaGreen = 0f;
    deltaBlue = 0f;
    colour = c;
  }

  public FeatureColour(Color c)
  {
    this(new Colour(c));
  }

  /**
   * Constructor given a colour range and a score range
   * 
   * @param low
   * @param high
   * @param min
   * @param max
   */
  public FeatureColour(ColorI low, ColorI high, float min, float max)
  {
    graduatedColour = true;
    colour = null;
    minColour = low;
    maxColour = high;
    threshold = Float.NaN;
    isHighToLow = min >= max;
    minRed = low.getRed() / 255f;
    minGreen = low.getGreen() / 255f;
    minBlue = low.getBlue() / 255f;
    deltaRed = (high.getRed() / 255f) - minRed;
    deltaGreen = (high.getGreen() / 255f) - minGreen;
    deltaBlue = (high.getBlue() / 255f) - minBlue;
    if (isHighToLow)
    {
      base = max;
      range = min - max;
    }
    else
    {
      base = min;
      range = max - min;
    }
  }

  public FeatureColour(Color low, Color high, float min, float max)
  {
    this(new Colour(low), new Colour(high), min, max);
  }
  /**
   * Copy constructor
   * 
   * @param fc
   */
  public FeatureColour(FeatureColour fc)
  {
    colour = fc.colour;
    minColour = fc.minColour;
    maxColour = fc.maxColour;
    minRed = fc.minRed;
    minGreen = fc.minGreen;
    minBlue = fc.minBlue;
    deltaRed = fc.deltaRed;
    deltaGreen = fc.deltaGreen;
    deltaBlue = fc.deltaBlue;
    base = fc.base;
    range = fc.range;
    isHighToLow = fc.isHighToLow;
    setAboveThreshold(fc.isAboveThreshold());
    setBelowThreshold(fc.isBelowThreshold());
    setThreshold(fc.getThreshold());
    setAutoScaled(fc.isAutoScaled());
    setColourByLabel(fc.isColourByLabel());
  }
  
  /**
   * Copy constructor with new min/max ranges
   * @param fc
   * @param min
   * @param max
   */
  public FeatureColour(FeatureColour fc, float min, float max)
  {
    this(fc);
    graduatedColour = true;
    updateBounds(min, max);
  }

  @Override
  public boolean isGraduatedColour()
  {
    return graduatedColour;
  }

  /**
   * Sets the 'graduated colour' flag. If true, also sets 'colour by label' to
   * false.
   */
  @Override
  public void setGraduatedColour(boolean b)
  {
    graduatedColour = b;
    if (b)
    {
      setColourByLabel(false);
    }
  }

  @Override
  public ColorI getColour()
  {
    return colour;
  }

  @Override
  public ColorI getMinColour()
  {
    return minColour;
  }

  @Override
  public ColorI getMaxColour()
  {
    return maxColour;
  }

  @Override
  public boolean isColourByLabel()
  {
    return colourByLabel;
  }

  /**
   * Sets the 'colour by label' flag. If true, also sets 'graduated colour' to
   * false.
   */
  @Override
  public void setColourByLabel(boolean b)
  {
    colourByLabel = b;
    if (b)
    {
      setGraduatedColour(false);
    }
  }
  @Override
  public boolean isBelowThreshold()
  {
    return belowThreshold;
  }

  @Override
  public void setBelowThreshold(boolean b)
  {
    belowThreshold = b;
    if (b)
    {
      setAboveThreshold(false);
    }
  }

  @Override
  public boolean isAboveThreshold()
  {
    return aboveThreshold;
  }

  @Override
  public void setAboveThreshold(boolean b)
  {
    aboveThreshold = b;
    if (b)
    {
      setBelowThreshold(false);
    }
  }

  @Override
  public boolean isThresholdMinMax()
  {
    return thresholdIsMinOrMax;
  }

  @Override
  public void setThresholdMinMax(boolean b)
  {
    thresholdIsMinOrMax = b;
  }

  @Override
  public float getThreshold()
  {
    return threshold;
  }

  @Override
  public void setThreshold(float f)
  {
    threshold = f;
  }

  @Override
  public boolean isAutoScaled()
  {
    return autoScaled;
  }

  @Override
  public void setAutoScaled(boolean b)
  {
    this.autoScaled = b;
  }

  /**
   * Updates the base and range appropriately for the given minmax range
   * 
   * @param min
   * @param max
   */
  @Override
  public void updateBounds(float min, float max)
  {
    if (max < min)
    {
      base = max;
      range = min - max;
      isHighToLow = true;
    }
    else
    {
      base = min;
      range = max - min;
      isHighToLow = false;
    }
  }

  /**
   * Returns the colour for the given instance of the feature. This may be a
   * simple colour, a colour generated from the feature description (if
   * isColourByLabel()), or a colour derived from the feature score (if
   * isGraduatedColour()).
   * 
   * @param feature
   * @return
   */
  @Override
  public ColorI getColor(SequenceFeature feature)
  {
    if (isColourByLabel())
    {
      return new Colour(UserColourScheme.createColourFromName(feature
              .getDescription()));
    }

    if (!isGraduatedColour())
    {
      return getColour();
    }

    // todo should we check for above/below threshold here?
    if (range == 0.0)
    {
      return getMaxColour();
    }
    float scr = feature.getScore();
    if (Float.isNaN(scr))
    {
      return getMinColour();
    }
    float scl = (scr - base) / range;
    if (isHighToLow)
    {
      scl = -scl;
    }
    if (scl < 0f)
    {
      scl = 0f;
    }
    if (scl > 1f)
    {
      scl = 1f;
    }
    return new Colour(new Color(minRed + scl * deltaRed, minGreen + scl
            * deltaGreen, minBlue + scl * deltaBlue));
  }

  /**
   * Returns the maximum score of the graduated colour range
   * 
   * @return
   */
  @Override
  public float getMax()
  {
    // regenerate the original values passed in to the constructor
    return (isHighToLow) ? base : (base + range);
  }

  /**
   * Returns the minimum score of the graduated colour range
   * 
   * @return
   */
  @Override
  public float getMin()
  {
    // regenerate the original value passed in to the constructor
    return (isHighToLow) ? (base + range) : base;
  }

  /**
   * Answers true if the feature has a simple colour, or is coloured by label,
   * or has a graduated colour and the score of this feature instance is within
   * the range to render (if any), i.e. does not lie below or above any
   * threshold set.
   * 
   * @param feature
   * @return
   */
  @Override
  public boolean isColored(SequenceFeature feature)
  {
    if (isColourByLabel() || !isGraduatedColour())
    {
      return true;
    }

    float val = feature.getScore();
    if (Float.isNaN(val))
    {
      return true;
    }
    if (Float.isNaN(this.threshold))
    {
      return true;
    }

    if (isAboveThreshold() && val <= threshold)
    {
      return false;
    }
    if (isBelowThreshold() && val >= threshold)
    {
      return false;
    }
    return true;
  }

  @Override
  public boolean isSimpleColour()
  {
    return (!isColourByLabel() && !isGraduatedColour());
  }

  @Override
  public boolean hasThreshold()
  {
    return isAboveThreshold() || isBelowThreshold();
  }

  @Override
  public String toJalviewFormat(String featureType)
  {
    String colourString = null;
    if (isSimpleColour())
    {
      colourString = Format.getHexString(getColour());
    }
    else
    {
      StringBuilder sb = new StringBuilder(32);
      if (isColourByLabel())
      {
        sb.append("label");
        if (hasThreshold())
        {
          sb.append(BAR).append(BAR).append(BAR);
        }
      }
      if (isGraduatedColour())
      {
        sb.append(Format.getHexString(getMinColour())).append(BAR);
        sb.append(Format.getHexString(getMaxColour())).append(BAR);
        if (isAutoScaled())
        {
          sb.append("abso").append(BAR);
        }
      }
      if (hasThreshold() || isGraduatedColour())
      {
        sb.append(getMin()).append(BAR);
        sb.append(getMax()).append(BAR);
        if (isBelowThreshold())
        {
          sb.append("below").append(BAR).append(getThreshold());
        }
        else if (isAboveThreshold())
        {
          sb.append("above").append(BAR).append(getThreshold());
        }
        else
        {
          sb.append("none");
        }
      }
      colourString = sb.toString();
    }
    return String.format("%s\t%s", featureType, colourString);
  }

}