/*
 * 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 javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.util.*;
import javax.swing.BorderFactory;
import java.awt.event.*;
import javax.swing.table.*;
import java.io.*;
import jalview.io.JalviewFileChooser;
import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.Color;

public class FeatureSettings extends JPanel
{
  DasSourceBrowser dassourceBrowser;
  jalview.io.DasSequenceFeatureFetcher dasFeatureFetcher;
  JPanel settingsPane = new JPanel();
  JPanel dasSettingsPane = new JPanel();

  final FeatureRenderer fr;
  public final AlignFrame af;
  Object [][] originalData;
  final JInternalFrame frame;
  JScrollPane scrollPane = new JScrollPane();
  JTable table;
  JPanel groupPanel;
  JSlider transparency = new JSlider();

  JPanel transPanel = new JPanel(new FlowLayout());

  public FeatureSettings(AlignFrame af)
  {
    this.af = af;
    fr = af.getFeatureRenderer();

    transparency.setMaximum( 100 - (int)(fr.transparency*100) ) ;

   try
   {
     jbInit();
   }
   catch (Exception ex)
   {
     ex.printStackTrace();
   }

   table = new JTable();
   table.getTableHeader().setFont(new Font("Verdana", Font.PLAIN, 12));
   table.setFont(new Font("Verdana", Font.PLAIN, 12));
   table.setDefaultRenderer(Color.class,
                            new ColorRenderer());

   table.setDefaultEditor(Color.class,
                          new ColorEditor());

   table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

   table.addMouseListener(new MouseAdapter()
   {
     public void mousePressed(MouseEvent evt)
     {
       selectedRow = table.rowAtPoint(evt.getPoint());
     }
   });

   table.addMouseMotionListener(new MouseMotionAdapter()
   {
     public void mouseDragged(MouseEvent evt)
     {
       int newRow = table.rowAtPoint(evt.getPoint());
       if (newRow != selectedRow
           && selectedRow != -1
           && newRow != -1)
       {
         Object[] temp = new Object[3];
         temp[0] = table.getValueAt(selectedRow, 0);
         temp[1] = table.getValueAt(selectedRow, 1);
         temp[2] = table.getValueAt(selectedRow, 2);

         table.setValueAt(table.getValueAt(newRow, 0), selectedRow, 0);
         table.setValueAt(table.getValueAt(newRow, 1), selectedRow, 1);
         table.setValueAt(table.getValueAt(newRow, 2), selectedRow, 2);

         table.setValueAt(temp[0], newRow, 0);
         table.setValueAt(temp[1], newRow, 1);
         table.setValueAt(temp[2], newRow, 2);

         selectedRow = newRow;
       }
     }
   });

   scrollPane.setViewportView(table);

    dassourceBrowser = new DasSourceBrowser();
    dasSettingsPane.add(dassourceBrowser, BorderLayout.CENTER);



    if (af.getViewport().featuresDisplayed == null || fr.renderOrder==null)
       fr.findAllFeatures();

    setTableData();

    frame = new JInternalFrame();
    frame.setContentPane(this);
    Desktop.addInternalFrame(frame, "Sequence Feature Settings", 400, 450);
    frame.setLayer(JLayeredPane.PALETTE_LAYER);
  }

  synchronized public void setTableData()
  {
    if (fr.featureGroups == null)
      fr.featureGroups = new Hashtable();

    Vector allFeatures = new Vector();
    Vector allGroups = new Vector();
    SequenceFeature[] tmpfeatures;
    String group;

    for (int i = 0; i < af.getViewport().alignment.getHeight(); i++)
    {
      if (af.getViewport().alignment.getSequenceAt(i).getDatasetSequence().getSequenceFeatures() == null)
        continue;

      tmpfeatures = af.getViewport().alignment.getSequenceAt(i).getDatasetSequence().getSequenceFeatures();

      int index = 0;
      while (index < tmpfeatures.length)
      {
        if(tmpfeatures[index].begin == 0 && tmpfeatures[index].end ==0)
        {
          index++;
          continue;
        }

        if(tmpfeatures[index].getFeatureGroup()!=null)
        {
          group = tmpfeatures[index].featureGroup;
          if(!allGroups.contains(group))
           {
             allGroups.addElement(group);

             boolean visible = true;
             if (fr.featureGroups.containsKey(group))
             {
               visible = ( (Boolean) fr.featureGroups.get(group)).booleanValue();
             }

               if (groupPanel == null)
               {
                 groupPanel = new JPanel();
               }

               boolean alreadyAdded = false;
               for(int g=0; g<groupPanel.getComponentCount(); g++)
               {
                 if(((JCheckBox)groupPanel.getComponent(g))
                    .getText().equals(group))
                 {
                   alreadyAdded = true;
                   break;
                 }
               }

               if(alreadyAdded)
                 continue;

               fr.featureGroups.put(group, new Boolean(visible));

               final JCheckBox check = new JCheckBox(group, visible);
               check.setFont(new Font("Serif", Font.BOLD, 12));
               check.addItemListener(new ItemListener()
               {
                 public void itemStateChanged(ItemEvent evt)
                 {
                   fr.featureGroups.put(check.getText(),
                                        new Boolean(check.isSelected()));
                   af.alignPanel.seqPanel.seqCanvas.repaint();
                   if (af.alignPanel.overviewPanel != null)
                     af.alignPanel.overviewPanel.updateOverviewImage();

                   resetTable(true);
                 }
               });
               groupPanel.add(check);
             }
       }

       if (!allFeatures.contains(tmpfeatures[index].getType()))
       {
           allFeatures.addElement(tmpfeatures[index].getType());
       }
       index ++;
    }
  }

     resetTable(false);

     validate();
  }


  void resetTable(boolean groupsChanged)
  {
   SequenceFeature [] tmpfeatures;
   String group=null, type;
   Vector visibleChecks = new Vector();

   //Find out which features should be visible depending on which groups
   //are selected / deselected
    for (int i = 0; i < af.getViewport().alignment.getHeight(); i++)
    {

        tmpfeatures = af.getViewport().alignment.getSequenceAt(i).getDatasetSequence().getSequenceFeatures();
        if (tmpfeatures == null)
          continue;

        int index = 0;
        while (index < tmpfeatures.length)
        {
          group = tmpfeatures[index].featureGroup;

          if(tmpfeatures[index].begin==0 && tmpfeatures[index].end==0)
          {
            index ++;
            continue;
          }

          if (group==null || fr.featureGroups.get(group)==null ||
              ((Boolean) fr.featureGroups.get(group)).booleanValue())
          {
            type = tmpfeatures[index].getType();
            if(!visibleChecks.contains(type) )
            {
              visibleChecks.addElement(type);
            }
          }
          index++;
        }
    }

    int fSize = visibleChecks.size();
    Object [][] data = new Object[fSize][3];
    int dataIndex = 0;

    if(fr.renderOrder!=null)
    {
      //First add the checks in the previous render order,
      //in case the window has been closed and reopened
      for(int ro=fr.renderOrder.length-1; ro>-1; ro--)
      {
           type = fr.renderOrder[ro];

           if(!visibleChecks.contains(type))
             continue;

           data[dataIndex][0] = type;
           data[dataIndex][1] = fr.getColour(type);
           data[dataIndex][2] = new Boolean(af.getViewport().featuresDisplayed.containsKey(type));
           dataIndex++;
           visibleChecks.removeElement(type);
      }
    }

    fSize = visibleChecks.size();
    for(int i=0; i<fSize; i++)
    {
      //These must be extra features belonging to the group
      //which was just selected
      type = visibleChecks.elementAt(i).toString();
      data[dataIndex][0] = type;

      data[dataIndex][1] = fr.getColour(type);
      if (data[dataIndex][1] == null)
      {
        //"Colour has been updated in another view!!"
        fr.renderOrder = null;
        return;
      }

      data[dataIndex][2] = new Boolean(true);
      dataIndex++;
    }

    if(originalData==null)
    {
      originalData = new Object[data.length][3];
      System.arraycopy(data,0,originalData,0,data.length);
    }

    table.setModel(new FeatureTableModel(data));
    table.getColumnModel().getColumn(0).setPreferredWidth(200);


    if (groupPanel != null)
    {
      groupPanel.setLayout(
          new GridLayout(fr.featureGroups.size() / 4 + 1, 4));

      groupPanel.validate();
      bigPanel.add(groupPanel, BorderLayout.NORTH);
    }

    updateFeatureRenderer(data);

  }

  void load()
  {
    JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.getProperty(
                 "LAST_DIRECTORY"), new String[] { "fc" },
             new String[] { "Sequence Feature Colours" }, "Sequence Feature Colours");
     chooser.setFileView(new jalview.io.JalviewFileView());
     chooser.setDialogTitle("Load Feature Colours");
     chooser.setToolTipText("Load");

     int value = chooser.showOpenDialog(this);

     if (value == JalviewFileChooser.APPROVE_OPTION)
     {
       File file = chooser.getSelectedFile();

       try
       {
         InputStreamReader in = new InputStreamReader(new FileInputStream(
             file), "UTF-8");

         jalview.binding.JalviewUserColours jucs = new jalview.binding.
             JalviewUserColours();
         jucs = (jalview.binding.JalviewUserColours) jucs.unmarshal(in);


         for (int i = 0; i < jucs.getColourCount(); i++)
         {
           fr.setColour( jucs.getColour(i).getName(),
                          new Color(Integer.parseInt( jucs.getColour(i).getRGB(), 16)));
         }

         setTableData();
         af.alignPanel.repaint();
       }
       catch (Exception ex)
       {
         System.out.println("Error loading User Colour File\n" + ex);
       }
     }
  }

  void save()
  {
    JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.getProperty(
                "LAST_DIRECTORY"), new String[] { "fc" },
            new String[] { "Sequence Feature Colours" }, "Sequence Feature Colours");
    chooser.setFileView(new jalview.io.JalviewFileView());
    chooser.setDialogTitle("Save Feature Colour Scheme");
    chooser.setToolTipText("Save");

    int value = chooser.showSaveDialog(this);

    if (value == JalviewFileChooser.APPROVE_OPTION)
    {
        String choice = chooser.getSelectedFile().getPath();
        jalview.binding.JalviewUserColours ucs = new jalview.binding.JalviewUserColours();
        ucs.setSchemeName("Sequence Features");
        try
        {
            PrintWriter out = new PrintWriter(new OutputStreamWriter(
                        new FileOutputStream(choice), "UTF-8"));

            Enumeration e = fr.featureColours.keys();
           while(e.hasMoreElements())
           {
                jalview.binding.Colour col = new jalview.binding.Colour();
                col.setName(e.nextElement().toString());
                col.setRGB(jalview.util.Format.getHexString(
                        fr.getColour(col.getName())));
                ucs.addColour(col);
            }

            ucs.marshal(out);
            out.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
  }

  public void invertSelection()
  {
    for(int i=0; i<table.getRowCount(); i++)
    {
      Boolean value = (Boolean)table.getValueAt(i,2);

      table.setValueAt(
          new Boolean(!value.booleanValue()),
                       i,2);
    }
  }

  public void close()
  {
    try
    {
      frame.setClosed(true);
    }
    catch (Exception exe)
    {}

  }

  public void updateFeatureRenderer(Object [][] data)
  {
    fr.setFeaturePriority( data );
    af.alignPanel.repaint();

    if(af.alignPanel.overviewPanel!=null)
      af.alignPanel.overviewPanel.updateOverviewImage();
  }

  int selectedRow =-1;
  JTabbedPane tabbedPane = new JTabbedPane();
  BorderLayout borderLayout1 = new BorderLayout();
  BorderLayout borderLayout2 = new BorderLayout();
  BorderLayout borderLayout3 = new BorderLayout();
  JPanel bigPanel = new JPanel();
  BorderLayout borderLayout4 = new BorderLayout();
  JButton invert = new JButton();
  JPanel buttonPanel = new JPanel();
  JButton cancel = new JButton();
  JButton ok = new JButton();
  JButton loadColours = new JButton();
  JButton saveColours = new JButton();
  JPanel dasButtonPanel = new JPanel();
  JButton fetchDAS = new JButton();
  JButton saveDAS = new JButton();
  JButton cancelDAS = new JButton();
  private void jbInit()
      throws Exception
  {
    this.setLayout(borderLayout1);
    settingsPane.setLayout(borderLayout2);
    dasSettingsPane.setLayout(borderLayout3);
    bigPanel.setLayout(borderLayout4);
    invert.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
    invert.setText("Invert Selection");
    invert.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        invertSelection();
      }
    });
    cancel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
    cancel.setText("Cancel");
    cancel.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
          updateFeatureRenderer(originalData);
          close();
      }
    });
    ok.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
    ok.setText("OK");
    ok.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        close();
      }
    });
    loadColours.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
    loadColours.setText("Load Colours");
    loadColours.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        load();
      }
    });
    saveColours.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
    saveColours.setText("Save Colours");
    saveColours.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        save();
      }
    });
    transparency.addChangeListener(new ChangeListener()
    {
      public void stateChanged(ChangeEvent evt)
      {
        fr.setTransparency( (float) (100 - transparency.getValue()) / 100f);
        af.alignPanel.repaint();
      }
    });


    transparency.setMaximum(70);
    fetchDAS.setText("Fetch DAS Features");
    fetchDAS.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        fetchDAS_actionPerformed(e);
      }
    });
    saveDAS.setText("Save as default");
    saveDAS.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        saveDAS_actionPerformed(e);
      }
    });
    dasButtonPanel.setBorder(BorderFactory.createEtchedBorder());
    dasSettingsPane.setBorder(null);
    cancelDAS.setEnabled(false);
    cancelDAS.setText("Cancel Fetch");
    cancelDAS.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        cancelDAS_actionPerformed(e);
      }
    });
    this.add(tabbedPane, java.awt.BorderLayout.CENTER);
    tabbedPane.addTab("Feature Settings", settingsPane );
    tabbedPane.addTab("DAS Settings", dasSettingsPane);
    bigPanel.add(transPanel, java.awt.BorderLayout.SOUTH);
    transPanel.add(transparency);
    transPanel.add(invert);
    buttonPanel.add(ok);
    buttonPanel.add(cancel);
    buttonPanel.add(loadColours);
    buttonPanel.add(saveColours);
    bigPanel.add(scrollPane, java.awt.BorderLayout.CENTER);
    dasSettingsPane.add(dasButtonPanel, java.awt.BorderLayout.SOUTH);
    dasButtonPanel.add(fetchDAS);
    dasButtonPanel.add(cancelDAS);
    dasButtonPanel.add(saveDAS);
    settingsPane.add(bigPanel, java.awt.BorderLayout.CENTER);
    settingsPane.add(buttonPanel, java.awt.BorderLayout.SOUTH);
  }

  public void fetchDAS_actionPerformed(ActionEvent e)
  {
    fetchDAS.setEnabled(false);
    cancelDAS.setEnabled(true);
    Vector selectedSources = dassourceBrowser.getSelectedSources();

    SequenceI [] dataset, seqs ;
    int iSize;

    if(af.getViewport().getSelectionGroup()!=null
      && af.getViewport().getSelectionGroup().getSize()>0)
    {
      iSize = af.getViewport().getSelectionGroup().getSize();
      dataset = new SequenceI[iSize];
      seqs = af.getViewport().getSelectionGroup().
          getSequencesInOrder(
              af.getViewport().getAlignment());
    }
    else
    {
       iSize = af.getViewport().getAlignment().getHeight();
       seqs = af.getViewport().getAlignment().getSequencesArray();
    }

    dataset = new SequenceI[iSize];
    for (int i = 0; i < iSize; i++)
    {
      dataset[i] = seqs[i].getDatasetSequence();
    }

    dasFeatureFetcher =
        new jalview.io.DasSequenceFeatureFetcher(
        dataset,
        this,
        selectedSources);

    af.getViewport().setShowSequenceFeatures(true);
    af.showSeqFeatures.setSelected(true);
  }

  public void saveDAS_actionPerformed(ActionEvent e)
  {
    dassourceBrowser.saveProperties(jalview.bin.Cache.applicationProperties);
  }

  public void complete()
  {
    fetchDAS.setEnabled(true);
    cancelDAS.setEnabled(false);
  }

  public void cancelDAS_actionPerformed(ActionEvent e)
  {
    dasFeatureFetcher.cancel();
    fetchDAS.setEnabled(true);
    cancelDAS.setEnabled(false);
  }

  /////////////////////////////////////////////////////////////////////////
  // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
  /////////////////////////////////////////////////////////////////////////
  class FeatureTableModel
      extends AbstractTableModel
  {
    FeatureTableModel(Object[][] data)
    {
      this.data = data;
    }

    private String[] columnNames = {"Feature Type", "Colour","Display"};
          private Object[][] data;

          public Object[][] getData()
          {
            return data;
          }

          public void setData(Object[][] data)
          {
            this.data = data;
          }

          public int getColumnCount() {
              return columnNames.length;
          }

          public Object[] getRow(int row)
          {
            return data[row];
          }

          public int getRowCount() {
              return data.length;
          }

          public String getColumnName(int col) {
              return columnNames[col];
          }

          public Object getValueAt(int row, int col) {
              return data[row][col];
          }

          public Class getColumnClass(int c) {
              return getValueAt(0, c).getClass();
          }

          public boolean isCellEditable(int row, int col) {
              return col==0 ? false:true;
          }

          public void setValueAt(Object value, int row, int col) {
              data[row][col] = value;
              fireTableCellUpdated(row, col);
              updateFeatureRenderer(data);
          }

    }
    class ColorRenderer extends JLabel
                              implements TableCellRenderer {
       javax.swing.border.Border unselectedBorder = null;
       javax.swing.border.Border selectedBorder = null;

       public ColorRenderer() {
           setOpaque(true); //MUST do this for background to show up.
       }

       public Component getTableCellRendererComponent(
                               JTable table, Object color,
                               boolean isSelected, boolean hasFocus,
                               int row, int column) {
           Color newColor = (Color)color;
           setBackground(newColor);
               if (isSelected) {
                   if (selectedBorder == null) {
                       selectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
                                                 table.getSelectionBackground());
                   }
                   setBorder(selectedBorder);
               } else {
                   if (unselectedBorder == null) {
                       unselectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
                                                 table.getBackground());
                   }
                   setBorder(unselectedBorder);
               }

           setToolTipText("RGB value: " + newColor.getRed() + ", "
                                        + newColor.getGreen() + ", "
                                        + newColor.getBlue());
           return this;
       }
   }
}

 class ColorEditor extends AbstractCellEditor
                          implements TableCellEditor,
                                     ActionListener {
     Color currentColor;
     JButton button;
     JColorChooser colorChooser;
     JDialog dialog;
     protected static final String EDIT = "edit";

     public ColorEditor() {
         //Set up the editor (from the table's point of view),
         //which is a button.
         //This button brings up the color chooser dialog,
         //which is the editor from the user's point of view.
         button = new JButton();
         button.setActionCommand(EDIT);
         button.addActionListener(this);
         button.setBorderPainted(false);
         //Set up the dialog that the button brings up.
         colorChooser = new JColorChooser();
         dialog = JColorChooser.createDialog(button,
                                         "Select new Colour",
                                         true,  //modal
                                         colorChooser,
                                         this,  //OK button handler
                                         null); //no CANCEL button handler
     }

     /**
      * Handles events from the editor button and from
      * the dialog's OK button.
      */
     public void actionPerformed(ActionEvent e) {

          if (EDIT.equals(e.getActionCommand())) {
             //The user has clicked the cell, so
             //bring up the dialog.
             button.setBackground(currentColor);
             colorChooser.setColor(currentColor);
             dialog.setVisible(true);

             //Make the renderer reappear.
             fireEditingStopped();

         } else { //User pressed dialog's "OK" button.
             currentColor = colorChooser.getColor();
         }
     }

     //Implement the one CellEditor method that AbstractCellEditor doesn't.
     public Object getCellEditorValue() {
         return currentColor;
     }

     //Implement the one method defined by TableCellEditor.
     public Component getTableCellEditorComponent(JTable table,
                                                  Object value,
                                                  boolean isSelected,
                                                  int row,
                                                  int column) {
         currentColor = (Color)value;
         return button;
     }
}