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

public class FeatureSettings extends JPanel
{
  Vector allFeatures;
  final FeatureRenderer fr;
  final AlignmentPanel ap;
  Object [][] originalData;

  public FeatureSettings(AlignViewport av, final AlignmentPanel ap)
  {
    this.ap = ap;
    fr = ap.seqPanel.seqCanvas.getFeatureRenderer();
    av.alignment.getSequences();
    final JInternalFrame frame = new JInternalFrame();
    frame.setContentPane(this);
    Desktop.addInternalFrame(frame, "Sequence Feature Settings", 500, 300);


    allFeatures = new Vector();
    Vector features;
    Enumeration e;
    SequenceFeature sf;
    for(int i=0; i< av.alignment.getHeight(); i++)
    {
       features = av.alignment.getSequenceAt(i).getSequenceFeatures();
       if(features==null)
         continue;

       e = features.elements();
       while(e.hasMoreElements())
       {
         sf = (SequenceFeature)e.nextElement();
         if(!allFeatures.contains(sf.getType()))
         {
           allFeatures.addElement(sf.getType());
         }
       }
    }
    if(allFeatures.size()<1)
     {
       try{
         frame.setClosed(true);
       }catch(Exception ex){}
       return;
     }

    int fSize = allFeatures.size();

    String type;
    Object [][] data = new Object[fSize][3];
    originalData = new Object[fSize][3];
    for(int i=0; i<fSize; i++)
    {
      type = allFeatures.elementAt(i).toString();
      Color col = fr.getColour(type);
      data[i][0]=type;
      data[i][1]=col;
      data[i][2]= new Boolean(true);
      originalData[i][0]=type;
      originalData[i][1]=col;
      originalData[i][2]= new Boolean(true);
    }

    final JSlider transparency = new JSlider(0,70,0);
    transparency.addChangeListener(new ChangeListener()
        {
          public void stateChanged(ChangeEvent evt)
          {
            fr.setTransparency( (float)(100-transparency.getValue())/100f);
            ap.repaint();
          }
        });

    JPanel transPanel = new JPanel(new FlowLayout());
    transPanel.add(new JLabel("Transparency"));
    transPanel.add(transparency);



    ////////////////////////////////////
    //Now build the table
    final JTable table = new JTable(new FeatureTableModel(data));
    JScrollPane scrollPane = new JScrollPane(table);
    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;
            }
          }
        });

      //////////////////////////////////////////////
      //We're going to need those OK cancel buttons
      JPanel buttonPanel = new JPanel(new FlowLayout());
        JButton button = new JButton("OK");
        button.addActionListener(new ActionListener()
        {
          public void actionPerformed(ActionEvent evt)
          {
            try {
              frame.setClosed(true);
            }
            catch (Exception exe)
            {}
          }
        });
        buttonPanel.add(button);
        button = new JButton("Cancel");
        button.addActionListener(new ActionListener()
        {
          public void actionPerformed(ActionEvent evt)
          {
            try{
              updateFeatureRenderer(originalData);
              frame.setClosed(true);
            }catch(Exception exe){}
          }
        });
        buttonPanel.add(button);


        this.setLayout(new BorderLayout());
        JPanel bigPanel = new JPanel(new BorderLayout());
        bigPanel.add(transPanel, BorderLayout.SOUTH);
        bigPanel.add(scrollPane, BorderLayout.CENTER);

        add(bigPanel, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);

  }

  public void updateFeatureRenderer(Object [][] data)
  {
    fr.setFeaturePriority( data );
    ap.repaint();
  }

  int selectedRow =-1;


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