"""A game mode that spawns three spinning coins to collect in Play In Editor."""

from __future__ import annotations

import enum

import ue

COINS = 3
SPHERE = ue.load_object("/Engine/BasicShapes/Sphere.Sphere")


@ue.uenum
class ECoinPhase(enum.IntEnum):
    PLAYING = 0
    WON = 1


@ue.ustruct
class CoinScore(ue.StructBase):
    coins: int = 0
    phase: ECoinPhase = ECoinPhase.PLAYING


@ue.uclass
class Spinner(ue.ActorComponent):
    """Turns its actor around the vertical axis."""

    degrees_per_second: float = ue.uproperty(90.0)

    def tick(self, delta_seconds: float) -> None:
        owner = self.get_owner()
        if owner is not None:
            owner.add_actor_local_rotation(
                ue.Rotator(0.0, self.degrees_per_second * delta_seconds, 0.0), False, True
            )


@ue.uclass
class Coin(ue.Actor):
    trigger = ue.component(ue.SphereComponent, sphere_radius=60.0)
    mesh = ue.component(ue.StaticMeshComponent, static_mesh=SPHERE, relative_scale3d=ue.Vector(0.5, 0.5, 0.1))
    spinner = ue.component(Spinner)

    def begin_play(self) -> None:
        self.mesh.set_collision_enabled(ue.ECollisionEnabled.NoCollision)  # only the trigger touches

    def actor_begin_overlap(self, other_actor: ue.Actor | None) -> None:
        mode = ue.GameplayStatics.get_game_mode()
        if isinstance(other_actor, ue.Pawn) and isinstance(mode, CoinMode):
            mode.collect(self)


@ue.uclass
class CoinMode(ue.GameModeBase):
    default_pawn_class = ue.DefaultPawn  # an inherited property, set like in a C++ constructor
    score: CoinScore = ue.uproperty(default_factory=CoinScore)

    def begin_play(self) -> None:
        for index in range(COINS):
            ue.spawn_actor(Coin, ue.Vector(300.0 * (index + 1), 0.0, 100.0))

    def collect(self, coin: Coin) -> None:
        coin.destroy_actor()
        score = self.score
        score.coins += 1
        if score.coins == COINS:
            score.phase = ECoinPhase.WON
        self.score = score
        ue.log(f"Coins: {score.coins}/{COINS} ({score.phase.name})")
