"""CSC110 Fall 2022 Prep 10: Programming Exercises

Instructions (READ THIS FIRST!)
===============================

This Python module contains a new *class definition* with attributes and representation
invariants already defined. We have started a few different methods in the class body,
and your task is to implement EACH method based on the method header and description.

There are two helper functions we have provided near the bottom of this file; please do
not modify either of them.

We have marked each place you need to write code with the word "TODO".
As you complete your work in this file, delete each TODO comment.

You do not need to add additional doctests. However, you should test your work carefully
before submitting it!

Copyright and Usage Information
===============================

This file is provided solely for the personal and private use of students
taking CSC110 at the University of Toronto St. George campus. All forms of
distribution of this code, whether as given or with any changes, are
expressly prohibited. For more information on copyright for CSC110 materials,
please consult our Course Syllabus.

This file is Copyright (c) 2022 David Liu and Mario Badr.
"""
import colorsys
import math
import random
import pygame

from python_ta.contracts import check_contracts


@check_contracts
class Spinner:
    """A spinner for a board game.

    A spinner has a certain number of slots, numbered starting at 0 and
    increasing by 1 each slot. For example, if the spinner has 6 slots,
    they are numbered 0 through 5, inclusive.

    A spinner also has an arrow that points to one of these slots.

    Instance Attributes:
      - slots: The number of slots in this spinner.
      - position: The slot number that the spinner's arrow is currently pointing to.

    Representation Invariants:
      - 0 <= self.position < self.slots

    Sample Usage:

    >>> s = Spinner(8)  # Create a spinner with 8 slots
    >>> s.position      # A spinner initially points to slot 0
    0
    >>> s.spin(4)
    >>> s.position
    4
    >>> s.spin(2)
    >>> s.position
    6
    >>> s.spin(2)
    >>> s.position
    0
    """
    slots: int
    position: int

    def __init__(self, size: int) -> None:
        """Initialize a new spinner with the given number of slots.

        A spinner's position always starts at 0 (so there is no "position"
        argument for the initializer).

        Preconditions:
            - size >= 1
        """
        self.position = 0
        self.slots = size

    def spin(self, force: int) -> None:
        """Spin this spinner, advancing the arrow <force> slots.

        The spinner wraps around once it reaches its maximum slot, starting
        back at 0. See the class docstring for an example of this.

        Preconditions:
            - force >= 0
        """
        p_max = self.position + force
        self.position = p_max % self.slots

    def spin_randomly(self) -> None:
        """Spin this spinner randomly.

        This modifies the spinner's position to a random slot on the
        spinner. Each slot has an equal chance of being pointed to.

        >>> s = Spinner(8)
        >>> s.spin_randomly()
        >>> 0 <= s.position < 8
        True
        """
        self.position = random.randint(0, self.slots - 1)

    def draw(self, screen: pygame.Surface) -> None:
        """Draw this spinner onto the given pygame screen.

        (See starter file images for some examples.)

        The drawing of the spinner consists of two parts:

        1. The outline of a circle that fills the given screen (we have provided this part
           for you already).
        2. The circle is filled by equal sectors, one for each slot. The first sector
           (corresponding to slot 0) should start on the radius of the circle extending
           horizontally to the right of the circle's centre, and extend counter-clockwise.
           The remaining sectors are numbered in counter-clockwise order starting from
           this first sector.

           For example, if self.slots == 6, each sector spans 60 degrees (pi / 3 radians),
           starting at the "positive x direction" relative to the circle's centre.

           Each slot has a colour chosen by the provided get_colour function (don't change
           this function!). See below for some implementation notes.

        Note: This method will display an empty circle if the number of slots in the spinner
        is too high for a small screen size. This is normal, and you don't need to fix this.

        Preconditions:
            - screen.get_width() == screen.get_height()  # screen must be a square
        """
        screen_rect = screen.get_rect()  # A pygame Rect representing the full screen
        radius = screen_rect.width // 2  # The radius of the circle

        # 2. Draw the sectors.
        for slot in range(0, self.slots):
            # Draw each the sector for slot i using the pygame.draw.arc function.
            # First, you should read the documentation for this function here:
            # https://www.pygame.org/docs/ref/draw.html#pygame.draw.arc
            # You'll need to pass in all six arguments to pygame.draw.arc.
            # The SURFACE and RECT should be based on the full screen;
            # the COLOR should be the value obtained from calling our provided
            # helper function Spinner.get_colour;
            # the WIDTH argument should be the radius of the circle;
            # and the START_ANGLE and STOP_ANGLE should be calculated by doing a
            # bit of math. Note that the angles are all calculated in radians,
            # so you should use the constant math.pi in your calculation.
            # Hint: slot 0's sector starts with start_angle == 0.
            #
            # One limitation of pygame is that is doesn't do filled-in arcs very well.
            # To compensate for this, try adding a small value to the stop angles
            # of each sector to fill in the gaps that you'll see if you just use the
            # angles you get from evenly dividing the circle.
            # We aren't grading your choice of "small value", but we do want you to
            # experiment with it a little.
            surface = screen
            color = self.get_colour(slot)
            rect = screen_rect
            start_angle = slot * ((math.pi * 2) / self.slots)
            stop_angle = (slot + 1) * ((math.pi * 2) / self.slots)
            pygame.draw.arc(surface, color, rect, start_angle, stop_angle, width=radius)

        # 1. Draw the circle outline. (This comes second to ensure it is drawn above the
        #    slot sectors.)
        pygame.draw.circle(screen, pygame.Color('black'), (radius, radius), radius, 3)

    def get_colour(self, slot: int) -> tuple[int, int, int]:
        """Return a unique pygame colour to use for the slot in spinner.

        The returned colour is grayscale when the slot is not currently selected.
        Note: Some colours may not be distinct when the spinner has over 600 slots.

        Preconditions:
            - 0 <= slot < self.slots

        You should not modify this function.
        """
        selected_colour = float_to_colour(slot / self.slots)
        if self.position == slot:
            return selected_colour
        else:
            gray_avg = sum(selected_colour) // 3
            return gray_avg, gray_avg, gray_avg


###############################################################################
# Helper functions (Pygame and colours)
###############################################################################
def run_example(spinner: Spinner) -> None:
    """Show a window that visualizes a spinner.

    You can use this function to test your other functions, and are
    free to modify this function as well.

    When you call this function, the spinner will appear in a Pygame window.
    The spinner can be spun randomly by pressing the space bar.
    """
    # We must first initialize pygame
    pygame.init()

    # Create a screen that we can draw on
    size = (500, 500)
    screen = pygame.display.set_mode(size)

    # Visualize the spinner
    screen.fill(pygame.Color('white'))
    spinner.draw(screen)
    pygame.display.flip()

    # Start the event loop
    while True:
        # Process events
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                # Exit the event loop
                pygame.quit()
                return
            if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
                # Spin the spinner
                spinner.spin_randomly()

                screen.fill(pygame.Color('white'))
                spinner.draw(screen)
                pygame.display.flip()


@check_contracts
def float_to_colour(x: float) -> tuple[int, int, int]:
    """Return an RGB24 colour computed from x.

    This uses x to pick a "direction on the colour wheel", using the colorsys module
    that comes with Python. You aren't responsible for knowing about how this works,
    but if you're interested you can read more about the HSV colour model at
    https://www.lifewire.com/what-is-hsv-in-design-1078068.

    Preconditions:
    - 0.0 <= x <= 1.0
    """
    rgb = colorsys.hsv_to_rgb(x, 1.0, 1.0)
    return round(rgb[0] * 255), round(rgb[1] * 255), round(rgb[2] * 255)


if __name__ == '__main__':
    import doctest
    doctest.testmod(verbose=True)

    # When you are ready to check your work with python_ta, uncomment the following lines.
    # (In PyCharm, select the lines below and press Ctrl/Cmd + / to toggle comments.)
    import python_ta
    python_ta.check_all(config={
        'max-line-length': 120,
        'extra-imports': ['colorsys', 'math', 'random', 'pygame'],
        'disable': ['use-a-generator'],
        'generated-members': ['pygame.*']
    })