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


class CrazyPolys(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.8  # random.randint(self.min_velocity, self.max_velocity)
        self.ticks = 0.0
        self.color = color
        self.size = self.max_size
        # self.size = (math.sin(self.ticks) / 2 + 0.5) * (
        #     self.max_size - self.min_size
        # ) + self.min_size
        image = pg.Surface((self.max_size, self.max_size))
        image.fill(Colors.Black)
        image.set_colorkey(Colors.Black)

        self.r = random.randint(1, 50)
        self.R = self.r * random.randint(1, 5)
        self.a = random.randint(1, self.r)
        self.nu = random.choice([-1, 1])

        self.R_nu_r = self.R + self.nu * self.r
        self.R_nu_r_divr = self.R_nu_r / self.r
        # self.R = random.randint(1, 50) / 2
        # self.r = random.randint(1, int(self.R + 0.6)) / 2
        # self.a = random.randint(1, int(self.r + 0.6))
        print(f"R:{self.R} r:{self.r} a:{self.a}")

        self.background = pg.Surface((self.max_size, self.max_size))
        self.background.fill(Colors.Black)
        # self.background.set_alpha(4)
        self.background.set_alpha(20)

        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.size_f = (self.size * 0.6 - 10) / 2 / (self.R + self.r)
        self.cursor = self.calc_pos()
        self.update()

    def calc_pos(self):
        x = self.max_size / 2 + self.size_f * (
            (self.R_nu_r) * math.cos(self.ticks)
            - self.a * self.nu * math.cos(self.R_nu_r_divr * self.ticks)
        )
        y = self.max_size / 2 + self.size_f * (
            (self.R_nu_r) * math.sin(self.ticks)
            - self.a * math.sin(self.R_nu_r_divr * self.ticks)
        )
        # x = self.max_size / 2 + self.size_f * (
        #     (self.R - self.r) * math.cos(self.r / self.R * self.ticks)
        #     + self.a * math.cos((1 - self.r / self.R) * self.ticks)
        # )
        # y = self.max_size / 2 + self.size_f * (
        #     (self.R - self.r) * math.sin(self.r / self.R * self.ticks)
        #     + self.a * math.sin((1 - self.r / self.R) * 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))

        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

        # pg.draw.ellipse(
        #     self.image,
        #     self.color if isinstance(self.color, pg.Color) else next(self.color),
        #     ((0, 0), self.rect.size),
        # )

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