<?php

declare(strict_types=1);

namespace Tez\Utils\Tests\Enum;

use PHPUnit\Framework\TestCase;
use Tez\Utils\Enum\EnumCollectionTrait;

enum Suit: string
{
    use EnumCollectionTrait;

    case Hearts   = 'H';
    case Diamonds = 'D';
    case Clubs    = 'C';
    case Spades   = 'S';
}

enum Compass
{
    use EnumCollectionTrait;

    case North;
    case East;
    case South;
    case West;
}

final class EnumCollectionTraitTest extends TestCase
{
    // -------------------------------------------------------------------------
    // random()
    // -------------------------------------------------------------------------

    public function testRandomReturnsACaseInstance(): void
    {
        $case = Suit::random();

        self::assertInstanceOf(Suit::class, $case);
    }

    public function testRandomEventuallyReturnsAllCases(): void
    {
        $seen = [];

        for ($i = 0; $i < 200; $i++) {
            $seen[Suit::random()->name] = true;
        }

        self::assertCount(4, $seen, 'Expected all 4 suits to appear within 200 draws');
    }

    public function testRandomWorksForPureEnum(): void
    {
        $case = Compass::random();

        self::assertInstanceOf(Compass::class, $case);
    }

    // -------------------------------------------------------------------------
    // except()
    // -------------------------------------------------------------------------

    public function testExceptRemovesGivenCases(): void
    {
        $result = Suit::except(Suit::Hearts, Suit::Spades);

        self::assertSame([Suit::Diamonds, Suit::Clubs], $result);
    }

    public function testExceptWithNoCasesReturnsAll(): void
    {
        self::assertSame(Suit::cases(), Suit::except());
    }

    public function testExceptWithAllCasesReturnsEmpty(): void
    {
        $result = Suit::except(...Suit::cases());

        self::assertSame([], $result);
    }

    public function testExceptPreservesEnumOrder(): void
    {
        $result = Suit::except(Suit::Diamonds);

        self::assertSame([Suit::Hearts, Suit::Clubs, Suit::Spades], $result);
    }

    public function testExceptWorksForPureEnum(): void
    {
        $result = Compass::except(Compass::North, Compass::South);

        self::assertSame([Compass::East, Compass::West], $result);
    }

    // -------------------------------------------------------------------------
    // only()
    // -------------------------------------------------------------------------

    public function testOnlyReturnsRequestedCases(): void
    {
        $result = Suit::only(Suit::Hearts, Suit::Spades);

        self::assertSame([Suit::Hearts, Suit::Spades], $result);
    }

    public function testOnlyPreservesEnumDefinitionOrder(): void
    {
        // Pass in reverse order — result must follow enum definition order
        $result = Suit::only(Suit::Spades, Suit::Hearts);

        self::assertSame([Suit::Hearts, Suit::Spades], $result);
    }

    public function testOnlyWithNoCasesReturnsEmpty(): void
    {
        self::assertSame([], Suit::only());
    }

    public function testOnlyWithAllCasesReturnsAll(): void
    {
        $result = Suit::only(...Suit::cases());

        self::assertSame(Suit::cases(), $result);
    }

    public function testOnlyWorksForPureEnum(): void
    {
        $result = Compass::only(Compass::East, Compass::West);

        self::assertSame([Compass::East, Compass::West], $result);
    }
}