<?php

declare(strict_types=1);

namespace Tez\Utils\Tests\Enum;

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

// String-backed enum
enum Color: string
{
    use BackedEnumTrait;

    case Red   = 'red';
    case Green = 'green';
    case Blue  = 'blue';
}

// Integer-backed enum
enum Priority: int
{
    use BackedEnumTrait;

    case Low    = 1;
    case Medium = 2;
    case High   = 3;
}

final class BackedEnumTraitTest extends TestCase
{
    // -------------------------------------------------------------------------
    // values()
    // -------------------------------------------------------------------------

    public function testValuesReturnsAllStringValues(): void
    {
        self::assertSame(['red', 'green', 'blue'], Color::values());
    }

    public function testValuesReturnsAllIntValues(): void
    {
        self::assertSame([1, 2, 3], Priority::values());
    }

    // -------------------------------------------------------------------------
    // hasValue()
    // -------------------------------------------------------------------------

    public function testHasValueReturnsTrueForExistingValue(): void
    {
        self::assertTrue(Color::hasValue('green'));
        self::assertTrue(Priority::hasValue(2));
    }

    public function testHasValueReturnsFalseForUnknownValue(): void
    {
        self::assertFalse(Color::hasValue('yellow'));
        self::assertFalse(Priority::hasValue(99));
    }

    public function testHasValueIsStrictlyTyped(): void
    {
        // integer 1 must not match string '1'
        self::assertFalse(Color::hasValue(1));
    }

    // -------------------------------------------------------------------------
    // fromName()
    // -------------------------------------------------------------------------

    public function testFromNameReturnsCorrectCase(): void
    {
        self::assertSame(Color::Blue, Color::fromName('Blue'));
        self::assertSame(Priority::High, Priority::fromName('High'));
    }

    public function testFromNameThrowsValueErrorForUnknownName(): void
    {
        $this->expectException(\ValueError::class);
        Color::fromName('Purple');
    }

    // -------------------------------------------------------------------------
    // tryFromName()
    // -------------------------------------------------------------------------

    public function testTryFromNameReturnsCorrectCase(): void
    {
        self::assertSame(Color::Red, Color::tryFromName('Red'));
    }

    public function testTryFromNameReturnsNullForUnknownName(): void
    {
        self::assertNull(Color::tryFromName('Magenta'));
    }

    // -------------------------------------------------------------------------
    // toArray() — inherited via EnumTrait, but backed path tested here
    // -------------------------------------------------------------------------

    public function testToArrayReturnsValueToNameMapping(): void
    {
        self::assertSame(
            ['red' => 'Red', 'green' => 'Green', 'blue' => 'Blue'],
            Color::toArray(),
        );
    }

    public function testToArrayForIntBackedEnum(): void
    {
        self::assertSame(
            [1 => 'Low', 2 => 'Medium', 3 => 'High'],
            Priority::toArray(),
        );
    }

    // -------------------------------------------------------------------------
    // is() with scalar (backed enum path)
    // -------------------------------------------------------------------------

    public function testIsReturnsTrueForMatchingValue(): void
    {
        self::assertTrue(Color::Green->is('green'));
    }

    public function testIsReturnsFalseForOtherValue(): void
    {
        self::assertFalse(Color::Green->is('red'));
    }

    public function testIsReturnsTrueForIntValue(): void
    {
        self::assertTrue(Priority::Medium->is(2));
    }

    // -------------------------------------------------------------------------
    // find() — backed enum paths (value + case-insensitive)
    // -------------------------------------------------------------------------

    public function testFindByValue(): void
    {
        self::assertSame(Color::Blue, Color::find('blue'));
    }

    public function testFindByValueCaseInsensitive(): void
    {
        self::assertSame(Color::Red, Color::find('RED', ignoreCase: true));
    }

    public function testFindByNameCaseInsensitive(): void
    {
        self::assertSame(Color::Green, Color::find('green', ignoreCase: true));
    }

    public function testFindReturnsNullForUnknown(): void
    {
        self::assertNull(Color::find('violet'));
    }

    // -------------------------------------------------------------------------
    // toValueArray()
    // -------------------------------------------------------------------------

    public function testToValueArrayReturnsNameToValueMapping(): void
    {
        self::assertSame(
            ['Red' => 'red', 'Green' => 'green', 'Blue' => 'blue'],
            Color::toValueArray(),
        );
    }

    public function testToValueArrayForIntBackedEnum(): void
    {
        self::assertSame(
            ['Low' => 1, 'Medium' => 2, 'High' => 3],
            Priority::toValueArray(),
        );
    }
}