/*
 * The dialog that controls our settings.
 */
package name.blackcap.exifwasher

import java.awt.Toolkit
import java.awt.event.ActionEvent
import java.awt.event.ActionListener
import java.io.File
import java.io.IOException
import java.util.logging.Level
import java.util.logging.Logger
import javax.swing.*
import javax.swing.event.ListDataEvent
import javax.swing.event.ListDataListener
import kotlin.text.toBoolean

import name.blackcap.exifwasher.exiv2.*

class SettingsDialog : JDialog(Application.mainFrame) {
    private val BW = 9
    private val BW2 = BW * 2

    /* where to send output, if not outputToInputDir */
    private var _outputTo = PROPERTIES.getProperty("outputTo")
    private var _dOutputTo = DPROPERTIES.getProperty("outputTo")
    val outputTo: String
    get() = _outputTo

    /* make output where input was found */
    private var _outputToInputDir = (PROPERTIES.getProperty("outputToInputDir") ?: "false").toBoolean()
    private var _dOutputToInputDir = (DPROPERTIES.getProperty("outputToInputDir") ?: "false").toBoolean()
    val outputToInputDir: Boolean
    get() = _outputToInputDir

    /* the whitelist of allowed Exif tags */
    private var _whitelist = Whitelist.parse(PROPERTIES.getProperty("whitelist") :? "")
    val whitelist: Whitelist
    get() = _whitelist

    /* the default whitelist, for factory resets */
    private val _oWhitelist = _whitelist.clone()
    private val _dWhitelist = Whitelist.parse(DPROPERTIES.getProperty("whitelist") :? "")

    /* radio buttons to choose output directory policy */
    private val outputToButton = JRadioButton("Output to:", !outputToInputDir).apply {
        addActionListener(ActionListener { setOutputOpts(isSelected()) })
    }
    private val outputToInputButton = JRadioButton(
      "Output to directory containing input file.", outputToInputDir).apply {
        addActionListener(ActionListener { setOutputOpts(!isSelected()) })
    }
    private val buttonGroup = ButtonGroup().apply {
        add(outputToButton)
        add(outputToInputButton)
    }
    private fun setOutputOpts(toSpecific: Boolean) {
        _outputToInputDir = !toSpecific
        changeOutputTo.setEnabled(toSpecific)
    }

    /* displays the OutputTo directory */
    private val outputToText = JTextField(outputTo, 50).apply {
        setEditable(false)
    }

    /* pops up to change the above directory */
    private val outputToChooser = JFileChooser(outputToText.text).apply {
        fileSelectionMode = DIRECTORIES_ONLY
    }

    /* requests the OutputTo directory be changed */
    private val changeOutputTo = JButton("Change").also {
        it.addActionListener(ActionListener {
            val status = outputToChooser.showOpenDialog(this)
            if (status == JFileChooser.APPROVE_OPTION) {
                _outputTo = outputToChooser.selectedFile.canonicalPath
                outputToText.text = _outputTo
            }
        })
        it.setEnabled(!outputToInputDir)
    }

    /* bottom buttons to restore defaults, cancel, save */
    private val restoreButton = JButton("Restore All Defaults").also {
        addActionListener(ActionListener {
            restore(_dOutputToInputDir, _dOutputTo, _dWhitelist)
        }
    }
    private val cancelButton = JButton("Cancel").also {
        addActionListener(ActionListener {
            setVisible(false)
            restore(outputToInputDir, outputTo, whitelist)
        })
    }
    private val saveButton = JButton("Save").also {
        addActionListener(ActionListener {
            setVisible(false)
            writeProperties()
        })
    }

    private fun writeProperties() {
        PROPERTIES.run {
            setProperty("outputTo", outputTo)
            setProperty("outputToInputDir", outputToInputDir.toString())
            setProperty("whitelist", whitelist.toString())
        }
        try {
            BufferedWriter(OutputStreamWriter(FileOutputStream(PROP_FILE), CHARSET)).use {
                PROPERTIES.store(it, null)
            }
        } catch (e: IOException) {
            LOGGER.log(Level.SEVERE, "unable to write settings", e)
            JOptionPane.showMessageDialog(Application.mainFrame,
                "Unable to write settings.",
                "Error",
                JOptionPane.ERROR_MESSAGE)
        }
    }

    private fun restore(outputToInput: Boolean, output: String, wl: Whitelist) {
        outputToButton.setSelected(!outputToInput)
        changeOutputTo.setEnabled(!outputToInput)
        outputToText.text = output
        outputToInputButton.setSelected(outputToInput)
        wlSelectorModel.reset(wl.toList())
    }

    /* so we can present a list of strings that is always sorted */
    private class WhiteListModel(basedOn: Collection<String>): ListModel<String> {
        private val storage = ArrayList<String>(basedOn).apply { sort() }
        private val listeners = mutableListOf<ListDataListener>()

        /* so we can mutate the list */

        fun add(newItem: String): Unit {
            var index = storage.binarySearch(newItem)
            if (index < 0) {
                index = -(index + 1)
            }
            storage.add(index, newItem)
            val event = ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, index, index)
            listeners.forEach { it.intervalAdded(event) }
        }

        fun removeAt(index: Int): Unit {
            if (storage.removeAt(index)) {
                val event = ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, index, index)
                listeners.forEach { it.intervalRemoved(event) }
            }
        }

        fun remove(oldItem: String): Unit {
            val index = basedOn.binarySearch(oldItem)
            if (index < 0) {
                return
            }
            var start = index
            while (start > 0 && storage[start] == oldItem) {
                start -= 1
            }
            var end = index
            var max = storage.size - 1
            while (end < max && storage[end] == oldItem) {
                end += 1
            }
            storage.removeRange(start, end+1)
            val event = ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, start, end)
            listeners.forEach { it.intervalRemoved(event) }
        }

        fun reset(basedOn: Collection<String>): Unit {
            val removeEvent = ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, 0, storage.size)
            storage.clear()
            storage.addAll(basedOn)
            storage.sort()
            val addEvent = ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, 0, storage.size)
            listeners.forEach {
                it.contentsChanged(removeEvent)
                it.contentsChanged(addEvent)
            }
        }

        fun toList(): List<String> = storage

        /* so we are a proper ListModel */

        override fun addListDataListener(l: ListDataListener): Unit {
            listeners.add(l)
        }

        override fun removeListDataListener(l: ListDataListener): Unit {
            listeners.remove(l)
        }

        override fun getElementAt(index: Int): String = storage[index]

        override fun getSize(): Int = storage.size
    }

    private class WLAddDialog(parent: SettingsDialog): JDialog(parent) {
        JTextField text = JTextField(40).apply {
            alignmentX = CENTER_ALIGNMENT
            border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
        }

        JButton cancelButton = JButton("Cancel").apply {
            addActionListener(ActionListener {
                text.text = ""
                setVisible(false)
            })
        }

        JButton addButton = JButton("Add").apply {
            addActionListener(ActionListener {
                val newItem = text.text?.trim()
                if (newItem.isNullOrEmpty()) {
                    Toolkit.getDefaultToolkit().beep()
                } else {
                    wlSelectorModel.add(newItem)
                }
                text.text = ""
                setVisible(false)
                }
            })
        }

        init {
            title = "Add Item to Whitelist"
            contentPane.apply {
                layout = BoxLayout(this, BoxLayout.Y_AXIS)
                add(text)
                add(Box(BoxLayout.X_AXIS).apply {
                    alignmentX = CENTER_ALIGNMENT
                    border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                    add(Box.createHorizontalGlue())
                    add(cancelButton)
                    add(Box.createHorizontalGlue())
                    add(addButton)
                    add(Box.createHorizontalGlue())
                })
            }
            pack()
            setResizable(false)
        }
    }

    /* the JList that holds our whitelist */
    private val wlSelectorModel = WhiteListModel(whitelist.toList())
    private val wlSelector = JList().apply {
        visibleRowCount = -1
        model = wlSelectorModel
        clearSelection()
        addListSelectionListener(ListSelectionListener {
            wlDeleteButton.setEnabled(!isSelectionEmpty())
        }
    }

    /* buttons for managing the whitelist */
    private val wlAddButton = JButton("Add").apply {
        addActionListener(ActionListener { wlAddDialog.setVisible(true) })
    }
    private val wlDeleteButton = JButton("Delete").apply {
        addActionListener(ActionListener {
            wlSelector.selectedIndices.forEach { wlSelectorModel.removeAt(it) }
        })
        setEnabled(false)
    }

    /* the dialog that the Add button pops up */
    private val wlAddDialog = WLAddDialog(this)

    init {
        if (_outputTo.isNullOrEmpty()) {
            _outputTo = System.getProperty("user.dir")
        }
        title = "Settings"
        contentPane.apply {
            layout = BoxLayout(this, BoxLayout.Y_AXIS)
            add(JTabbedPane().apply {
                addTab("Folders", JPanel().apply {
                    border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                    layout = BoxLayout(this, BoxLayout.Y_AXIS)
                    add(outputToInputButton.apply {
                        alignmentX = LEFT_ALIGNMENT
                        border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                    })
                    add(Box(BoxLayout.X_AXIS).apply {
                        alignmentX = LEFT_ALIGNMENT
                        border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                        add(outputToButton)
                        add(Box.createHorizontalStrut(BW2))
                        add(outputToText)
                        add(Box.createHorizontalGlue())
                    })
                    add(Box(BoxLayout.X_AXIS).apply {
                        alignmentX = LEFT_ALIGNMENT
                        border = BorderFactory.createEmptyBorder(0, BW, BW, BW)
                        add(Box.createHorizontalGlue())
                        add(changeOutputTo)
                    })
                })
                addTab("Whitelist", JPanel().apply {
                    border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                    layout = BoxLayout(this, BoxLayout.Y_AXIS)
                    add(JScrollPane(wlSelector).apply {
                        alignmentX = CENTER_ALIGNMENT
                        border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                        verticalScrollBarPolicy = ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
                        horizontalScrollBarPolicy = ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
                    })
                    add(Box(BoxLayout.X_AXIS).apply {
                        alignmentX = CENTER_ALIGNMENT
                        border = BorderFactory.createEmptyBorder(BW, BW, BW, BW)
                        add(Box.createHorizontalGlue())
                        add(wlAddButton)
                        add(Box.createHorizontalGlue())
                        add(wlDeleteButton)
                        add(Box.createHorizontalGlue())
                    })
                })
            })
            add(Box(BoxLayout.X_AXIS).apply {
                border = BorderFactory.createEmptyBorder(BW, BW2, BW2, BW2)
                add(restoreButton)
                add(Box.createHorizontalGlue())
                add(cancelButton)
                add(Box.createHorizontalStrut(BW2))
                add(saveButton)
            })
        }
        pack()
        minimumSize = size
    }
}