from typing import Any
import pygame as pg
from effects.effect import Effect, Colors, copy_color, transform_bounce
import random
import math
from typing import Union, Generator


class Spiro(Effect):
    def __init__(
        self,
        bounds: pg.Rect,
        color: Union[pg.Color, Generator[pg.Color, None, None]],
        sizes=(100, 500),
        velocity=(0.1, 1),
        x_factor=(0.1, 1),
        y_factor=(0.1, 1),
        segments=100,
        *groups: pg.sprite.Group,
    ) -> None:
        self.min_size = sizes[0]
        self.max_size = sizes[1]
        self.min_velocity = velocity[0]
        self.max_velocity = velocity[1]

        self.velocity = 0.1 # random.uniform(self.min_velocity, self.max_velocity)
        self.ticks = 0.0
        self.color = color
        self.size = self.max_size
        image = pg.Surface((self.max_size, self.max_size))
        image.fill(Colors.Black)
        image.set_colorkey(Colors.Black)

        self.R = random.randint(self.max_size / 6, self.max_size / 2)
        self.a = 3/random.randint(4, 10)  #random.uniform(0, 1)
        self.k = 3/random.randint(4, 10) #random.uniform(0, 1)

        self.scan_speed = random.randint(1, 100)

        self.one_minus_k = 1 - self.k
        self.one_minus_k_div_k = self.one_minus_k / self.k
        self.ak = self.a * self.k

        print(f"R:{self.R} l:{self.a} k:{self.k}")

        self.background = pg.Surface((self.max_size, self.max_size))
        self.background.fill(Colors.Black)
        # self.background.set_alpha(4)
        self.background.set_alpha(random.randint(1, 30))

        super().__init__(
            image,
            pg.Rect(
                bounds.centerx - self.size / 2,
                bounds.centery - self.size / 2,
                self.size,
                self.size,
            ),
            *groups,
        )
        self.bounds = bounds
        self.bouncer = transform_bounce(
            bounds=bounds, velocity=velocity, x_factor=x_factor, y_factor=y_factor
        )
        next(self.bouncer)

        self.cursor = self.calc_pos()
        self.update()

    def calc_pos(self):
        x = self.max_size / 2 + self.R * (
            self.one_minus_k * math.cos(self.ticks)
            + self.ak * math.cos(self.one_minus_k_div_k * self.ticks)
        )
        y = self.max_size / 2 + self.R * (
            self.one_minus_k * math.sin(self.ticks)
            - self.ak * math.sin(self.one_minus_k_div_k * self.ticks)
        )
        return x, y

    def update(self, *args: Any, **kwargs: Any) -> None:
        # new_size = (math.sin(self.ticks) / 2 + 0.5) * (
        #     self.max_size - self.min_size
        # ) + self.min_size

        # new_scale = new_size - self.rect.width
        # self.rect.inflate_ip(new_scale, new_scale)

        self.rect.center = self.bouncer.send(self.rect.size)

        self.image.blit(self.background, (0, 0))

        for _ in range(self.scan_speed):
            new_cursor = self.calc_pos()
            pg.draw.line(
                self.image,
                self.color if isinstance(self.color, pg.Color) else next(self.color),
                self.cursor,
                new_cursor,
                width=10,
            )
            self.cursor = new_cursor
            self.ticks += self.velocity

        # self.velocity = random.randint(self.min_velocity, self.max_velocity)