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.{TransferMode, DataFormat, 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) + ",G"
                    clickX = -1.0
                    clickY = -1.0
                    paint
                }
                else if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(1)))
                {
                    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) + ",S"
                    clickX = -1.0
                    clickY = -1.0
                    paint
                }
            }))
        setOnMouseClicked(handleEvt(evt => {
            if (evt.getButton == MouseButton.PRIMARY)
            {
                if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(3)))
                {
                    grid(math.floor(evt.getY / 32).toInt)(math.floor(evt.getX / 32).toInt) = "D"
                }
                else if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(4)))
                {
                    grid(math.floor(evt.getY / 32).toInt)(math.floor(evt.getX / 32).toInt) = "T"
                }
                else if (toolGroup.getSelectedToggle.equals(toolGroup.getToggles.get(2)))
                {
                    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("D"))
                    {
                        gc.setFill(Color.BROWN)
                        gc.fillRect(j * scale + size, i * scale + size, scale - size, scale - size)
                    }
                    else if (grid(i)(j).equals("T"))
                    {
                        gc.setFill(Color.RED)
                        gc.fillRect(j * scale + size, i * scale + size, scale - size, scale - size)
                    }
                    else if (!grid(i)(j).equals("-"))
                    {
                        val wAndH = grid(i)(j).split(",")
                        if (wAndH(2).equals("G"))
                            gc.setFill(Color.GREEN)
                        else
                            gc.setFill(Color.GRAY)
                        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)
                        if (wAndH(2).equals("G"))
                            gc.setFill(Color.DARKGREEN)
                        else
                            gc.setFill(Color.DARKGRAY)
                        gc.fillRect(j * scale + size, i * scale + size, scale - size, scale - size)
                    }
        }
    }



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

        val toggles = new VBox
        val grass = new ToggleButton("Grass")
        grass.setSelected(true)
        grass.setToggleGroup(toolGroup)
        val stone = new ToggleButton("Stone")
        stone.setToggleGroup(toolGroup)
        val player = new ToggleButton("Player")
        player.setToggleGroup(toolGroup)
        val door = new ToggleButton("Door")
        door.setToggleGroup(toolGroup)
        val trap = new ToggleButton("Trap")
        trap.setToggleGroup(toolGroup)
        toggles.getChildren.addAll(grass, stone, player, door, trap)

        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)

        def loadMapFile(f: File) =
        {
            currentDir = f.getParentFile
            val ar = ArrayBuffer[Array[String]]()
            val in = new Scanner(f)
            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
        }

        canvas.setOnDragOver(handleEvt(evt =>
            if (evt.getDragboard.getContentTypes.contains(DataFormat.FILES))
                evt.acceptTransferModes(TransferMode.COPY, TransferMode.MOVE, TransferMode.LINK)
        ))
        canvas.setOnDragDropped(handleEvt(evt => loadMapFile(evt.getDragboard.getContent(DataFormat.FILES).asInstanceOf[java.util.List[File]].get(0))))

        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)
                loadMapFile(openFile)
        }%))
        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
    }
}