package shared.draw.rectangle

import javafx.event.EventHandler
import javafx.scene.Cursor
import javafx.scene.input.MouseEvent
import javafx.scene.shape.Rectangle

class ResizableRectangle() : Rectangle() {

    private val resizableRectangleListener: ResizableRectangleListener = object : ResizableRectangleListener {

        override var resizableRectangleCursorState: ResizableRectangleCursorState = ResizableRectangleCursorState.INIT

        private val MOUSE_MARGIN: Double = 10.0
        private val RESIZE_LIMIT: Double = MOUSE_MARGIN + 20.0

        private var pressedPoint: Pair<Double, Double>? = null

        private fun isOnLedge(mouse: Double, pos: Double): Boolean {
            return (mouse > pos - MOUSE_MARGIN && mouse < pos + MOUSE_MARGIN)
        }

        override fun onMovePressed(mouseEvent: MouseEvent, rectangle: Rectangle) {
            pressedPoint = Pair(mouseEvent.sceneX - rectangle.x, mouseEvent.sceneY - rectangle.y)
        }

        override fun onMouseRelease(mouseEvent: MouseEvent) {
            pressedPoint = null
        }

        override fun onMouseDragged(
            mouseEvent: MouseEvent,
            rectangle: Rectangle
        ) {
            when (resizableRectangleCursorState) {
                ResizableRectangleCursorState.MOVE -> {
                    pressedPoint?.let { pressedPoint ->
                        rectangle.x = mouseEvent.sceneX - pressedPoint.first
                        rectangle.y = mouseEvent.sceneY - pressedPoint.second
                    }
                }

                ResizableRectangleCursorState.LEFT -> {
                    if (RESIZE_LIMIT < (rectangle.width + (rectangle.x - mouseEvent.sceneX))) {
                        val beforeX: Double = rectangle.x
                        rectangle.x = mouseEvent.sceneX
                        rectangle.width = rectangle.width + (beforeX - rectangle.x)
                    }
                }

                ResizableRectangleCursorState.RIGHT -> {
                    if (RESIZE_LIMIT < (rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width)))) {
                        rectangle.width = rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width))
                    }
                }

                ResizableRectangleCursorState.TOP -> {
                    if (RESIZE_LIMIT < (rectangle.height + (rectangle.y - mouseEvent.sceneY))) {
                        val beforeY: Double = rectangle.y
                        rectangle.y = mouseEvent.sceneY
                        rectangle.height = rectangle.height + (beforeY - rectangle.y)
                    }
                }

                ResizableRectangleCursorState.BOTTOM -> {
                    if (RESIZE_LIMIT < (rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height)))) {
                        rectangle.height = rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height))
                    }
                }

                ResizableRectangleCursorState.TOP_LEFT -> {
                    if (RESIZE_LIMIT < (rectangle.width + (rectangle.x - mouseEvent.sceneX))) {
                        val beforeX: Double = rectangle.x
                        rectangle.x = mouseEvent.sceneX
                        rectangle.width = rectangle.width + (beforeX - rectangle.x)
                    }

                    if (RESIZE_LIMIT < (rectangle.height + (rectangle.y - mouseEvent.sceneY))) {
                        val beforeY: Double = rectangle.y
                        rectangle.y = mouseEvent.sceneY
                        rectangle.height = rectangle.height + (beforeY - rectangle.y)
                    }
                }

                ResizableRectangleCursorState.TOP_RIGHT -> {
                    if (RESIZE_LIMIT < (rectangle.height + (rectangle.y - mouseEvent.sceneY))) {
                        val beforeY: Double = rectangle.y
                        rectangle.y = mouseEvent.sceneY
                        rectangle.height = rectangle.height + (beforeY - rectangle.y)
                    }

                    if (RESIZE_LIMIT < (rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width)))) {
                        rectangle.width = rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width))
                    }
                }

                ResizableRectangleCursorState.BOTTOM_RIGHT -> {
                    if (RESIZE_LIMIT < (rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height)))) {
                        rectangle.height = rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height))
                    }

                    if (RESIZE_LIMIT < (rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width)))) {
                        rectangle.width = rectangle.width + (mouseEvent.sceneX - (rectangle.x + rectangle.width))
                    }
                }

                ResizableRectangleCursorState.BOTTOM_LEFT -> {
                    if (RESIZE_LIMIT < (rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height)))) {
                        rectangle.height = rectangle.height + (mouseEvent.sceneY - (rectangle.y + rectangle.height))
                    }

                    if (RESIZE_LIMIT < (rectangle.width + (rectangle.x - mouseEvent.sceneX))) {
                        val beforeX: Double = rectangle.x
                        rectangle.x = mouseEvent.sceneX
                        rectangle.width = rectangle.width + (beforeX - rectangle.x)
                    }
                }

                ResizableRectangleCursorState.INIT -> return
            }
        }

        override fun onMouseMoved(mouseEvent: MouseEvent, rectangle: Rectangle) {
            if (isOnLedge(mouseEvent.x, rectangle.x) && isOnLedge(mouseEvent.y, rectangle.y)) {
                cursor = Cursor.NW_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.TOP_LEFT

                return
            }

            if (isOnLedge(mouseEvent.x, rectangle.x + rectangle.width) && isOnLedge(mouseEvent.y, rectangle.y)) {
                cursor = Cursor.NE_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.TOP_RIGHT

                return
            }

            if (isOnLedge(mouseEvent.x, rectangle.x) && isOnLedge(mouseEvent.y, rectangle.y + rectangle.height)) {
                cursor = Cursor.SW_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.BOTTOM_LEFT

                return
            }

            if (isOnLedge(mouseEvent.x, rectangle.x + rectangle.width) && isOnLedge(mouseEvent.y, rectangle.y + rectangle.height)) {
                cursor = Cursor.SE_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.BOTTOM_RIGHT

                return
            }

            if (isOnLedge(mouseEvent.x, rectangle.x)) {
                cursor = Cursor.W_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.LEFT

                return
            }

            if (isOnLedge(mouseEvent.y, rectangle.y)) {
                cursor = Cursor.N_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.TOP

                return
            }

            if (isOnLedge(mouseEvent.x, rectangle.x + rectangle.width)) {
                cursor = Cursor.E_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.RIGHT

                return
            }

            if (isOnLedge(mouseEvent.y, rectangle.y + rectangle.height)) {
                cursor = Cursor.S_RESIZE
                resizableRectangleCursorState = ResizableRectangleCursorState.BOTTOM

                return
            }

            cursor = Cursor.MOVE
            resizableRectangleCursorState = ResizableRectangleCursorState.MOVE
        }
    }

    init {
        this.onMouseMoved = EventHandler<MouseEvent> { p0 ->
            p0?.let {
                resizableRectangleListener.onMouseMoved(p0, this)
            }
        }

        this.onMouseDragged = EventHandler<MouseEvent> { p0 ->
            p0?.let {
                resizableRectangleListener.onMouseDragged(p0, this)
            }
        }

        this.onMousePressed = EventHandler<MouseEvent> { p0 ->
            p0?.let {
                resizableRectangleListener.onMovePressed(p0, this)
            }
        }

        this.onMouseReleased = EventHandler<MouseEvent> { p0 ->
            p0?.let {
                resizableRectangleListener.onMouseRelease(p0)
            }
        }
    }
}