/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2005 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
 */
/*///////////////////////////////////////////////////////////////////
// This file was taken from java forum
// Re: JFileChooser functioning like normal Windows Apps FileChooser
// Author: ddanimal
// http://forum.java.sun.com/thread.jspa?forumID=57&threadID=327712
*/

//////////////////////////////////////////////////////////////////
package jalview.io;

import java.io.*;
import java.util.*;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.plaf.*;
import javax.swing.plaf.basic.*;
import javax.swing.plaf.metal.*;
import javax.swing.table.*;

public class JalviewFileChooser
    extends JFileChooser
{


  public JalviewFileChooser(String dir, String[] suffix, String[] desc,
                            String selected)
  {
    super(dir);

    JalviewFileFilter chosen = null;

    for (int i = 0; i < suffix.length; i++)
    {
      JalviewFileFilter jvf = new JalviewFileFilter(suffix[i], desc[i]);
      addChoosableFileFilter(jvf);

      if ( (selected != null) && selected.equalsIgnoreCase(desc[i]))
      {
        chosen = jvf;
      }
    }

    if (chosen != null)
    {
      setFileFilter(chosen);
    }

  }


  public void setFileFilter(javax.swing.filechooser.FileFilter filter)
 {
   super.setFileFilter(filter);

   if (!(getUI() instanceof BasicFileChooserUI)) {
           return;
   }

   final BasicFileChooserUI ui = (BasicFileChooserUI) getUI();
   final String name = ui.getFileName().trim();

   if ((name == null) || (name.length() == 0)) {
           return;
   }

   EventQueue.invokeLater(new Thread() {
           public void run() {
                   String currentName = ui.getFileName();
                   if ((currentName == null) || (currentName.length() == 0)) {
                           ui.setFileName(name);
                   }
           }
	});
 }


  public JalviewFileChooser(String dir)
  {
    super(dir);
  }

  public String getSelectedFormat()
  {
    String format = getFileFilter().getDescription();

    if (format.toUpperCase().startsWith("JALVIEW"))
    {
      format = "Jalview";
    }
    else if (format.toUpperCase().startsWith("FASTA"))
    {
      format = "FASTA";
    }
    else if (format.toUpperCase().startsWith("MSF"))
    {
      format = "MSF";
    }
    else if (format.toUpperCase().startsWith("CLUSTAL"))
    {
      format = "CLUSTAL";
    }
    else if (format.toUpperCase().startsWith("BLC"))
    {
      format = "BLC";
    }
    else if (format.toUpperCase().startsWith("PIR"))
    {
      format = "PIR";
    }
    else if (format.toUpperCase().startsWith("PFAM"))
    {
      format = "PFAM";
    }

    return format;
  }

  public int showSaveDialog(Component parent)
      throws HeadlessException
  {
    setDialogType(SAVE_DIALOG);

    int ret = showDialog(parent, null);

    if (getFileFilter() instanceof JalviewFileFilter)
    {
      JalviewFileFilter jvf = (JalviewFileFilter) getFileFilter();

      if (!jvf.accept(getSelectedFile()))
      {
        String withExtension = getSelectedFile() + "." +
            jvf.getAcceptableExtension();
        setSelectedFile(new File(withExtension));
      }
    }

    if ( (ret == JalviewFileChooser.APPROVE_OPTION) &&
        getSelectedFile().exists())
    {
      int confirm = JOptionPane.showConfirmDialog(parent,
                                                  "Overwrite existing file?",
                                                  "File exists",
                                                  JOptionPane.YES_NO_OPTION);

      if (confirm != JOptionPane.YES_OPTION)
      {
        ret = this.CANCEL_OPTION;
      }
    }

    return ret;
  }



  /**************************************************************************
   * Always create the local UI
   * @param comp
   *************************************************************************/
  public final void setUI(ComponentUI comp)
  {
    UI ui = new UI(this);

    super.setUI(ui);
  }

  /**************************************************************************
   * Internal implementation of Metal LookAndFeel to create the table sorting
   * ability.
   *************************************************************************/
  private class UI
      extends MetalFileChooserUI
  {
    private DirectoryModel model;

    /**************************************************************************
     * Must be overridden to extend
     * @param e
     *************************************************************************/
    public UI(JFileChooser e)
    {
      super(e);
      try{
        this.installIcons(e);
      }catch(Exception ex)
      { System.out.println(ex+"\nProblem installing icons, FileChooser");}
    }

    /**************************************************************************
     * Overridden to create our own model
     *************************************************************************/
    protected final void createModel()
    {
      model = new DirectoryModel(getFileChooser());
    }

    /**************************************************************************
     * Overridden to get our own model
     * @return
     *************************************************************************/
    public final BasicDirectoryModel getModel()
    {
      return model;
    }

    /**************************************************************************
     * Calls the default method then adds a MouseListener to the JTable
     * @param chooser
     * @return
     *************************************************************************/
    protected final JPanel createDetailsView(JFileChooser chooser)
    {
      final JPanel panel = super.createDetailsView(chooser);

      //Since we can't access MetalFileChooserUI's private member detailsTable
      //directly, we have to find it in the JPanel
      final JTable tbl = findJTable(panel.getComponents());

      if (tbl != null)
      {
        //Add a mouselistener to listen for presses on column headers
        tbl.getTableHeader().addMouseListener(new MouseAdapter()
        {
          public void mousePressed(MouseEvent e)
          {

            e.consume();

            final int col = tbl.getTableHeader().columnAtPoint(e.getPoint());
            model.sort(col, tbl);

          }
        });
      }

      return panel;
    }

    /**************************************************************************
     * Finds the JTable in the panel so we can add MouseListener
     * @param comp
     * @return
     *************************************************************************/
    private JTable findJTable(Component[] comp)
    {
      for (int i = 0; i < comp.length; i++)
      {
        if (comp[i] instanceof JTable)
        {
          return (JTable) comp[i];
        }

        if (comp[i] instanceof Container)
        {
          JTable tbl = findJTable( ( (Container) comp[i]).getComponents());

          if (tbl != null)
          {
            return tbl;
          }
        }
      }

      return null;
    }
  }

  /***************************************************************************
   * Implementation of BasicDirectoryModel that sorts the Files by column
   **************************************************************************/
  private final  class DirectoryModel
      extends BasicDirectoryModel
  {
    String sortingColumnName=null;
    int col = 0;
    boolean ascending;

    /**************************************************************************
     * Must be overridden to extend BasicDirectoryModel
     * @param chooser
     *************************************************************************/
    DirectoryModel(JFileChooser chooser)
    {
      super(chooser);
    }


    /**************************************************************************
     * Resorts the JFileChooser table based on new column
     * @param c
     *************************************************************************/
    protected final void sort(int c, JTable tbl)
    {


      //Set column and order
      col = c;
      ascending = !ascending;

      String indicator = " (^)";

      if (ascending)
      {
        indicator = " (v)";
      }

      final JTableHeader th = tbl.getTableHeader();
      final TableColumnModel tcm = th.getColumnModel();
      TableColumn tc = null;
      String title = null;


      //Remove indicator from old sort, and add to new
      for(int i=0; i<tcm.getColumnCount(); i++)
      {
        tc = tcm.getColumn(i);
        title = tc.getHeaderValue().toString();
        if (title.endsWith(" (^)") || title.endsWith(" (v)"))
        {
          title = title.substring(0, title.length() - 4);
        }

        if(i==col)
        {
          sortingColumnName = title;
          title = title + indicator;
        }

        tc.setHeaderValue(title);
      }

      //Requery the file listing
      validateFileCache();
    }

    /**************************************************************************
     * Sorts the data based on current column setting
     * @param data
     *************************************************************************/
    protected final void sort(Vector data)
    {
        /*
                        UIManager.getString("FileChooser.fileTypeHeaderText", l),
                        UIManager.getString("FileChooser.fileAttrHeaderText", l)
*/
    if(sortingColumnName==null)
      return;


    if(sortingColumnName.equals(UIManager.getString("FileChooser.fileDateHeaderText")))
    {
      Collections.sort(data,
                           new Comparator()
          {

            public int compare(Object o1, Object o2)
            {
              int ret = 1;
              final File a = (File) o1;
              final File b = (File) o2;

              if (a.lastModified() > b.lastModified())
              {
                ret = -1;
              }
              else if (a.lastModified() == b.lastModified())
              {
                ret = 0;
              }

              if (ascending)
              {
                ret *= -1;
              }

              return ret;
            }
          });
    }
    else if(sortingColumnName.equals(UIManager.getString("FileChooser.fileSizeHeaderText")))
    {

         Collections.sort(data,
                           new Comparator()
          {

            public int compare(Object o1, Object o2)
            {
              int ret = 1;
              final File a = (File) o1;
              final File b = (File) o2;

              if (a.length() > b.length())
              {
                ret = -1;
              }
              else if (a.length() == b.length())
              {
                ret = 0;
              }

              if (ascending)
              {
                ret *= -1;
              }

              return ret;
            }
          });
    }
    else if(sortingColumnName.equals(UIManager.getString("FileChooser.fileTypeHeaderText")))
    {
          Collections.sort(data,
                           new Comparator()
          {
            public int compare(Object o1, Object o2)
            {
              final String a = getFileSystemView().getSystemTypeDescription( (File)o1 );
              final String b = getFileSystemView().getSystemTypeDescription( (File)o2 );
              if (ascending)
              {
                return a.compareToIgnoreCase(b);
              }
              else
              {
                return -1 * a.compareToIgnoreCase(b);
              }
            }
          });
      }
      else if(sortingColumnName.equals(UIManager.getString("FileChooser.fileNameHeaderText")))
{
      Collections.sort(data,
                       new Comparator()
      {
        public int compare(Object o1, Object o2)
        {
          final String a = ((File) o1).getName();
          final String b = ((File) o2).getName();

          if (ascending)
          {
            return a.compareToIgnoreCase(b);
          }
          else
          {
            return -1 * a.compareToIgnoreCase(b);
          }
        }
      });
  }

    }
  }
}