/*
 * Please feel free to use any fragment of the code in this file that you need in your own
 * work. As far as I am concerned, it's in the public domain. No permission is necessary
 * or required. Credit is always appreciated if you use a large chunk or base a
 * significant product on one of my examples, but that's not required either.
 * 
 * This code 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.
 * 
 * --- Joseph A. Huwaldt
 */
package jahuwaldt.swing;

import java.awt.*;
import java.awt.desktop.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.URI;
import java.util.*;
import java.util.List;
import static java.util.Objects.*;
import javax.swing.*;


/**
 * This class defines a MacOS friendly application instance. It is a replacement for
 * Steve Roy's excellent MRJAdapter package of old that adds Window Menu support and other
 * features used by Multi-Document-Interface (MDI) applications. Under MacOS, an
 * application instance will automatically call "handleNew()" method if the user brings
 * the application forward and there are no open window's registered. On non-Mac
 * platforms, the application will quit once the last document window has been closed.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt, Date: April 25, 2004
 * @version February 22, 2025
 */
public class MDIApplication {

    /**
     * The application instance.
     */
    private static MDIApplication instance;
    
        /**
         * The name of the application.
         */
        private String name;
    
    /**
     * A reference to the AWT Desktop.
     */
    private static Desktop desktop;
    
    static {
        if (Desktop.isDesktopSupported())
            desktop = Desktop.getDesktop();
    }
    
        /**
         * The frameless menu bar that we have set.
         */
        private static JMenuBar framelessMenuBar;
    
    /**
     * A list of all open document windows.
     */
    private static final Stack<Window> openWindows = new Stack();

    /**
     * A list of references to JMenu objects used to hold "Windows" menus.
     */
    private static final ArrayList<JMenu> windowsMenus = new ArrayList();

    /**
     * A list of objects that want to be notified if the application is going to quit.
     */
    private static final List<QuitListener> quitList = new ArrayList();

    /**
     * The resource bundle for this application.
     */
    private static ResourceBundle resBundle = null;

    /**
     * The user preferences for this application.
     */
    private static Preferences prefs = null;

    /**
     * The filename filter for this application.
     */
    private static FilenameFilter fnFilter = null;

    /**
     * Flag indicating if the application should quit when the last window is closed.
     */
    private static boolean quitOnClose = !AppUtilities.isMacOS();
    
    private QuitJMenuItem quitJMenuItem = null;
    private AboutJMenuItem aboutJMenuItem = null;
    private PreferencesJMenuItem prefsJMenuItem = null;
    
    private static AboutHandler aboutHdlr = null;
    private static PreferencesHandler prefsHdlr = null;
    

    //-------------------------------------------------------------------------
    /**
     * Constructor a new MDIApplication instance with no name. Note that only one can ever
     * be created. Attempting to instantiate more will result in an
     * <code>IllegalStateException</code> being thrown.
     */
    protected MDIApplication(String name) {
        if (nonNull(instance))
            throw new IllegalStateException();
        instance = this;
        
        // Set the application name.
        if (nonNull(name))
                setName(name);
        
        //  Handle "Application ReOpen Event" by bringing a window forward or by creating a
        //  new blank document window if there are no currently open windows.
        desktop.addAppEventListener(new AppReopenedListener() {
            @Override
            public void appReopened(AppReopenedEvent e) {
                // If a window exists, bring it to the front, otherwise create a new document window.
                if (!openWindows.empty()) {
                    Window window = openWindows.peek();
                    window.setVisible(true);

                } else {
                    //  Create a new blank document window for this application.
                    handleNew(null);
                }
            }
        });

    }

        /**
         * Get the unique application instance. If it doesn't exist,
         * this method creates it.
         * @return the unique application instance
         */
        public static synchronized MDIApplication getInstance() {
                if (isNull(instance))
                        new MDIApplication(null);
                return instance;
        }
        
     //-------------------------------------------------------------------------
        /**
         * Set the name of the application.
         * @param appName the name of the application
         */
        public final void setName(String appName) {
                name = appName;
        }
        
        /**
         * Get the name of the application.
         * @return the name of the application
         */
        public String getName() {
                if (isNull(name))
                        name = "";
                return name;
        }
        
        /**
         * Set the Swing frameless menu bar. This menu bar is shown when
         * no frame is visible. This state is normal for a Mac application
         * Note that this method won't have any visual effect if the application
     * is running on platforms other than MacOS. This method sets
         * the menu bar internally so that it will be properly returned by
         * a subsequent call to <code>getFramelessMenuBar()</code>.
         *
         * @param menuBar The Swing menu bar to use as frameless menu bar.
         */
        public static void setFramelessJMenuBar(JMenuBar menuBar) {
                if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.APP_MENU_BAR)) {
            desktop.setDefaultMenuBar(menuBar);
        }
        framelessMenuBar = menuBar;
        }

        /**
         * Get the Swing frameless menu bar. This method is functional on
         * all platforms.
         *
         * @return the Swing frameless menu bar or null if it hasn't been set.
         */
        public static JMenuBar getFramelessJMenuBar() {
                return framelessMenuBar;
        }

    /**
     * Used to set the resource bundle for this application. This is provided as a
     * convenience for storing the resource bundle so that it is accessible throughout an
     * application.
     *
     * @param bundle The resource bundle to be stored with this application.
     */
    public static void setResourceBundle(ResourceBundle bundle) {
        resBundle = bundle;
    }

    /**
     * Returns the resource bundle stored with this application. If no resource bundle has
     * been stored, then null is returned.
     *
     * @return The resource bundle stored with this application.
     */
    public ResourceBundle getResourceBundle() {
        return resBundle;
    }

    /**
     * Used to set the user preferences for this application. This is provided as a
     * convenience for storing the preferences so that it is accessible throughout an
     * application.
     *
     * @param appPrefs The user preferences for this application.
     */
    public static final void setPreferences(Preferences appPrefs) {
        prefs = appPrefs;
    }

    /**
     * @return a reference to the user preferences for this application.
     */
    public final Preferences getPreferences() {
        return prefs;
    }

    /**
     * Installs a handler to show a custom Preference window for your application.
     *
     * @param preferencesHandler The handler to respond to the
     *                     PreferencesHandler.handlePreferences(PreferencesEvent) message.
     * @throws SecurityException if a security manager exists and it denies the
     * RuntimePermission("canProcessApplicationEvents") permission
     * @throws UnsupportedOperationException if the current platform does not support the
     * Desktop.Action.APP_ABOUT action.
     */
    public static void setPreferencesHandler(PreferencesHandler preferencesHandler) {
        prefsHdlr = preferencesHandler;
        if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.APP_ABOUT))
            desktop.setPreferencesHandler(prefsHdlr);
    }
    
        /**
         * Get the About item as a Swing menu item. This item will automatically have the correct
     * text and will have an ActionListener registered that will call the registered AboutHandler
     * if the ActionEvent is triggered.
     * 
         * @return the About Swing menu item
         */
        public PreferencesJMenuItem getPreferencesJMenuItem() {
                return getPreferencesJMenuItem("Preferences");
        }
        
        /**
         * Get the About item as a Swing menu item. This item will automatically have the correct
     * text and will have an ActionListener registered that will call the registered AboutHandler
     * if the ActionEvent is triggered.
     * 
     * @param prefsLabel the label for the Preferences menu item.
         * @return the About Swing menu item
         */
        public PreferencesJMenuItem getPreferencesJMenuItem(String prefsLabel) {
                if (isNull(prefsJMenuItem)) {
                        prefsJMenuItem = new PreferencesJMenuItem(prefsLabel);
            prefsJMenuItem.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (nonNull(prefsHdlr)) {
                        PreferencesEvent pe = new PreferencesEvent();
                        prefsHdlr.handlePreferences(pe);
                    }
                }
            });
        }
                return prefsJMenuItem;
        }
        
    /**
     * Used to set the filename filter for this application. This is provided as a
     * convenience for storing the filename filter so that it is accessible throughout an
     * application.
     *
     * @param filter The filename filter to be stored with this application.
     */
    public static void setFilenameFilter(FilenameFilter filter) {
        fnFilter = filter;
    }

    /**
     * Return a reference to this application's default file name filter or null if a
     * filename filter has not been stored.
     *
     * @return The default filename filter for this application.
     */
    public static FilenameFilter getFilenameFilter() {
        return fnFilter;
    }

    /**
     * Sets a flag indicating if the application should quit when the last window is
     * closed (true) or stay open (false; allowing the user to select "New" from the file
     * menu for instance). The default value is true except on MacOS X where the default
     * value if false.
     *
     * @param flag Set to true to have the application automatically quit when all the
     *             windows close.
     */
    public static void setQuitOnClose(boolean flag) {
        quitOnClose = flag;
    }

    /**
     * Returns a flag indicating if the application should quit when the last window is
     * closed (true) or stay open (false; allowing the user to select "New" from the file
     * menu for instance). The default value is true except on MacOS X where the default
     * value if false.
     *
     * @return A flag indicating if the application should quit when the last window is
     *         closed.
     */
    public static boolean getQuitOnClose() {
        return quitOnClose;
    }

        /**
         * Get the Quit item as a Swing menu item. This item will automatically have the correct
     * text and shortcut key for the platform and will have an ActionListener registered
     * that will call System.exit(0) if the ActionEvent is triggered.
     * 
         * @return the Quit Swing menu item
         */
        public QuitJMenuItem getQuitJMenuItem() {
                return getQuitJMenuItem("Exit");
        }
        
        /**
         * Get the Quit item as a Swing menu item. This item will automatically have the correct
     * text and shortcut key for the platform and will have an ActionListener registered
     * that will call System.exit(0) if the ActionEvent is triggered.
     * 
     * @param exitLabel The label for the quit menu on non-MacOS platforms.
         * @return the Quit Swing menu item
         */
        public QuitJMenuItem getQuitJMenuItem(String exitLabel) {
                if (isNull(quitJMenuItem)) {
                        quitJMenuItem = new QuitJMenuItem(this, exitLabel);
            quitJMenuItem.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    //  Ask Java to quit if the user selects this menu item.
                    //  The quit handler (if one is registered) will be called automatically.
                    System.exit(0);
                }
            });
        }
                return quitJMenuItem;
        }
        
    /**
     * Register the supplied window with the list of windows managed by this
     * MDIApplication. When the window is made visible, it will be added to the "Windows"
     * menu. The window will be removed from the "Windows" menu when it is closed.
     *
     * @param window The window to be added to the list of open windows.
     */
    public static void addWindow(Window window) {
        if (openWindows.contains(window))
            return;   //  Don't add a window twice.
        
        //  Add a window event listener in order to keep the open windows list and menus up to date.
        window.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosed(WindowEvent e) {
                Window aWindow = e.getWindow();
                int idx = openWindows.indexOf(aWindow);
                if (idx >= 0) {
                    removeMenuItem(openWindows.size() - idx - 1);
                    openWindows.remove(idx);
                }

                //  If requested, quit if there are no open windows.
                if (quitOnClose && openWindows.isEmpty())
                    handleQuit(null,null);
            }

            @Override
            public void windowActivated(WindowEvent e) {
                Window aWindow = e.getWindow();
                if (aWindow.isVisible()) {
                    int idx = openWindows.indexOf(aWindow);
                    if (idx >= 0) {
                        //  Change the position of the window in the Windows menu.
                        removeMenuItem(openWindows.size() - idx - 1);
                        openWindows.remove(idx);
                        openWindows.push(aWindow);
                        addNewMenuItem(aWindow);
                        
                    } else {
                        //  Add a new item to the Windows menu.
                        openWindows.push(aWindow);
                        addNewMenuItem(aWindow);
                    }
                }
            }
        });

    }

    /**
     * Register an object to receive notification that the application is going to quit
     * soon.
     *
     * @param listener The listener to register.
     */
    public static void addQuitListener(QuitListener listener) {
        quitList.add(listener);
    }

    /**
     * Method to remove a quit listener from the list of quit listeners for this
     * application.
     *
     * @param listener The listener to remove.
     */
    public static void removeQuitListener(QuitListener listener) {
        quitList.remove(listener);
    }

    /**
     * Installs the handler which determines if the application should quit. The handler
     * is passed a one-shot QuitResponse which can cancel or proceed with the quit.
     * Setting the handler to null causes all quit requests to directly perform the
     * default QuitStrategy.
     *
     * @param quitHandler The handler which determines if the application should quit.
     */
    public static void setQuitHandler(QuitHandler quitHandler) {
        if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.APP_QUIT_HANDLER))
            desktop.setQuitHandler(quitHandler);
    }

    /**
     * Launches the default browser to display a URI. If the default browser is not able
     * to handle the specified URI, the application registered for handling URIs of the
     * specified type is invoked. The application is determined from the protocol and path
     * of the URI, as defined by the URI class.
     *
     * @param uri The URI to be displayed in the user default browser.
     * @throws IOException If the supplied URI can not be displayed.
     */
    public static void browse(URI uri) throws IOException {
        if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.BROWSE))
            desktop.browse(uri);
    }
    
    /**
     * Installs a handler to show a custom About window for your application.
     *
     * @param aboutHandler the handler to respond to the
     *                     AboutHandler.handleAbout(AboutEvent) message
     * @throws SecurityException if a security manager exists and it denies the
     * RuntimePermission("canProcessApplicationEvents") permission
     * @throws UnsupportedOperationException if the current platform does not support the
     * Desktop.Action.APP_ABOUT action.
     */
    public static void setAboutHandler(AboutHandler aboutHandler) {
        aboutHdlr = aboutHandler;
        if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.APP_ABOUT))
            desktop.setAboutHandler(aboutHandler);
    }
    
        /**
         * Get the About item as a Swing menu item. This item will automatically have the correct
     * text and will have an ActionListener registered that will call the registered AboutHandler
     * if the ActionEvent is triggered.
     * 
         * @return the About Swing menu item
         */
        public AboutJMenuItem getAboutJMenuItem() {
                if (isNull(aboutJMenuItem)) {
                        aboutJMenuItem = new AboutJMenuItem(this);
            aboutJMenuItem.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (nonNull(aboutHdlr)) {
                        AboutEvent ae = new AboutEvent();
                        aboutHdlr.handleAbout(ae);
                    }
                }
            });
        }
                return aboutJMenuItem;
        }
        
    /**
     * Installs the handler which is notified when the application is asked to open a list
     * of files.
     *
     * @param openFilesHandler handler
     * @throws SecurityException if a security manager exists and its
     * SecurityManager.checkRead(java.lang.String) method denies read access to the files,
     * or it denies the RuntimePermission("canProcessApplicationEvents") permission, or
     * the calling thread is not allowed to create a subprocess.
     * @throws UnsupportedOperationException if the current platform does not support the
     * Desktop.Action.APP_OPEN_FILE action
     */
    public static void setOpenFileHandler(OpenFilesHandler openFilesHandler) throws SecurityException, UnsupportedOperationException {
        if (Desktop.isDesktopSupported() && desktop.isSupported(Desktop.Action.APP_OPEN_FILE))
            desktop.setOpenFileHandler(openFilesHandler);
    }
    
    /**
     * Returns a reference to the top-most window in the list of all open windows
     * registered with this application. If there are no open windows, null is returned.
     *
     * @return The top-most window in the list of all open windows.
     */
    public static Window getTopWindow() {
        Window window = null;
        if (!openWindows.empty())
            window = openWindows.peek();
        return window;
    }

    /**
     * Get an unmodifiable list of all the currently open windows in the application.
     *
     * @return An unmodifiable list of all the currently open windows.
     */
    public static List<Window> allOpenWindows() {
        return Collections.unmodifiableList(openWindows);
    }

    /**
     * Get a new JMenu instance that can be used as a Windows menu using the specified
     * title (typically "Windows"). The menu that is returned is maintained by this class
     * and should not be modified by the user.
     *
     * @param title The title for the Windows menu.
     * @return A JMenu that represents the application's Windows menu.
     */
    public static JMenu newWindowsMenu(String title) {
        JMenu menu = new JMenu(title);

        //  Add the new menu to our list of Windows menus.
        windowsMenus.add(menu);

        createNewMenuItems(menu);

        return menu;
    }

    /**
     * Call this method when a window being shown in a Windows menu has changed it's
     * title. This method will update the titles shown in the Windows menu.
     *
     * @param window The window that has changed titles.
     */
    public static void windowTitleChanged(Window window) {
        //  Find the window in the list of open windows.
        int idx = openWindows.indexOf(window);
        if (idx < 0)
            return;

        //  Adjust the index to be top down instead of bottom up.
        idx = openWindows.size() - idx - 1;

        if (idx >= 0 && !windowsMenus.isEmpty()) {
            //  Get the new title.
            String title = getWindowTitle(window);

            //  Loop over all the Windows Menus in existence.
            for (JMenu menu : windowsMenus) {
                if (menu != null) {
                    JMenuItem item = menu.getItem(idx);
                    item.setText(title);
                }
            }
        }
    }

    /**
     * Return the title of the given window (assuming it is either a Frame or a Dialog).
     * If it is actually a Window instance, this returns the title of the parent Frame.
     *
     * @param window The window to return the title for.
     */
    private static String getWindowTitle(Window window) {
        String title;
        if (window instanceof Frame)
            title = ((Frame)window).getTitle();
        else if (window instanceof Dialog)
            title = ((Dialog)window).getTitle();
        else {
            Frame frame = AppUtilities.getFrameForComponent(window);
            title = frame.getTitle();
        }
        return title;
    }

    /**
     * Method that adds a menu item to the specified menu for each open window.
     */
    private static void createNewMenuItems(JMenu menu) {
        for (int i = openWindows.size() - 1; i >= 0; --i) {
            Window window = openWindows.get(i);
            JMenuItem item = new JMenuItem(getWindowTitle(window));
            item.addActionListener(new MenuListener(window));
            menu.add(item);
        }
    }

    /**
     * Method that adds a single new menu item to the top of ALL the Windows menus.
     */
    private static void addNewMenuItem(Window window) {
        if (!windowsMenus.isEmpty()) {

            String title = getWindowTitle(window);
            for (Iterator<JMenu> i = windowsMenus.iterator(); i.hasNext();) {
                JMenu menu = i.next();

                if (menu != null) {
                    JMenuItem item = new JMenuItem(title);
                    item.addActionListener(new MenuListener(window));
                    menu.add(item, 0);
                } else {
                    i.remove();
                }
            }

        }
    }

    /**
     * Method that removes a single menu item from ALL of the Windows menus.
     */
    private static void removeMenuItem(int idx) {
        if (!windowsMenus.isEmpty()) {

            for (Iterator<JMenu> i = windowsMenus.iterator(); i.hasNext();) {
                JMenu menu = i.next();
                if (menu != null) {
                    menu.remove(idx);
                } else {
                    i.remove();
                }
            }

        }
    }

    /**
     * Class that provides an action listener for Window menu items. When this listener is
     * called, it brings it's window to the front.
     */
    private static class MenuListener implements ActionListener {

        private final Window theWindow;

        MenuListener(Window window) {
            theWindow = window;
        }

        @Override
        public void actionPerformed(ActionEvent event) {
            theWindow.setVisible(true);
        }
    }

    /**
     * Handle the user requesting a new document window. If it is inappropriate for the
     * application to create a new document window, then this method should do nothing.
     * The default implementation does nothing and returns null.
     *
     * @param event The event that caused this method to be called. May be "null" if this
     *              method is called by MDIApplication or one of it's subclasses.
     * @return A reference to the newly created window frame or null if a window was not
     *         created.
     */
    public Frame handleNew(ActionEvent event) {
        return null;
    }

    /**
     * Handle the user choosing "Close" from the File menu. This implementation dispatches
     * a "Window Closing" event on the top most window.
     *
     * @param event The event that caused this method to be called.
     */
    public static void handleClose(ActionEvent event) {
        if (!openWindows.isEmpty()) {
            Window window = openWindows.peek();
            window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
        }
    }

    /**
     * Handle the user choosing "Quit" from the File menu. This implementation dispatches a
     * separate "window closing" event to each window. This gives each window an
     * opportunity to cancel the quit process.
     *
     * @param event The event that caused this method to be called or null if none.
     * @param response the one-shot response object used to cancel or proceed with the quit action or null if none.
     * @return True if the application can proceed with the quit or false if it shoudl be canceled.
     */
    public static synchronized boolean handleQuit(QuitEvent event, QuitResponse response) {

        boolean quitFlag = true;
        if (!quitList.isEmpty()) {
    
            // Loop over all the quit listeners, notifying them one at a time.
            // When the last notification is made.  The application will quit.
            QuitListener[] array = new QuitListener[quitList.size()];
            quitList.toArray(array);
            for (QuitListener next : array) {

                //  Tell the listener that we are going to quit.
                boolean cancel = next.quit();
                if (cancel) {
                    quitFlag = false;
                    break;
                }
            }
        }
        
        if (nonNull(response)) {
            if (quitFlag)
                response.performQuit();
            else
                response.cancelQuit();
        }
        
        return quitFlag;
    }

}