package app;

// Java imports
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.swing.*;
import javax.swing.filechooser.*;

// Project imports
import util.*;
import vue.*;

// Main application window
class MainWindow extends JFrame {

    // Instance fields
    App app; // Containing application
    VUE vue; // Emulation core context

    // Private fields
    private boolean debugMode; // Window is in debug mode
    private int     number;    // Window number within application
    private boolean only;      // This is the only application window
    private File    pwd;       // Most recent working directory
    private ROM     rom;       // Currently loaded ROM
    private File    romFile;   // Currently loaded ROM file

    // UI components
    private JPanel        client;   // Common client container
    private ConsoleWindow console;  // Console window
    private CPUWindow     cpu;      // CPU window
    private JDesktopPane  desktop;  // Container for child windows
    private MemoryWindow  memory;   // Memory window
    private JMenu         mnuDebug; // Debug menu
    private JPanel        video;    // Video output
    private JMenuItem mnuFileDebugMode; // File -> Debug mode
    private JMenuItem mnuFileGameMode;  // File -> Game mode



    ///////////////////////////////////////////////////////////////////////////
    //                               Constants                               //
    ///////////////////////////////////////////////////////////////////////////

    // Application icon
    private static final BufferedImage APPICON;

    // Static initializer
    static {
        APPICON = Util.imageRead("images/app_icon.png");
    }



    ///////////////////////////////////////////////////////////////////////////
    //                             Constructors                              //
    ///////////////////////////////////////////////////////////////////////////

    // Default constructor
    MainWindow(App app) {
        super();

        // Configure instance fields
        this.app = app;
        pwd      = Util.PWD;
        vue      = VUE.create(app.getUseNative());
        System.out.println("Native: " + (vue.isNative() ? "Yes" : "No"));

        // Configure video pane
        video = new JPanel(null) {
            public void paintComponent(Graphics g) {
                super.paintComponent(g);
                onPaintVideo((Graphics2D) g, getWidth(), getHeight());
            }
        };
        video.setPreferredSize(new Dimension(384, 224));
        video.setFocusable(true);

        // Configure client area
        client = new JPanel(new BorderLayout());
        client.add(video, BorderLayout.CENTER);

        // Configure window
        addWindowListener(Util.onClose(e->onClose()));
        setContentPane(client);
        setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        setIconImage(APPICON);
        setJMenuBar(initMenus());
        app.localizer.add(this, "app.title.default");

        // Configure child windows
        desktop = new JDesktopPane();
        desktop.setBackground(SystemColor.controlShadow);
        desktop.add(console = new ConsoleWindow(this));
        desktop.add(cpu     = new CPUWindow    (this));
        desktop.add(memory  = new MemoryWindow (this));

        // Display window
        refreshDebug();
        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }



    ///////////////////////////////////////////////////////////////////////////
    //                           Menu Constructors                           //
    ///////////////////////////////////////////////////////////////////////////

    // Produce the window's menu bar
    private JMenuBar initMenus() {
        var bar = new JMenuBar();
        var loc = app.localizer;
        bar.add(initMenuFile (loc));
        bar.add(initMenuDebug(loc));
        return bar;
    }

    // Initialize the Debug menu
    private JMenu initMenuDebug(Localizer loc) {
        mnuDebug = new JMenu();
        loc.add(mnuDebug, "app.debug.(menu)");
        mnuDebug.setVisible(false);

        var mnuDebugConsole = new JMenuItem();
        loc.add(mnuDebugConsole, "app.debug.console");
        mnuDebugConsole.addActionListener(e->console.setVisible(true));
        mnuDebug.add(mnuDebugConsole);

        var mnuDebugMemory = new JMenuItem();
        loc.add(mnuDebugMemory, "app.debug.memory");
        mnuDebugMemory.addActionListener(e->memory.setVisible(true));
        mnuDebug.add(mnuDebugMemory);

        var mnuDebugCPU = new JMenuItem();
        loc.add(mnuDebugCPU, "app.debug.cpu");
        mnuDebugCPU.addActionListener(e->cpu.setVisible(true));
        mnuDebug.add(mnuDebugCPU);

        return mnuDebug;
    }

    // Initialize the File menu
    private JMenu initMenuFile(Localizer loc) {
        var mnuFile = new JMenu();
        loc.add(mnuFile, "app.file.(menu)");

        var mnuFileLoadRom = new JMenuItem();
        loc.add(mnuFileLoadRom, "app.file.load_rom");
        mnuFileLoadRom.addActionListener(e->onLoadROM());
        mnuFile.add(mnuFileLoadRom);

        mnuFileDebugMode = new JMenuItem();
        loc.add(mnuFileDebugMode, "app.file.debug_mode");
        mnuFileDebugMode.addActionListener(e->onDebugMode(true));
        mnuFile.add(mnuFileDebugMode);

        mnuFileGameMode = new JMenuItem();
        loc.add(mnuFileGameMode, "app.file.game_mode");
        mnuFileGameMode.addActionListener(e->onDebugMode(false));
        mnuFileGameMode.setVisible(false);
        mnuFile.add(mnuFileGameMode);

        mnuFile.addSeparator();

        var mnuFileNewWindow = new JMenuItem();
        loc.add(mnuFileNewWindow, "app.file.new_window");
        mnuFileNewWindow.addActionListener(e->onNewWindow());
        mnuFile.add(mnuFileNewWindow);

        var mnuFileExit = new JMenuItem();
        loc.add(mnuFileExit, "app.file.exit");
        mnuFileExit.addActionListener(e->onClose());
        mnuFile.add(mnuFileExit);

        return mnuFile;
    }



    ///////////////////////////////////////////////////////////////////////////
    //                            Package Methods                            //
    ///////////////////////////////////////////////////////////////////////////

    // Refresh all debug views
    void refreshDebug() {
        cpu   .refresh();
        memory.refresh();
    }

    // A window has been added to or removed from the program state
    void windowsChanged(int number, boolean only) {
        this.number = number;
        this.only   = only;
        app.localizer.put(this, "ctrl.number", "" + number);
        updateTitle();
    }



    ///////////////////////////////////////////////////////////////////////////
    //                            Event Handlers                             //
    ///////////////////////////////////////////////////////////////////////////

    // Window close, File -> Exit
    private void onClose() {
        app.removeWindow(this);
        cpu.dispose();
        dispose();
        vue.dispose();
    }

    // File -> Debug mode, File -> Game mode
    private void onDebugMode(boolean debugMode) {
        this.debugMode = debugMode;
        mnuFileDebugMode.setVisible(!debugMode);
        mnuFileGameMode .setVisible( debugMode);

        // Transition to debug mode
        if (debugMode) {
            client.remove(video);
            client.add(desktop, BorderLayout.CENTER);
            console.setContentPane(video);
            console.firstShow();
            mnuDebug.setVisible(true);
        }

        // Transition to game mode
        else {
            client.remove(desktop);
            client.add(video, BorderLayout.CENTER);
            mnuDebug.setVisible(false);
        }

        client.revalidate();
        client.repaint();
    }

    // File -> Load ROM
    private void onLoadROM() {
        var loc = app.localizer;

        // Prompt the user to select a file
        var dlgFile = new JFileChooser(pwd);
        dlgFile.addChoosableFileFilter(new FileNameExtensionFilter(
            loc.get("dialog.ext_vb"), "vb"));
        dlgFile.addChoosableFileFilter(new FileNameExtensionFilter(
            loc.get("dialog.ext_isx"), "isx"));
        dlgFile.setAcceptAllFileFilterUsed(true);
        dlgFile.setDialogTitle(loc.get("dialog.load_rom"));
        int option = dlgFile.showDialog(this, loc.get("dialog.load"));

        // The user did not select a file
        var file = dlgFile.getSelectedFile();
        if (option != JFileChooser.APPROVE_OPTION || file == null)
            return;

        // Update the current directory
        pwd = file.getParentFile();

        // Read the file
        var data = Util.fileRead(file);
        if (data == null) {
            JOptionPane.showMessageDialog(this,
                loc.get("dialog.load_rom_error"),
                loc.get("dialog.load_rom"),
                JOptionPane.ERROR_MESSAGE
            );
            return;
        }

        // Process the ROM
        ROM rom = null;
        try { rom = new ROM(data); }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this,
                loc.get("dialog.load_rom_notvb"),
                loc.get("dialog.load_rom"),
                JOptionPane.ERROR_MESSAGE
            );
            return;
        }

        // Update instance fields
        this.rom = rom;
        romFile  = file;
        loc.put(this, "ctrl.filename", file.getName());
        updateTitle();

        // Update the emulation state
        var bytes = rom.toByteArray();
        // Pause emulation
        vue.setROM(bytes, 0, bytes.length);
        vue.reset();
        refreshDebug();
        // Resume emulation
    }

    // File -> New window
    private void onNewWindow() {
        app.addWindow();
    }

    // Video paint
    private void onPaintVideo(Graphics2D g, int width, int height) {
        int scale = Math.max(1, Math.min(width / 384, height / 224));

        g.translate(
            Math.max(0, (width  - scale * 384) / 2),
            Math.max(0, (height - scale * 224) / 2)
        );
        g.scale(scale, scale);

        g.setColor(Color.black);
        g.fillRect(0, 0, 384, 224);
    }



    ///////////////////////////////////////////////////////////////////////////
    //                            Private Methods                            //
    ///////////////////////////////////////////////////////////////////////////

    // Update the window title
    private void updateTitle() {
        app.localizer.add(this,
            only ? romFile != null ?
                "app.title.rom" :
                "app.title.default"
            : romFile != null ?
                "app.title.mixed" :
                "app.title.number"
        );
    }

}