import java.io.{File, FileWriter}
import java.lang.Boolean
import java.util.Scanner
import javafx.application.Application
import javafx.beans.value.{ChangeListener, ObservableValue}
import javafx.geometry.{Insets, Pos}
import javafx.scene.Scene
import javafx.scene.canvas.Canvas
import javafx.scene.control._
import javafx.scene.input.MouseButton
import javafx.scene.layout._
import javafx.scene.paint.Color
import javafx.stage.{FileChooser, Stage}

import sw.common.Tools
import sw.common.ui.UIShortcuts

import scala.collection.mutable.ArrayBuffer

object Main extends App{new Main().launch}
class Main extends Application with Tools with UIShortcuts
{
    def launch = javafx.application.Application.launch()

    var currentDir = new File(System.getProperty("user.dir"))
    var stg: Stage = null
    var grid: Array[Array[String]] = null

    def newGridBounds(x: Int, y: Int) =
    {
        val temp = new Array[Array[String]](y)
        for (i <- 0 until temp.length)
            temp(i) = Array.fill(x)("-")
        if (grid != null)
            for (i <- 0 until math.min(grid.length, temp.length))
                for (j <- 0 until math.min(grid(i).length, temp(i).length))
                    temp(i)(j) = grid(i)(j)
        grid = temp
    }

    newGridBounds(20, 20)

    var scale = 32
    var rows: TextField = null
    var cols: TextField = null
    var toolGroup: ToggleGroup = null
    var sp: ScrollPane = null

    class MyCanvas extends Canvas
    {
        var size = 2
        var clickX = -1.0
        var clickY = -1.0
        setOnMousePressed(handleEvt(evt =>
        {
            clickX = evt.getX
            clickY = evt.getY
        }))
        setOnMouseDragged(handleEvt(evt =>
        {
            paint
            val (left, right) = (math.min(clickX, evt.getX), math.max(clickX, evt.getX))
            val (top, bottom) = (math.min(clickY, evt.getY), math.max(clickY, evt.getY))
            val gc = getGraphicsContext2D
            gc.setFill(Color.GREEN)
            gc.fillRect(left, top, right - left, size)
            gc.fillRect(left, top, size, bottom - top)
            gc.fillRect(right, top, size, bottom - top)
            gc.fillRect(left, bottom, right - left, size)
        }))
        setOnMouseReleased(handleEvt(evt =>
            if (evt.getButton == MouseButton.PRIMARY)
            {
                if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(0)))
                {
                    val (left, right) = (math.max(0, math.floor(math.min(clickX, evt.getX) / 32).toInt), math.min(grid(0).length, math.ceil(math.max(clickX, evt.getX) / 32).toInt))
                    val (top, bottom) = (math.max(0, math.floor(math.min(clickY, evt.getY) / 32).toInt), math.min(grid.length, math.ceil(math.max(clickY, evt.getY) / 32).toInt))
                    grid(top)(left) = (right - left) + "," + (bottom - top)
                    clickX = -1.0
                    clickY = -1.0
                    paint
                }
            }))
        setOnMouseClicked(handleEvt(evt => {
            if (evt.getButton == MouseButton.PRIMARY)
            {
                if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(1)))
                {
                    val (x, y) = (math.floor(evt.getX / 32).toInt, math.floor(evt.getY / 32).toInt)
                    for (i <- 0 until grid.length)
                        for (j <- 0 until grid(i).length)
                            if (grid(i)(j).equals("P"))
                                grid(i)(j) = "-"
                    grid(y)(x) = "P"
                }
            }
            else if (evt.getButton == MouseButton.SECONDARY)
                grid(math.floor(math.min(clickY, evt.getY) / 32).toInt)(math.floor(math.min(clickX, evt.getX) / 32).toInt) = "-"
            paint
        }))

        def paint =
        {
            sp.setMinHeight(math.min(javafx.stage.Screen.getPrimary.getBounds.getMaxX - 400, cols.getText.toInt * scale + size + 2))
            sp.setMinWidth(math.min(javafx.stage.Screen.getPrimary.getBounds.getMaxX - 400, rows.getText.toInt * scale + size + 2))
            setHeight(cols.getText.toInt * scale + size)
            setWidth(rows.getText.toInt * scale + size)

            {
                stg.setWidth(math.min(javafx.stage.Screen.getPrimary.getBounds.getMaxX - 100, math.max(150, getWidth + 200)))
                stg.setHeight(math.min(javafx.stage.Screen.getPrimary.getBounds.getMaxY - 100, getHeight + 160 + 50))
            }.fx

            newGridBounds(rows.getText.toInt, cols.getText.toInt)
            val gc = getGraphicsContext2D
            gc.clearRect(0, 0, getWidth, getHeight)
            gc.setFill(Color.BLACK)
            for (x <- 0 to getWidth.toInt by scale)
                gc.fillRect(x, 0, size, getHeight)
            for (y <- 0 to getHeight.toInt by scale)
                gc.fillRect(0, y, getWidth, size)

            for (i <- 0 until grid.length)
                for (j <- 0 until grid(i).length)
                    if (grid(i)(j).equals("P"))
                    {
                        gc.setFill(Color.PURPLE)
                        gc.fillRect(j * scale + size, i * scale + size, scale - size, scale - size)
                    }
                    else if (!grid(i)(j).equals("-"))
                    {
                        val wAndH = grid(i)(j).split(",")
                        gc.setFill(Color.GREEN)
                        for (l <- 0 until wAndH(0).toInt)
                            for (k <- 0 until wAndH(1).toInt)
                                gc.fillRect((j + l) * scale + size, (i + k) * scale + size, scale - size, scale - size)
                        gc.setFill(Color.DARKGREEN)
                        gc.fillRect(j * scale + size, i * scale + size, scale - size, scale - size)
                    }
        }
    }

    def start(stg: Stage) =
    {
        toolGroup = new ToggleGroup

        val toggles = new VBox
        val terrain = new ToggleButton("Terrain")
        terrain.setSelected(true)
        terrain.setToggleGroup(toolGroup)
        val player = new ToggleButton("Player")
        player.setToggleGroup(toolGroup)
        toggles.getChildren.addAll(terrain, player)

        val canvas = new MyCanvas
        sp = new ScrollPane(canvas)
        sp.setBorder(Border.EMPTY)

        val rowsL = new Label("Rows:")
        rows = new TextField("20")
        rows.focusedProperty.addListener(new ChangeListener[Boolean] {def changed(observable: ObservableValue[_ <: Boolean], oldValue: Boolean, newValue: Boolean) = if (!newValue) canvas.paint})
        rows.setOnAction(handle(canvas.paint%))
        val colsL = new Label("Cols:")
        cols = new TextField("20")
        cols.focusedProperty.addListener(new ChangeListener[Boolean] {def changed(observable: ObservableValue[_ <: Boolean], oldValue: Boolean, newValue: Boolean) = if (!newValue) canvas.paint})
        cols.setOnAction(handle(canvas.paint%))

        val gp = new GridPane
        gp.setAlignment(Pos.CENTER)
        gp.setHgap(20)
        gp.setVgap(10)
        gp.add(rowsL, 0, 0)
        gp.add(rows, 1, 0)
        gp.add(colsL, 0, 1)
        gp.add(cols, 1, 1)

        canvas.setWidth(rows.getText.toInt * scale + canvas.size)
        canvas.setHeight(cols.getText.toInt * scale + canvas.size)

        val load = new Button("Load Map File")
        load.setOnAction(handle({
            val fc = new FileChooser
            fc.setInitialDirectory(currentDir)
            val openFile = fc.showOpenDialog(stg)
            if (openFile != null)
            {
                currentDir = openFile.getParentFile
                val ar = ArrayBuffer[Array[String]]()
                val in = new Scanner(openFile)
                while (in.hasNextLine)
                    ar += in.nextLine.split("\\|")
                in.close
                rows.setText(ar(0).length.toString)
                cols.setText(ar.length.toString)
                newGridBounds(ar(0).length, ar.length)
                for (i <- 0 until grid.length)
                    for (j <- 0 until grid(i).length)
                        grid(i)(j) = ar(i)(j)
                canvas.paint
            }
        }%))
        val save = new Button("Save Map Layout")
        save.setOnAction(handle({
            val fc = new FileChooser
            fc.setInitialDirectory(new File(System.getProperty("user.dir")))
            fc.setInitialDirectory(currentDir)
            val saveFile = fc.showSaveDialog(stg)
            if (saveFile != null)
            {
                currentDir = saveFile.getParentFile
                if (!saveFile.exists)
                    saveFile.createNewFile
                val fw = new FileWriter(saveFile)
                for (i <- 0 until grid.length)
                    fw.write(grid(i).mkString("|") + "\r\n")
                fw.close
            }
        }%))

        val hb = new HBox
        hb.setSpacing(15)
        hb.getChildren.addAll(toggles, sp)

        val vb = new VBox
        VBox.setVgrow(sp, Priority.ALWAYS)
        vb.setStyle("-fx-font-family: Consolas; -fx-font-size: 10pt; -fx-font-weight: normal")
        vb.setPadding(new Insets(10))
        vb.setSpacing(15)
        vb.setAlignment(Pos.CENTER)
        vb.getChildren.addAll(gp, hb, load, save)

        stg.setScene(new Scene(vb))
        stg.show
        this.stg = stg

        canvas.paint.fx
    }
}