/*
 * 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.*;
import javax.swing.*;
import javax.swing.JOptionPane;
import java.awt.event.*;


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


    static String lastFeatureAdded;
    static String lastFeatureGroupAdded;
    static String lastDescriptionAdded;

    public boolean createNewFeatures(SequenceI[] sequences,
                                  SequenceFeature [] features)
    {
      return amendFeatures(sequences, features, true);
    }

    int featureIndex = 0;
    boolean amendFeatures(SequenceI[] sequences,
                           final SequenceFeature [] features,
                           boolean newFeatures)
    {
      JPanel bigPanel = new JPanel(new BorderLayout());
      final JComboBox name = new JComboBox();
      final JComboBox source = new JComboBox();
      final JTextArea description = new JTextArea(3,25);
      final JTextField start = new JTextField(6);
      final JTextField end = new JTextField(6);
      final JButton colour = new JButton("     ");
      colour.setMaximumSize(new Dimension(40,10));
      colour.setBackground(new Color(60, 160, 115));
      colour.addActionListener(new ActionListener()
          {
            public void actionPerformed(ActionEvent evt)
            {
              colour.setBackground(
                  JColorChooser.showDialog(Desktop.desktop,
                                           "Select Feature Colour",
                                           colour.getBackground()));
            }
          });

      JPanel panel = new JPanel(new GridLayout(3, 2));
      panel.add(new JLabel("Sequence Feature Name: ",JLabel.RIGHT));
      panel.add(name);
      panel.add(new JLabel("Feature Group: ", JLabel.RIGHT));
      panel.add(source);
      panel.add(new JLabel("Feature Colour: ", JLabel.RIGHT));
      JPanel tmp = new JPanel();
      tmp.add(colour);
      colour.setPreferredSize(new Dimension(150,15));
      panel.add(tmp);
      name.setEditable(true);
      source.setEditable(true);

      bigPanel.add(panel, BorderLayout.NORTH);
      panel = new JPanel();
      panel.add(new JLabel("Description: ", JLabel.RIGHT));
      description.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
      description.setLineWrap(true);
      panel.add(new JScrollPane(description));

      if(!newFeatures)
      {
        bigPanel.add(panel, BorderLayout.SOUTH);

        panel = new JPanel();
        panel.add(new JLabel("Start: ", JLabel.RIGHT));
        panel.add(start);
        panel.add(new JLabel("End: ", JLabel.RIGHT));
        panel.add(end);
        bigPanel.add(panel, BorderLayout.CENTER);
      }
      else
        bigPanel.add(panel, BorderLayout.CENTER);

      if (lastFeatureAdded == null)
        if (features[0].type != null)
          lastFeatureAdded = features[0].type;
        else
          lastFeatureAdded = "feature_1";

      if (lastFeatureGroupAdded == null)
        if (features[0].featureGroup != null)
          lastFeatureGroupAdded = features[0].featureGroup;
        else
          lastFeatureAdded = "Jalview";


      Enumeration en;
      if (featureGroups != null)
      {
        en = featureGroups.keys();
        while (en.hasMoreElements())
        {
          source.addItem(en.nextElement().toString());
        }
      }

      if (newFeatures)
      {
        if(av.featuresDisplayed != null)
        {
          en = av.featuresDisplayed.keys();
          while (en.hasMoreElements())
          {
            name.addItem(en.nextElement().toString());
          }
        }

        name.setSelectedItem(lastFeatureAdded);
        source.setSelectedItem(lastFeatureGroupAdded);
        description.setText(
            lastDescriptionAdded == null ?
            features[0].description : lastDescriptionAdded);
      }
      else if (!newFeatures)
      {
        featureIndex = 0;
        for(int f=0; f<features.length; f++)
        {
          name.addItem(features[f].getType().toString());
        }

        description.setText(features[0].getDescription());
        source.setSelectedItem(features[0].getFeatureGroup());
        start.setText(features[0].getBegin()+"");
        end.setText(features[0].getEnd()+"");
        colour.setBackground(
                getColour(name.getSelectedItem().toString()));
        name.addItemListener(new ItemListener()
        {
          public void itemStateChanged(ItemEvent e)
          {
            int index = name.getSelectedIndex();
            if(index!=-1)
            {
              featureIndex = index;
              description.setText(features[index].getDescription());
              source.setSelectedItem(features[index].getFeatureGroup());
              start.setText(features[index].getBegin() + "");
              end.setText(features[index].getEnd() + "");
              colour.setBackground(
                  getColour(name.getSelectedItem().toString()));
            }
          }
        });

      }


      Object [] options;
      if(!newFeatures)
        options = new Object[]{"Amend", "Delete", "Cancel"};
      else
        options = new Object[]{"OK", "Cancel"};

      int reply = JOptionPane.showInternalOptionDialog(Desktop.desktop,
                                                   bigPanel,
                                                   newFeatures ?
                                                   "Create New Sequence Feature(s)" :
                                                   "Amend/Delete Features",
                                                   JOptionPane.YES_NO_CANCEL_OPTION,
                                                   JOptionPane.QUESTION_MESSAGE,
                                                   null,
                                                   options, null);

      jalview.io.FeaturesFile ffile = new jalview.io.FeaturesFile();

      if (reply == JOptionPane.OK_OPTION
          && name.getSelectedItem() != null
          && source.getSelectedItem() != null)
      {
        lastFeatureAdded = name.getSelectedItem().toString();
        lastFeatureGroupAdded = source.getSelectedItem().toString();
        lastDescriptionAdded = description.getText().replaceAll("\n", " ");
      }

      if(!newFeatures)
      {
        SequenceFeature sf = features[featureIndex];

        if(reply==JOptionPane.NO_OPTION)
          sequences[0].getDatasetSequence().deleteFeature(sf);
        else if(reply==JOptionPane.YES_OPTION)
        {
          sf.type = lastFeatureAdded;
          sf.featureGroup = lastFeatureGroupAdded;
          sf.description = lastDescriptionAdded;
          setColour(sf.type, colour.getBackground());
          try{
            sf.begin = Integer.parseInt( start.getText() );
            sf.end = Integer.parseInt( end.getText() );
          }catch(NumberFormatException ex)
          {}

          ffile.parseDescriptionHTML(sf, false);
        }
      }
      else
      {
        if (reply == JOptionPane.OK_OPTION
            && name.getSelectedItem() != null
            && source.getSelectedItem() != null)
        {
          for (int i = 0; i < sequences.length; i++)
          {
            features[i].type = lastFeatureAdded;
            features[i].featureGroup = lastFeatureGroupAdded;
            features[i].description = lastDescriptionAdded;
            sequences[i].addSequenceFeature(features[i]);
            ffile.parseDescriptionHTML(features[i], false);
          }

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

          if (featureGroups == null)
            featureGroups = new Hashtable();

          featureGroups.put(lastFeatureGroupAdded, new Boolean(true));

          Color col = colour.getBackground();
          setColour(lastFeatureAdded, colour.getBackground());

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

          findAllFeatures();

          return true;
        }
        else
          return false;
      }

      if(name.getSelectedIndex()==-1)
        findAllFeatures();


      return true;
    }

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

    }




}