/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
  Part of the Processing project - http://processing.org

  Copyright (c) 2004-08 Ben Fry and Casey Reas
  Copyright (c) 2001-04 Massachusetts Institute of Technology

  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

package processing.app;
import static processing.app.I18n._;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


/**
 * Find & Replace window for the Processing editor.
 * <p/>
 * One major annoyance in this is that the window is re-created each time
 * that "Find" is called. This is because Mac OS X has a strange focus
 * issue with windows that are re-shown with setVisible() or show().
 * requestFocusInWindow() properly sets the focus to the find field,
 * however, just a short moment later, the focus is set to null. Even
 * trying to catch this scenario and request it again doesn't seem to work.
 * Most likely this is some annoyance buried deep in one of Apple's docs,
 * or in the doc for the focus stuff (I tend to think the former because
 * Windows doesn't seem to be quite so beligerent). Filed as
 * <A HREF="http://dev.processing.org/bugs/show_bug.cgi?id=244"> Bug 244</A>
 * should anyone have clues about how to fix.
 */
public class FindReplace extends JFrame implements ActionListener {

  static final int EDGE = Base.isMacOS() ? 20 : 13;
  static final int SMALL = 6;
  static final int BUTTONGAP = 12; // 12 is correct for Mac, other numbers may be required for other platofrms

  Editor editor;

  JTextField findField;
  JTextField replaceField;
  static String findString;
  static String replaceString;

  JButton replaceButton;
  JButton replaceAllButton;
  JButton replaceFindButton;
  JButton previousButton;
  JButton findButton;

  JCheckBox ignoreCaseBox;
  static boolean ignoreCase = true;

  JCheckBox wrapAroundBox;
  static boolean wrapAround = true;

  public FindReplace(Editor editor) {
    super("Find");
    setResizable(false);
    this.editor = editor;

    Container pain = getContentPane();
    pain.setLayout(null);

    JLabel findLabel = new JLabel(_("Find:"));
    JLabel replaceLabel = new JLabel(_("Replace with:"));
    Dimension labelDimension = replaceLabel.getPreferredSize();

    pain.add(findLabel);
    pain.add(replaceLabel);

    pain.add(findField = new JTextField(20));
    pain.add(replaceField = new JTextField(20));
    int fieldHeight = findField.getPreferredSize().height;

    if (findString != null) findField.setText(findString);
    if (replaceString != null) replaceField.setText(replaceString);
    //System.out.println("setting find str to " + findString);
    //findField.requestFocusInWindow();

    ignoreCaseBox = new JCheckBox(_("Ignore Case"));
    ignoreCaseBox.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          ignoreCase = ignoreCaseBox.isSelected();
        }
      });
    ignoreCaseBox.setSelected(ignoreCase);
    pain.add(ignoreCaseBox);

    wrapAroundBox = new JCheckBox(_("Wrap Around"));
    wrapAroundBox.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          wrapAround = wrapAroundBox.isSelected();
        }
      });
    wrapAroundBox.setSelected(wrapAround);
    pain.add(wrapAroundBox);

    JPanel buttons = new JPanel();
    
    buttons.setLayout(new FlowLayout(FlowLayout.CENTER,BUTTONGAP,0));

    // ordering is different on mac versus pc
    if (Base.isMacOS()) {
      buttons.add(replaceAllButton = new JButton(_("Replace All")));
      buttons.add(replaceButton = new JButton(_("Replace")));
      buttons.add(replaceFindButton = new JButton(_("Replace & Find")));
      buttons.add(previousButton = new JButton(_("Previous")));
      buttons.add(findButton = new JButton(_("Find")));

    } else {
      buttons.add(findButton = new JButton(_("Find")));
      buttons.add(previousButton = new JButton(_("Previous"))); // is this the right position for non-Mac?
      buttons.add(replaceFindButton = new JButton(_("Replace & Find")));
      buttons.add(replaceButton = new JButton(_("Replace")));
      buttons.add(replaceAllButton = new JButton(_("Replace All")));
    }
    pain.add(buttons);

    // to fix ugliness.. normally macosx java 1.3 puts an
    // ugly white border around this object, so turn it off.
    if (Base.isMacOS()) {
      buttons.setBorder(null);
    }

    /*
    findField.addFocusListener(new FocusListener() {
        public void focusGained(FocusEvent e) {
          System.out.println("Focus gained " + e.getOppositeComponent());
        }

        public void focusLost(FocusEvent e) {
          System.out.println("Focus lost "); // + e.getOppositeComponent());
          if (e.getOppositeComponent() == null) {
            requestFocusInWindow();
          }
        }
      });
    */

    Dimension buttonsDimension = buttons.getPreferredSize();
    int visibleButtonWidth = buttonsDimension.width - 2 * BUTTONGAP;
    int fieldWidth = visibleButtonWidth - (labelDimension.width + SMALL);

   // +1 since it's better to tend downwards
    int yoff = (1 + fieldHeight - labelDimension.height) / 2;

    int ypos = EDGE;
    
    int labelWidth = findLabel.getPreferredSize().width;
    findLabel.setBounds(EDGE + (labelDimension.width-labelWidth), ypos + yoff, //  + yoff was added to the wrong field
                        labelWidth, labelDimension.height);
    findField.setBounds(EDGE + labelDimension.width + SMALL, ypos,
                        fieldWidth, fieldHeight);
                        
    ypos += fieldHeight + SMALL;
    
    labelWidth = replaceLabel.getPreferredSize().width;
    replaceLabel.setBounds(EDGE + (labelDimension.width-labelWidth), ypos + yoff,
                           labelWidth, labelDimension.height);
    replaceField.setBounds(EDGE + labelDimension.width + SMALL, ypos,
                           fieldWidth, fieldHeight);

    ypos += fieldHeight + SMALL;

    ignoreCaseBox.setBounds(EDGE + labelDimension.width + SMALL,
                            ypos,
                            (fieldWidth-SMALL)/2, fieldHeight);

    wrapAroundBox.setBounds(EDGE + labelDimension.width + SMALL + (fieldWidth-SMALL)/2 + SMALL,
                            ypos,
                            (fieldWidth-SMALL)/2, fieldHeight);

    ypos += fieldHeight + SMALL;

    buttons.setBounds(EDGE-BUTTONGAP, ypos,
                      buttonsDimension.width, buttonsDimension.height);

    ypos += buttonsDimension.height + EDGE;

//    Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();

    int wide = visibleButtonWidth + EDGE*2;
    int high = ypos; // butt.y + butt.height + EDGE*2 + SMALL;

    pack();
    Insets insets = getInsets();
    //System.out.println("Insets = " + insets);
    setSize(wide + insets.left + insets.right,high + insets.top + insets.bottom); 

    setLocationRelativeTo( null ); // center
 //   setBounds((screen.width - wide) / 2, (screen.height - high) / 2, wide, high);

    replaceButton.addActionListener(this);
    replaceAllButton.addActionListener(this);
    replaceFindButton.addActionListener(this);
    findButton.addActionListener(this);
    previousButton.addActionListener(this);

    // you mustn't replace what you haven't found, my son
    // semantics of replace are "replace the current selection with the replace field"
    // so whether we have found before or not is irrelevent
    // replaceButton.setEnabled(false);
    // replaceFindButton.setEnabled(false);

    // make the find button the blinky default
    getRootPane().setDefaultButton(findButton);

    setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
    addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          handleClose();
        }
      });
    Base.registerWindowCloseKeys(getRootPane(), new ActionListener() {
        public void actionPerformed(ActionEvent actionEvent) {
          //hide();
          handleClose();
        }
      });
    Base.setIcon(this);

    // hack to to get first field to focus properly on osx
    addWindowListener(new WindowAdapter() {
        public void windowActivated(WindowEvent e) {
          //System.out.println("activating");
          /*boolean ok =*/ findField.requestFocusInWindow();
          //System.out.println("got " + ok);
          findField.selectAll();
        }
      });
  }


  public void handleClose() {
    //System.out.println("handling close now");
    findString = findField.getText();
    replaceString = replaceField.getText();

    // this object should eventually become dereferenced
    setVisible(false);
  }


  /*
  public void show() {
    findField.requestFocusInWindow();
    super.show();
    //findField.selectAll();
    //findField.requestFocus();
  }
  */


  public void actionPerformed(ActionEvent e) {
    Object source = e.getSource();

    if (source == findButton) {
      findNext();

    } else if (source == previousButton) {
      findPrevious();

    } else if (source == replaceFindButton) {
      replaceAndFindNext();

    } else if (source == replaceButton) {
      replace();

    } else if (source == replaceAllButton) {
      replaceAll();
    }
  }


  // look for the next instance of the find string to be found
  // once found, select it (and go to that line)

  private boolean find(boolean wrap,boolean backwards ) {

    String search = findField.getText();
    //System.out.println("finding for " + search + " " + findString);
    // this will catch "find next" being called when no search yet
    if (search.length() == 0) return false;

    String text = editor.getText();

    if (ignoreCase) {
      search = search.toLowerCase();
      text = text.toLowerCase();
    }

    int nextIndex;
    if (!backwards) {
      //int selectionStart = editor.textarea.getSelectionStart();
      int selectionEnd = editor.getSelectionStop();

      nextIndex = text.indexOf(search, selectionEnd);
      if (wrap && nextIndex == -1) {
        // if wrapping, a second chance is ok, start from beginning
        nextIndex = text.indexOf(search, 0);
      }
    } else {
      //int selectionStart = editor.textarea.getSelectionStart();
      int selectionStart = editor.getSelectionStart()-1;

      if ( selectionStart >= 0 ) {
        nextIndex = text.lastIndexOf(search, selectionStart);
      } else {
        nextIndex = -1;
      }
      if (wrap && nextIndex == -1) {
        // if wrapping, a second chance is ok, start from the end
        nextIndex = text.lastIndexOf(search);
      }
    }

    if (nextIndex != -1) {
      editor.setSelection(nextIndex, nextIndex + search.length());
    } else {
      //Toolkit.getDefaultToolkit().beep();
    }
    return nextIndex != -1;
  }


  /**
   * Replace the current selection with whatever's in the
   * replacement text field.
   */
  public void replace() {
    editor.setSelectedText(replaceField.getText());
    editor.getSketch().setModified(true);  // TODO is this necessary?
  }

  /**
   * Replace the current selection with whatever's in the
   * replacement text field, and then find the next match
   */
  public void replaceAndFindNext() {
    replace();
    findNext();
  }

  /**
   * Replace everything that matches by doing find and replace
   * alternately until nothing more found.
   */
  public void replaceAll() {
    // move to the beginning
    editor.setSelection(0, 0);

    boolean foundAtLeastOne = false;
    while ( true ) {
      if ( find(false,false) ) {
        foundAtLeastOne = true;
        replace();
     } else {
        break;
      }
    }
    if ( !foundAtLeastOne ) {
      Toolkit.getDefaultToolkit().beep();
    }
  }
  
  public void setFindText( String t ) {
    findField.setText( t );
    findString = t;
  }

  public void findNext() {
    if ( !find( wrapAround, false ) ) {
      Toolkit.getDefaultToolkit().beep();
    }
  }

  public void findPrevious() {
    if ( !find( wrapAround, true ) ) {
      Toolkit.getDefaultToolkit().beep();
    }
  }

}