/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2006 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 jalview.datamodel.*;

import java.awt.*;

import java.util.*;

/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class FeatureRenderer
{
    AlignViewport av;

    Hashtable featureColours = new Hashtable();

    // A higher level for grouping features of a
    // particular type
    Hashtable featureGroups = null;

    // Holds web links for feature groups and feature types
    // in the form label|link
    Hashtable featureLinks = null;


    // This is actually an Integer held in the hashtable,
    // Retrieved using the key feature type
    Object currentColour;

    String [] renderOrder;

    FontMetrics fm;
    int charOffset;

    float transparency = 1f;

    TransparencySetter transparencySetter = null;

    /**
     * Creates a new FeatureRenderer object.
     *
     * @param av DOCUMENT ME!
     */
    public FeatureRenderer(AlignViewport av)
    {
        this.av = av;

        if(!System.getProperty("java.version").startsWith("1.1"))
             transparencySetter = new TransparencySetter();
    }


    public void transferSettings(FeatureRenderer fr)
    {
      renderOrder = fr.renderOrder;
      featureGroups = fr.featureGroups;
      featureColours = fr.featureColours;
      transparency =  fr.transparency;
    }


    public Color findFeatureColour(Color initialCol, SequenceI seq, int i)
    {
      overview = true;
      if(!av.showSequenceFeatures)
        return initialCol;

        lastSequence = seq;
        sequenceFeatures = lastSequence.getSequenceFeatures();
        if(sequenceFeatures==null)
          return initialCol;

        sfSize = sequenceFeatures.length;

      if(jalview.util.Comparison.isGap(lastSequence.getCharAt(i)))
        return Color.white;

      currentColour = null;

      drawSequence(null, lastSequence, lastSequence.findPosition(i), -1,-1);

      if(currentColour==null)
        return initialCol;

      return new Color( ((Integer)currentColour).intValue() );
    }

    /**
     * This is used by the Molecule Viewer to get the accurate colour
     * of the rendered sequence
     */
    boolean overview = false;

    int white = Color.white.getRGB();
    public int findFeatureColour(int initialCol, int seqIndex, int column)
    {
      if(!av.showSequenceFeatures)
        return initialCol;

      if(seqIndex!=lastSequenceIndex)
      {
        lastSequence = av.alignment.getSequenceAt(seqIndex);
        lastSequenceIndex = seqIndex;
        sequenceFeatures = lastSequence.getSequenceFeatures();
        if(sequenceFeatures==null)
          return initialCol;

        sfSize = sequenceFeatures.length;
      }


      if(jalview.util.Comparison.isGap(lastSequence.getCharAt(column)))
        return Color.white.getRGB();

      currentColour = null;

      drawSequence(null, lastSequence, lastSequence.findPosition(column), -1,-1);

      if(currentColour==null)
        return initialCol;

      return  ((Integer)currentColour).intValue();
    }


    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     * @param seq DOCUMENT ME!
     * @param sg DOCUMENT ME!
     * @param start DOCUMENT ME!
     * @param end DOCUMENT ME!
     * @param x1 DOCUMENT ME!
     * @param y1 DOCUMENT ME!
     * @param width DOCUMENT ME!
     * @param height DOCUMENT ME!
     */
   // String type;
   // SequenceFeature sf;
    int lastSequenceIndex=-1;
    SequenceI lastSequence;
    SequenceFeature [] sequenceFeatures;
    int sfSize, sfindex, spos, epos;

    public void drawSequence(Graphics g, SequenceI seq,
                             int start, int end, int y1)
    {
      if (   seq.getSequenceFeatures() == null
          || seq.getSequenceFeatures().length==0)
        return;

      if(transparencySetter!=null && g!=null)
      {
        transparencySetter.setTransparency(g, transparency);
      }

      if (av.featuresDisplayed == null || renderOrder==null)
       {
         findAllFeatures();
         if(av.featuresDisplayed.size()<1)
           return;

         sequenceFeatures = seq.getSequenceFeatures();
         sfSize = sequenceFeatures.length;
       }
       if(lastSequence==null || seq!=lastSequence)
      {
        lastSequence = seq;
        sequenceFeatures = seq.getSequenceFeatures();
        sfSize = sequenceFeatures.length;
      }
      if(!overview)
      {
        spos = lastSequence.findPosition(start);
        epos = lastSequence.findPosition(end);
        if(g!=null)
          fm = g.getFontMetrics();
      }
      String type;
      for(int renderIndex=0; renderIndex<renderOrder.length; renderIndex++)
       {
        type =  renderOrder[renderIndex];
        if(!av.featuresDisplayed.containsKey(type))
          continue;

        // loop through all features in sequence to find
        // current feature to render
        for (sfindex = 0; sfindex < sfSize; sfindex++)
        {
          if (!sequenceFeatures[sfindex].type.equals(type))
            continue;

          if (featureGroups != null
              && sequenceFeatures[sfindex].featureGroup != null
              &&
              featureGroups.containsKey(sequenceFeatures[sfindex].featureGroup)
              &&
              ! ( (Boolean) featureGroups.get(sequenceFeatures[sfindex].featureGroup)).
              booleanValue())
          {
            continue;
          }

          if (!overview && (sequenceFeatures[sfindex].getBegin() > epos
                            || sequenceFeatures[sfindex].getEnd() < spos))
            continue;

          if (overview)
          {
            if (sequenceFeatures[sfindex].begin <= start &&
                sequenceFeatures[sfindex].end >= start)
            {
              currentColour = av.featuresDisplayed.get(sequenceFeatures[sfindex].
                  type);
            }

          }
          else if (sequenceFeatures[sfindex].type.equals("disulfide bond"))
          {

            renderFeature(g, seq,
                          seq.findIndex(sequenceFeatures[sfindex].begin) - 1,
                          seq.findIndex(sequenceFeatures[sfindex].begin) - 1,
                          new Color( ( (Integer) av.featuresDisplayed.get(
                sequenceFeatures[sfindex].type)).intValue()),
                          start, end, y1);
            renderFeature(g, seq,
                          seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                          seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                          new Color( ( (Integer) av.featuresDisplayed.get(
                sequenceFeatures[sfindex].type)).intValue()),
                          start, end, y1);

          }
          else
            renderFeature(g, seq,
                          seq.findIndex(sequenceFeatures[sfindex].begin) - 1,
                          seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                          getColour(sequenceFeatures[sfindex].type),
                          start, end, y1);

        }
      }

      if(transparencySetter!=null && g!=null)
      {
        transparencySetter.setTransparency(g, 1.0f);
      }
    }


    char s;
    int i;
    void renderFeature(Graphics g, SequenceI seq,
                       int fstart, int fend, Color featureColour, int start, int end,  int y1)
    {

      if (((fstart <= end) && (fend >= start)))
      {
        if (fstart < start)
        { // fix for if the feature we have starts before the sequence start,
          fstart = start; // but the feature end is still valid!!
        }

        if (fend >= end)
        {
          fend = end;
        }

          for (i = fstart; i <= fend; i++)
          {
            s = seq.getSequence().charAt(i);

            if (jalview.util.Comparison.isGap(s))
            {
              continue;
            }

            g.setColor(featureColour);

            g.fillRect( (i - start) * av.charWidth, y1, av.charWidth, av.charHeight);

            if(!av.validCharWidth)
              continue;

            g.setColor(Color.white);
            charOffset = (av.charWidth - fm.charWidth(s)) / 2;
            g.drawString(String.valueOf(s),
                         charOffset + (av.charWidth * (i - start)),
                         (y1 + av.charHeight) - av.charHeight / 5); //pady = height / 5;

          }
      }
    }

    void findAllFeatures()
    {
      jalview.schemes.UserColourScheme ucs = new
          jalview.schemes.UserColourScheme();

      av.featuresDisplayed = new Hashtable();
      Vector allfeatures = new Vector();
      for (int i = 0; i < av.alignment.getHeight(); i++)
      {
        SequenceFeature [] features = av.alignment.getSequenceAt(i).getSequenceFeatures();

        if (features == null)
          continue;

        int index = 0;
        while (index < features.length)
        {
          if (!av.featuresDisplayed.containsKey(features[index].getType()))
          {
            if (getColour(features[index].getType()) == null)
            {
              featureColours.put(features[index].getType(),
                                 ucs.createColourFromName(features[index].
                  getType()));
            }


            av.featuresDisplayed.put(features[index].getType(),
                                  new Integer( getColour(features[index].getType()).getRGB()) );
            allfeatures.addElement(features[index].getType());
          }
          index++;
        }
      }

      renderOrder = new String[allfeatures.size()];
      Enumeration en = allfeatures.elements();
      int i = allfeatures.size()-1;
      while(en.hasMoreElements())
      {
        renderOrder[i] = en.nextElement().toString();
        i--;
      }
    }

    public Color getColour(String featureType)
    {
      return (Color)featureColours.get(featureType);
    }

    public void addNewFeature(String name, Color col)
    {

      setColour(name, col);
      if(av.featuresDisplayed==null)
        av.featuresDisplayed = new Hashtable();


      av.featuresDisplayed.put(name, "NOGROUP");
    }

    public void setColour(String featureType, Color col)
    {
      featureColours.put(featureType, col);
    }

    public void setFeaturePriority(Object [][] data)
    {
        // The feature table will display high priority
        // features at the top, but theses are the ones
        // we need to render last, so invert the data
        if(av.featuresDisplayed!=null)
          av.featuresDisplayed.clear();

        renderOrder = new String[data.length];

        if (data.length > 0)
          for (int i = 0; i < data.length; i++)
          {
            String type = data[i][0].toString();
            setColour(type, (Color) data[i][1]);
            if ( ( (Boolean) data[i][2]).booleanValue())
            {
              av.featuresDisplayed.put(type, new Integer(getColour(type).getRGB()));
            }

            renderOrder[data.length - i - 1] = type;
          }
    }
}

  class TransparencySetter
  {
    void setTransparency(Graphics g, float value)
    {
     //Graphics2D g2 = (Graphics2D) g;
    // g2.setComposite(
    //    AlphaComposite.getInstance(
    //         AlphaComposite.SRC_OVER, value));
    }
  }