import random

from PyQt5.QtCore import QEvent, Qt
from PyQt5.QtGui import QCursor
from PyQt5.QtWidgets import QErrorMessage, QInputDialog
from scipy.spatial import Voronoi

from voronoiview.colors import Color
from voronoiview.exceptions import ExceededWindowBoundsError
from voronoiview.mode import Mode
from voronoiview.ui.opengl_widget import (set_drawing_event, set_move_bb_top_left,
                                          set_move_bb_bottom_right, reset_move_bbs,
                                          viewport_height, viewport_width)
from voronoiview.point_manager import PointManager


class _ClickFlag:

    # This is the first stage. On mouse release it goes to
    # SELECTION_MOVE.
    NONE = 0

    # We are now in selection box mode.
    SELECTION_BOX = 1

    # Second stage - we have selected a number of points
    # and now we are going to track the left mouse button
    # to translate those points. After a left click
    # this moves to SELECTED_MOVED.
    SELECTION_MOVE = 2

    # Any subsequent click in this mode will send it back
    # to NONE - we are done.
    SELECTED_MOVED = 3


# GLOBALS

# Canvas pixel border - empirical, not sure where this is stored officially
_CANVAS_BORDER = 1

# Module level flag for left click events (used to detect a left
# click hold drag)
_left_click_flag = _ClickFlag.NONE

# Variable to track the mouse state during selection movement
_last_mouse_pos = None

# Used to implement mouse dragging when clicked
_left_click_down = False

# TODO: WHEN THE GROUPING ENDS AND THE USER CANCELS THE CENTROID COUNT
#       SHOULD BE ZEROED AND REMAINING COLORS SHOULD BE REPOPULATED.
# Count of centroids for comparison with the spin widget
_centroid_count = 0
_remaining_colors = [c for c in Color if c not in [Color.BLUE, Color.GREY]]


def refresh_point_list(ctx):
    """
    Refreshes the point list display.

    @param ctx A handle to the window context.
    """
    # In order to make some guarantees and avoid duplicate
    # data we will clear the point list widget and re-populate
    # it using the current _point_set.
    ctx.point_list_widget.clear()

    for p in PointManager.point_set.points:
        ctx.point_list_widget.addItem(f"({p.x}, {p.y}) | Weight: {p.weight}")

    ctx.point_list_widget.update()

    num_of_points = len(list(PointManager.point_set.points))

    ctx.number_of_points_label.setText(str(num_of_points))


def _handle_add_point(ctx, event):
    """
    Event handler for the add point mode.

    Sets the drawing mode for the OpenGL Widget using
    `set_drawing_mode`, converts a point to our point
    representation, and adds it to the list.

    @param ctx A context handle to the main window.
    @param event The click event.
    """

    # Update information as needed
    _handle_info_updates(ctx, event)

    if (event.button() == Qt.LeftButton and
            event.type() == QEvent.MouseButtonPress):

        # At this point we can be sure resize_gl has been called
        # at least once, so set the viewport properties of the
        # point set so it knows the canvas bounds.
        PointManager.point_set.viewport_width = viewport_width()
        PointManager.point_set.viewport_height = viewport_height()

        # Clear any existing selections
        PointManager.point_set.clear_selection()

        try:
            # No attribute at the moment, default point color is Color.GREY.
            PointManager.point_set.add_point(event.x(), event.y(), Color.GREY)
        except ExceededWindowBoundsError:
            # The user tried to place a point whos edges would be
            # on the outside of the window. We will just ignore it.
            return

        refresh_point_list(ctx)

        set_drawing_event(event)

        ctx.opengl_widget.update()
        ctx.point_list_widget.update()


def _handle_edit_point(ctx, event):
    _handle_info_updates(ctx, event)
    PointManager.point_set.clear_selection()

    if (event.button() == Qt.LeftButton and
            event.type() == QEvent.MouseButtonPress):

        # See if a point was hit
        point = None

        for p in PointManager.point_set.points:
            if p.hit(event.x(), event.y()):
                point = p
                break

        # Get point weight from user and assign it to the point.
        if point is not None:
            value, ok = QInputDialog.getDouble(None, 'Weight', 'Weight(Float): ', 1, 1, 3000, 1)

            if ok:
                if not isinstance(value, float):
                    error_dialog = QErrorMessage()
                    error_dialog.showMessage('Point weight must be a floating point value.')
                    error_dialog.exec_()

                else:
                    point.weight = value

                    # Store old x, y from event
                    set_drawing_event(event)
                    ctx.update()
                    refresh_point_list(ctx)


def ogl_keypress_handler(ctx, event):
    """
    A keypress handler attached to the OpenGL widget.

    It primarily exists to allow the user to cancel selection.

    Also allows users to escape from modes.

    @param ctx A handle to the window context.
    @param event The event associated with this handler.
    """
    global _left_click_flag
    global _last_mouse_pos

    if event.key() == Qt.Key_Escape:
        if ctx.mode is Mode.MOVE:
            if _left_click_flag is not _ClickFlag.NONE:

                _last_mouse_pos = None

                _left_click_flag = _ClickFlag.NONE
                PointManager.point_set.clear_selection()
                reset_move_bbs()
                refresh_point_list(ctx)

        elif ctx.mode is not Mode.OFF:
            ctx.mode = Mode.OFF

            # Also change the mouse back to normal
            ctx.opengl_widget.setCursor(QCursor(Qt.CursorShape.ArrowCursor))
            ctx.status_bar.showMessage("")

        ctx.opengl_widget.update()


def _handle_move_points(ctx, event):
    """
    A relatively complicated state machine that handles the process of
    selection, clicking, and dragging.

    @param ctx The context to the window.
    @param event The event.
    """

    global _left_click_flag
    global _left_mouse_down
    global _last_mouse_pos

    set_drawing_event(event)

    _handle_info_updates(ctx, event)

    # If we release the mouse, we want to quickly alert drag mode.
    if (event.button() == Qt.LeftButton and
            event.type() == QEvent.MouseButtonRelease):

        _left_mouse_down = False

    # This if statement block is used to set the bounding box for
    # drawing and call the selection procedure.
    if (event.button() == Qt.LeftButton and
            event.type() == QEvent.MouseButtonPress):

        _left_mouse_down = True

        if _left_click_flag is _ClickFlag.NONE:
            _left_click_flag = _ClickFlag.SELECTION_BOX

            set_move_bb_top_left(event.x(), event.y())

        elif (_left_click_flag is _ClickFlag.SELECTION_BOX
              and _left_mouse_down):
            # We are now in the click-and-hold to signal move
            # tracking and translation
            _left_click_flag = _ClickFlag.SELECTION_MOVE
            _last_mouse_pos = (event.x(), event.y())

    # Post-selection handlers
    if (_left_click_flag is _ClickFlag.SELECTION_BOX
            and event.type() == QEvent.MouseMove):

        set_move_bb_bottom_right(event.x(), event.y())

    elif (_left_click_flag is _ClickFlag.SELECTION_MOVE
          and _last_mouse_pos is not None
          and _left_mouse_down
          and event.type() == QEvent.MouseMove):

        dx = abs(_last_mouse_pos[0] - event.x())
        dy = abs(_last_mouse_pos[1] - event.y())

        for p in PointManager.point_set.points:
            if p.selected:
                # Use the deltas to decide what direction to move.
                # We only want to move in small unit increments.
                # If we used the deltas directly the points would
                # fly off screen quickly as we got farther from our
                # start.
                try:
                    if event.x() < _last_mouse_pos[0]:
                        p.move(-dx, 0)
                    if event.y() < _last_mouse_pos[1]:
                        p.move(0, -dy)
                    if event.x() > _last_mouse_pos[0]:
                        p.move(dx, 0)
                    if event.y() > _last_mouse_pos[1]:
                        p.move(0, dy)

                except ExceededWindowBoundsError:
                    # This point has indicated a move would exceed
                    # it's bounds, so we'll just go to the next
                    # point.
                    continue

        _last_mouse_pos = (event.x(), event.y())

    elif (_left_click_flag is not _ClickFlag.NONE and
          event.type() == QEvent.MouseButtonRelease):

        if _left_click_flag is _ClickFlag.SELECTION_BOX:

            set_move_bb_bottom_right(event.x(), event.y())

            # Satisfy the post condition by resetting the bounding box
            reset_move_bbs()

    ctx.opengl_widget.update()


def _handle_delete_point(ctx, event):

    _handle_info_updates(ctx, event)

    if (event.button() == Qt.LeftButton and
            event.type() == QEvent.MouseButtonPress):

        set_drawing_event(event)

        PointManager.point_set.remove_point(event.x(), event.y())

        refresh_point_list(ctx)

        ctx.opengl_widget.update()
        ctx.point_list_widget.update()


def _handle_info_updates(ctx, event):
    """
    Updates data under the "information" header.

    @param ctx The context to the main window.
    @param event The event.
    """
    if event.type() == QEvent.MouseMove:
        ctx.mouse_position_label.setText(f"{event.x(), event.y()}")


def reset_colors():
    global _remaining_colors

    _remaining_colors = [c for c in Color if c not in [Color.BLUE, Color.GREY]]

    for point in PointManager.point_set.points:
        point.color = Color.GREY


def generate_random_points(point_count, x_bound, y_bound):
    """
    Using the random module of python generate a unique set of xs and ys
    to use as points, bounded by the canvas edges.

    @param point_count The count of points to generate.
    @param x_bound The width bound.
    @param y_bound The height bound.
    """

    # TODO: The window size should be increased slightly to
    #       accomodate 3000 points (the maximum) given the point size.
    #       Work out an algorithm and limit the number of points
    #       selectable based on the maximum amount of points on the screen
    #       given the point size.

    # First clear the point set
    PointManager.point_set.clear()

    point_size = PointManager.point_set.point_size

    # Sample without replacement so points are not duplicated.
    xs = random.sample(range(point_size, x_bound), point_count)

    ys = random.sample(range(point_size, y_bound), point_count)

    points = list(zip(xs, ys))

    for point in points:
        PointManager.point_set.add_point(point[0], point[1], Color.GREY)


def _handle_voronoi(ctx, _):

    if not ctx.voronoi_solved:
        points = list(PointManager.point_set.points)

        point_arr = [point.array for point in points]

        PointManager.voronoi_results = Voronoi(point_arr)

        ctx.opengl_widget.update()
        ctx.voronoi_solved = True


# Simple dispatcher to make it easy to dispatch the right mode
# function when the OpenGL window is acted on.
MODE_HANDLER_MAP = {
    Mode.OFF: _handle_info_updates,
    Mode.LOADED: _handle_info_updates,
    Mode.ADD: _handle_add_point,
    Mode.EDIT: _handle_edit_point,
    Mode.MOVE: _handle_move_points,
    Mode.DELETE: _handle_delete_point,
    Mode.VORONOI: _handle_voronoi
}