package mars.tools

import mars.Globals
import mars.detectRadix
import mars.mips.hardware.*
import mars.toHex
import mars.util.Binary
import java.awt.*
import java.awt.BorderLayout.*
import java.awt.event.KeyEvent
import java.awt.event.KeyListener
import java.util.*
import javax.swing.*
import javax.swing.border.EmptyBorder
import kotlin.collections.ArrayList
import kotlin.collections.HashSet

/*
Copyright (c) 2010-2011,  Pete Sanderson and Kenneth Vollmar

Developed by Pete Sanderson (psanderson@otterbein.edu)
and Kenneth Vollmar (kenvollmar@missouristate.edu)

Permission is hereby granted, free of charge, to any person obtaining 
a copy of this software and associated documentation files (the 
"Software"), to deal in the Software without restriction, including 
without limitation the rights to use, copy, modify, merge, publish, 
distribute, sublicense, and/or sell copies of the Software, and to 
permit persons to whom the Software is furnished to do so, subject 
to the following conditions:

The above copyright notice and this permission notice shall be 
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

(MIT license, http://www.opensource.org/licenses/mit-license.html)
 */
/**
 * Bitmapp display simulator.  It can be run either as a stand-alone Java application having access to the mars package,
 * or through MARS as an item in its Tools menu.  It makes maximum use of methods inherited from its abstract superclass
 * AbstractMarsToolAndApplication. Pete Sanderson, verison 1.0, 23 December 2010.
 */
class BitmapDisplay : AbstractMarsToolAndApplication
{
    // Major GUI components
    private lateinit var uiBaseAddressSelector: JComboBox<String>
    private lateinit var uiKeyboardCheckbox: JCheckBox
    private lateinit var canvas: JPanel
    private lateinit var results: JPanel

    // Some GUI settings
    private val emptyBorder = EmptyBorder(4, 4, 4, 4)
    private val backgroundColor = Color.WHITE

    // Values for display canvas.  Note their initialization uses the identifiers just above.
    private var unitWidth: Int = 2
    private var unitHeight: Int = 2
    private var displayWidth: Int = 512
    private var displayHeight: Int = 256
    private val displayDimension get() = Dimension(displayWidth, displayHeight)

    private val baseAddresses = intArrayOf(Memory.dataSegmentBaseAddress, Memory.globalPointer, Memory.dataBaseAddress,
        Memory.heapBaseAddress, Memory.memoryMapBaseAddress)

    private val baseAddress get() = baseAddresses[uiBaseAddressSelector.selectedIndex]

    // Keyboard++
    private var keyboardAddr: UInt = 0xFFFF0010u
    private var oldKeyboardAddr: UInt = 0xFFFF0000u
    private var oldKeyboardLastPressed: Char = ' '
    private var keyboardAttached = false
    private lateinit var uiKeyboard: JTextField

    private lateinit var grid: Grid

    val pooledKeyEvents = hashMapOf<UInt, ArrayList<KeyEvent>>(
        0x00u to ArrayList(), 0x10u to ArrayList(), 0x20u to ArrayList()
    )
    val downKeys = HashSet<Int>()

    /**
     * Simple constructor, likely used to run a stand-alone bitmap display tool.
     *
     * @param title String containing title for title bar
     * @param heading String containing text for heading shown in upper part of window.
     */
    constructor(title: String, heading: String) : super(title, heading)

    constructor() : super("Azalea's Bitmap Display++", HEADING)

    override fun getName() = HEADING

    /**
     * Override the inherited method, which registers us as an Observer over the static data segment (starting address
     * 0x10010000) only.  This version will register us as observer over the the memory range as selected by the base
     * address combo box and capacity of the visualization display (number of visualization elements times the number of
     * memory words each one represents). It does so by calling the inherited 2-parameter overload of this method. If
     * you use the inherited GUI buttons, this method is invoked when you click "Connect" button on MarsTool or the
     * "Assemble and Run" button on a Mars-based app.
     */
    override fun addAsObserver()
    {
        var highAddress: Int = baseAddress + grid.rows * grid.cols * Memory.WORD_LENGTH_BYTES
        // Special case: baseAddress<0 means we're in kernel memory (0x80000000 and up) and most likely
        // in memory map address space (0xffff0000 and up).  In this case, we need to make sure the high address
        // does not drop off the high end of 32 bit address space.  Highest allowable word address is 0xfffffffc,
        // which is interpreted in Java int as -4.
        if (baseAddress < 0 && highAddress > -4)
        {
            highAddress = -4
        }
        addAsObserver(baseAddress, highAddress)
        addAsObserver(keyboardAddr.toInt(), (keyboardAddr + 0x20u).toInt())
    }

    /**
     * Method that constructs the main display area.  It is organized vertically into two major components: the display
     * configuration which an be modified using combo boxes, and the visualization display which is updated as the
     * attached MIPS program executes.
     *
     * @return the GUI component containing these two areas
     */
    override fun buildMainDisplayArea(): JComponent
    {
        results = JPanel()
        results.add(buildOrganizationArea())
        results.add(buildVisualizationArea())
        return results
    }

    //////////////////////////////////////////////////////////////////////////////////////
    //  Rest of the protected methods.  These override do-nothing methods inherited from
    //  the abstract superclass.
    //////////////////////////////////////////////////////////////////////////////////////
    /**
     * Update display when connected MIPS program accesses (data) memory.
     *
     * @param memory the attached memory
     * @param ac information provided by memory in MemoryAccessNotice object
     */
    override fun processMIPSUpdate(memory: Observable, ac: AccessNotice)
    {
        if (ac !is MemoryAccessNotice || ac.accessType != AccessNotice.WRITE) return
        val addr = ac.address.toUInt()

        // For the keyboard++
        if (addr in keyboardAddr..keyboardAddr + 0x30u)
        {
            // Offset 0x01 or 0x11 or 0x21 bytes are for telling the keyboard that the events are received
            var offset = addr - keyboardAddr

            // Clear the segment
            if (offset == 0x01u || offset == 0x11u)
            {
                if (Globals.memory.getByte(addr.toInt()) != 1) return

                println("Offset written: ${offset.toHex(2)}")

                // Clear bytes if 1 is written to the 0x01 offset
                offset -= 1u
                val range = offset..offset + 0x0Fu
                synchronized(Globals.memoryAndRegistersLock)
                {
                    range.map { keyboardAddr + it }.forEach { Globals.memory.setByte(it.toInt(), 0) }
                }
                pooledKeyEvents[offset]!!.clear()
                println("[Keyboard++] Keyboard segment range $range cleared")
            }
            return
        }

        // For the display
        val value = ac.value
        val offset = ((addr - baseAddress.toUInt()) / 4u).toInt()
        try
        {
            grid.setElement(offset / grid.cols, offset % grid.cols, value)
        }
        catch (e: IndexOutOfBoundsException)
        {
            // If address is out of range for display, do nothing.
        }
        if (offset == 0) canvas.repaint()
    }

    /**
     * Event on key press
     *
     * @param offset Event type / offset
     * @param e Event
     */
    fun keyEvent(offset: UInt, e: KeyEvent)
    {
        if (!keyboardAttached) return
        println("[Keyboard++] ${e.id} '${e.keyChar}' ${e.keyCode}")
        val queue = pooledKeyEvents[offset]!!

        // Old keyboard compatibility
        synchronized(Globals.memoryAndRegistersLock)
        {
            if (e.id == KeyEvent.KEY_PRESSED)
            {
                oldKeyboardLastPressed = e.keyChar
                Globals.memory.setWord(oldKeyboardAddr.toInt(), 1)
                Globals.memory.setWord((oldKeyboardAddr + 4u).toInt(), e.keyChar.code)
            }

            if (e.id == KeyEvent.KEY_RELEASED && e.keyChar == oldKeyboardLastPressed)
            {
                oldKeyboardLastPressed = 0.toChar()
                Globals.memory.setWord(oldKeyboardAddr.toInt(), 0)
                Globals.memory.setWord((oldKeyboardAddr + 4u).toInt(), 0)
            }
        }

        // Check for more than 7 key events queued
        if (queue.size == 7) return

        // Add to queue
        queue.add(e)

        // Add to memory
        var addr = keyboardAddr + offset
        println("[Keyboard++] Address ${addr.toHex(8)} set to ${queue.size} | ${addr.toHex(8)} set to ${e.keyCode} (${e.keyChar.toHex()})")
        synchronized(Globals.memoryAndRegistersLock)
        {
            // Change 0x0: Number of events
            Globals.memory.setByte(addr.toInt(), queue.size)

            // Set the keycode
            addr += queue.size.toUInt() * 2u
            Globals.memory.setHalf(addr.toInt(), e.keyCode)
        }
    }

    /**
     * Initialize all JComboBox choice structures not already initialized at declaration. Overrides inherited method
     * that does nothing.
     */
    override fun initializePreGUI()
    {
        grid = Grid(0, 0)
    }

    /**
     * The only post-GUI initialization is to create the initial Grid object based on the default settings of the
     * various combo boxes. Overrides inherited method that does nothing.
     */
    override fun initializePostGUI()
    {
        grid = createNewGrid()
    }

    /**
     * Method to reset counters and display when the Reset button selected. Overrides inherited method that does
     * nothing.
     */
    override fun reset()
    {
        grid.reset()
        canvas.repaint()
    }

    /**
     * Overrides default method, to provide a Help button for this tool/app.
     */
    override fun getHelpComponent(): JComponent
    {
        val helpContent = """
             Use this program to simulate a basic bitmap display where
             each memory word in a specified address space corresponds to
             one display pixel in row-major order starting at the upper left
             corner of the display.  This tool may be run either from the
             MARS Tools menu or as a stand-alone application.
             
             You can easily learn to use this small program by playing with
             it!   Each rectangular unit on the display represents one memory
             word in a contiguous address space starting with the specified
             base address.  The value stored in that word will be interpreted
             as a 24-bit RGB color value with the red component in bits 16-23,
             the green component in bits 8-15, and the blue component in bits 0-7.
             Each time a memory word within the display address space is written
             by the MIPS program, its position in the display will be rendered
             in the color that its value represents.
             
             Version 1.0 is very basic and was constructed from the Memory
             Reference Visualization tool's code.  Feel free to improve it and
             send me your code for consideration in the next MARS release.
             
             Contact Pete Sanderson at psanderson@otterbein.edu with
             questions or comments.
             
             """.trimIndent()
        val help = JButton("Help")
        help.addActionListener { JOptionPane.showMessageDialog(theWindow, helpContent) }
        return help
    }

    //////////////////////////////////////////////////////////////////////////////////////
    //  Private methods defined to support the above.
    //////////////////////////////////////////////////////////////////////////////////////
    // UI components and layout for left half of GUI, where settings are specified.
    private fun buildOrganizationArea(): JComponent
    {
        val uiUnitWidthSelector = JComboBox(arrayOf(1, 2, 4, 8, 16, 32)).apply {
            isEditable = false
            background = backgroundColor
            selectedIndex = 1
            toolTipText = "Width in pixels of rectangle representing memory word"
            addActionListener {
                unitWidth = getInt()
                grid = createNewGrid()
                reset()
            }
        }

        val uiUnitHeightSelector = JComboBox(arrayOf(1, 2, 4, 8, 16, 32)).apply {
            isEditable = false
            background = backgroundColor
            selectedIndex = 1
            toolTipText = "Height in pixels of rectangle representing memory word"
            addActionListener {
                unitHeight = getInt()
                grid = createNewGrid()
                reset()
            }
        }

        val uiWidthSelector = JComboBox(arrayOf(64, 128, 256, 512, 1024)).apply {
            isEditable = false
            background = backgroundColor
            selectedIndex = 3
            toolTipText = "Total width in pixels of display area"
            addActionListener {
                displayWidth = getInt()
                canvas.preferredSize = displayDimension
                canvas.size = displayDimension
                grid = createNewGrid()
                reset()
            }
        }

        val uiHeightSelector = JComboBox(arrayOf(64, 128, 256, 512, 1024)).apply {
            isEditable = false
            background = backgroundColor
            selectedIndex = 2
            toolTipText = "Total height in pixels of display area"
            addActionListener {
                displayHeight = getInt()
                canvas.preferredSize = displayDimension
                canvas.size = displayDimension
                grid = createNewGrid()
                reset()
            }
        }

        val descriptions = arrayOf("global data", "\$gp", "static data", "heap", "memory map")

        val displayBaseAddressChoices = baseAddresses
            .mapIndexed { i, it -> "${Binary.intToHexString(it)} (${descriptions[i]})" }.toTypedArray()

        uiBaseAddressSelector = JComboBox(displayBaseAddressChoices).apply {
            isEditable = false
            background = backgroundColor
            selectedIndex = 1
            toolTipText = "Base address for display area (upper left corner)"
            addActionListener {
                // If display base address is changed while connected to MIPS (this can only occur
                // when being used as a MarsTool), we have to delete ourselves as an observer and re-register.
                if (connectButton != null && connectButton.isConnected)
                {
                    deleteAsObserver()
                    addAsObserver()
                }
                grid = createNewGrid()
                reset()
            }
        }

        val uiKeyboardAddress = JTextField(keyboardAddr.toHex(8)).apply {
            addActionListener {
                text.toUIntOrNull(text.detectRadix())?.let {
                    keyboardAddr = it
                    uiKeyboardCheckbox.isSelected = false
                }
            }
        }
        val uiKeyboardCheckbox = JCheckBox("Attach Keyboard++", keyboardAttached).apply {
            addActionListener {
                keyboardAttached = isSelected
                if (isSelected)
                {
                    deleteAsObserver()
                    addAsObserver()
                }
                pooledKeyEvents.values.forEach { it.clear() }
            }
        }

        println("Bitmap Display++ Initialized")

        // Register key listener
        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher {
            if (!(keyboardAttached && uiKeyboard.hasFocus())) return@addKeyEventDispatcher false
            when (it.id)
            {
                KeyEvent.KEY_PRESSED ->
                {
                    // Keep track of down keys to avoid the system's key repeat
                    if (!downKeys.contains(it.keyCode))
                    {
                        keyEvent(0x00u, it)
                        downKeys.add(it.keyCode)
                    }
                }
                KeyEvent.KEY_RELEASED ->
                {
                    keyEvent(0x10u, it)
                    downKeys.remove(it.keyCode)
                }
            }
            true
        }
        uiKeyboard = JTextField(2).apply {
            class KL : KeyListener
            {
                override fun keyTyped(e: KeyEvent) {
                    uiKeyboard.text = ""
                }
                override fun keyPressed(e: KeyEvent) {
                    uiKeyboard.text = ""
                    // keyEvent(0x0u, e)
                }
                override fun keyReleased(e: KeyEvent) {
                    uiKeyboard.text = ""
                    // keyEvent(0x10u, e)
                }
            }

            addKeyListener(KL())
        }

        // Lay 'em out in the grid...
        return JPanel(GridLayout(8, 1)).apply {
            add(getPanelWithBorderLayout().apply {
                add(JLabel("Unit Width in Pixels "), WEST)
                add(uiUnitWidthSelector, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(JLabel("Unit Height in Pixels "), WEST)
                add(uiUnitHeightSelector, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(JLabel("Display Width in Pixels "), WEST)
                add(uiWidthSelector, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(JLabel("Display Height in Pixels "), WEST)
                add(uiHeightSelector, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(JLabel("Base address for display "), WEST)
                add(uiBaseAddressSelector, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(uiKeyboardCheckbox, WEST)
                add(uiKeyboardAddress, EAST)
            })
            add(getPanelWithBorderLayout().apply {
                add(JLabel("To use keyboard, put your cursor here >"), WEST)
                add(uiKeyboard)
            })
        }
    }

    // UI components and layout for right half of GUI, the visualization display area.
    private fun buildVisualizationArea(): JComponent
    {
        canvas = GraphicsPanel()
        canvas.preferredSize = displayDimension
        canvas.toolTipText = "Bitmap display area"
        return canvas
    }

    private fun <T> JComboBox<T>.getInt() = selectedItem!!.toString().toInt()

    // Use this for consistent results.
    private fun getPanelWithBorderLayout(): JPanel = JPanel(BorderLayout(2, 2)).apply { border = emptyBorder }

    // Method to determine grid dimensions based on current control settings.
    // Each grid element corresponds to one visualization unit.
    private fun createNewGrid(): Grid
    {
        val rows = displayHeight / unitHeight
        val columns = displayWidth / unitWidth
        return Grid(rows, columns)
    }

    //////////////////////////////////////////////////////////////////////////////////////
    //  Specialized inner classes for modeling and animation.
    //////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////
    //  Class that represents the panel for visualizing and animating memory reference
    //  patterns.
    private inner class GraphicsPanel : JPanel()
    {
        // override default paint method to assure display updated correctly every time
        // the panel is repainted.
        override fun paint(g: Graphics) = paintGrid(g, grid)

        // Paint the color codes.
        private fun paintGrid(g: Graphics, grid: Grid)
        {
            var upperLeftX = 0
            var upperLeftY = 0
            for (i in 0 until grid.rows)
            {
                for (j in 0 until grid.cols)
                {
                    g.color = grid.getElementFast(i, j)
                    g.fillRect(upperLeftX, upperLeftY, unitWidth, unitHeight)
                    upperLeftX += unitWidth // faster than multiplying
                }
                // get ready for next row...
                upperLeftX = 0
                upperLeftY += unitHeight // faster than multiplying
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////
    // Represents grid of colors
    private class Grid(rows: Int, columns: Int)
    {
        var grid: Array<Array<Color?>>
        var rows: Int
        var cols: Int

        init
        {
            grid = Array(rows) { arrayOfNulls(columns) }
            this.rows = rows
            this.cols = columns
            reset()
        }

        // Returns value in given grid element; null if row or column is out of range.
        private fun getElement(row: Int, column: Int): Color?
        {
            return if (row in 0..rows && column >= 0 && column <= cols) grid[row][column] else null
        }

        // Returns value in given grid element without doing any row/column index checking.
        // Is faster than getElement but will throw array index out of bounds exception if
        // parameter values are outside the bounds of the grid.
        fun getElementFast(row: Int, column: Int): Color?
        {
            return grid[row][column]
        }

        // Set the grid element.
        fun setElement(row: Int, column: Int, color: Int)
        {
            grid[row][column] = Color(color)
        }

        // Set the grid element.
        private fun setElement(row: Int, column: Int, color: Color)
        {
            grid[row][column] = color
        }

        // Just set all grid elements to black.
        fun reset()
        {
            for (i in 0 until rows)
            {
                for (j in 0 until cols)
                {
                    grid[i][j] = Color.BLACK
                }
            }
        }
    }

    companion object
    {
        private const val VERSION = "Version 1.0"
        private const val HEADING = "Bitmap Display++"

        /**
         * Main provided for pure stand-alone use.  Recommended stand-alone use is to write a driver program that
         * instantiates a Bitmap object then invokes its go() method. "stand-alone" means it is not invoked from the MARS
         * Tools menu.  "Pure" means there is no driver program to invoke the application.
         */
        @JvmStatic
        fun main(args: Array<String>)
        {
            BitmapDisplay("Bitmap Display stand-alone, " + VERSION, HEADING).go()
        }
    }
}