/*
 * 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.gui;

import jalview.datamodel.*;

import java.awt.*;

import java.util.*;

import java.awt.image.*;


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class FeatureRenderer
{
    AlignViewport av;
    Color resBoxColour;
    float transparency = 1.0f;
    FontMetrics fm;
    int charOffset;

    Hashtable featureColours = new Hashtable();


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

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

    String [] renderOrder;

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

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

    BufferedImage offscreenImage;
    boolean offscreenRender = false;
    public Color findFeatureColour(Color initialCol, SequenceI seq, int res)
    {
      return new Color( findFeatureColour (initialCol.getRGB(),
                        seq, res ));
    }

    /**
     * This is used by the Molecule Viewer and Overview to
     * get the accurate colourof the rendered sequence
     */
    public int findFeatureColour(int initialCol, SequenceI seq, int column)
    {
      if(!av.showSequenceFeatures)
        return initialCol;

      if(seq!=lastSeq)
      {
        lastSeq = seq;
        sequenceFeatures = lastSeq.getDatasetSequence().getSequenceFeatures();
        if(sequenceFeatures==null)
          return initialCol;

        sfSize = sequenceFeatures.length;
      }

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


      //Only bother making an offscreen image if transparency is applied
      if(transparency!=1.0f && offscreenImage==null)
      {
        offscreenImage = new BufferedImage(1,1,BufferedImage.TYPE_INT_ARGB);
      }

      currentColour = null;

      offscreenRender = true;

      if(offscreenImage!=null)
      {
        offscreenImage.setRGB(0,0,initialCol);
        drawSequence(offscreenImage.getGraphics(),
                     lastSeq,
                     column,column,0);

        return offscreenImage.getRGB(0,0);
      }
      else
      {
        drawSequence(null,
                    lastSeq,
                    lastSeq.findPosition(column),
                    -1, -1);

        if (currentColour == null)
          return initialCol;
        else
          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;
    SequenceI lastSeq;
    SequenceFeature [] sequenceFeatures;
    int sfSize, sfindex, spos, epos;

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

      if(g!=null)
        fm = g.getFontMetrics();


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

         sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();
         sfSize = sequenceFeatures.length;
       }

       if(lastSeq==null || seq!=lastSeq)
      {
        lastSeq = seq;
        sequenceFeatures = seq.getDatasetSequence().getSequenceFeatures();
        sfSize = sequenceFeatures.length;
      }


      if (transparency != 1 && g!=null)
      {
        Graphics2D g2 = (Graphics2D) g;
        g2.setComposite(
            AlphaComposite.getInstance(
                AlphaComposite.SRC_OVER, transparency));
      }

      if(!offscreenRender)
      {
        spos = lastSeq.findPosition(start);
        epos = lastSeq.findPosition(end);
      }


      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.length<=sfindex)
          {
            continue;
          }
          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 (!offscreenRender && (sequenceFeatures[sfindex].getBegin() > epos
                            || sequenceFeatures[sfindex].getEnd() < spos))
            continue;

          if (offscreenRender && offscreenImage==null)
          {
            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(transparency!=1.0f && g!=null)
        {
          Graphics2D g2 = (Graphics2D) g;
          g2.setComposite(
              AlphaComposite.getInstance(
                  AlphaComposite.SRC_OVER, 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;
        }
          int pady = (y1 + av.charHeight) - av.charHeight / 5;
          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(offscreenRender || !av.validCharWidth)
              continue;

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

          }
      }
    }


    boolean newFeatureAdded = false;

    public void featuresAdded()
    {
      findAllFeatures();
    }

   boolean findingFeatures = false;
   synchronized void findAllFeatures()
   {
      newFeatureAdded = false;

      if(findingFeatures)
      {
        newFeatureAdded = true;
        return;
      }

      findingFeatures = true;
      jalview.schemes.UserColourScheme ucs = new
          jalview.schemes.UserColourScheme();

      if(av.featuresDisplayed==null)
        av.featuresDisplayed = new Hashtable();

      av.featuresDisplayed.clear();

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

        if (features == null)
          continue;

        int index = 0;
        while (index < features.length)
        {
          if (!av.featuresDisplayed.containsKey(features[index].getType()))
          {
            if(!(features[index].begin == 0 && features[index].end ==0))
            {
              // If beginning and end are 0, the feature is for the whole sequence
              // and we don't want to render the feature in the normal way

              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--;
      }

      findingFeatures = false;
    }

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


    public void addNewFeature(String name, Color col, String group)
    {

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

      if(group == null)
        group = "NOGROUP";

      av.featuresDisplayed.put(name, new Integer(col.getRGB()));
    }

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

    public void setTransparency(float value)
    {
      transparency = value;
    }

    public float getTransparency()
    {
      return transparency;
    }

    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();
      else
        av.featuresDisplayed = new Hashtable();

      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;
        }

    }




}