<?php

declare(strict_types=1);

namespace LIT\MCP\Tests\Unit\Integrations\Divi\Release;

use Brain\Monkey\Functions;
use LIT\MCP\Integrations\Divi\Release\CheckStep;
use LIT\MCP\Integrations\Divi\Release\CompatibilityCheck;
use LIT\MCP\Integrations\Divi\Release\FormatCheck;
use LIT\MCP\Integrations\Divi\Release\ManifestCheck;
use LIT\MCP\Integrations\Divi\Release\WriteProbe;
use LIT\MCP\Plugin;
use LIT\MCP\Tests\Unit\TestCase;
use Mockery;
use RuntimeException;

final class CompatibilityCheckTest extends TestCase
{
    private function check(
        array $code,
        array $mirrors,
        ?WriteProbe $probe = null,
        ?\Closure $catalog = null
    ): CompatibilityCheck {
        Functions\when('wp_generate_uuid4')->justReturn('uuid-1');
        $manifests = Mockery::mock(ManifestCheck::class);
        $manifests->allows('codeChecks')->andReturn($code);
        $manifests->allows('registrationChecks')->andReturn([]);
        $manifests->allows('mirrorChecks')->andReturn($mirrors);
        $format = Mockery::mock(FormatCheck::class);
        $format->allows('problems')->andReturn([]);
        if ($probe === null) {
            $probe = Mockery::mock(WriteProbe::class);
            $probe->allows('run')->andReturn([]);
        }

        return new CompatibilityCheck(
            $manifests,
            $catalog ?? static fn (): array => [],
            $format,
            $probe,
            static fn (): string => '5.3.0',
            static fn (string $version): string => 'key-' . $version
        );
    }

    public function testAGreenRunNamesVersionsAndStateKey(): void
    {
        $report = $this->check([], [])->run(7);

        self::assertTrue($report->green());
        self::assertSame(['uuid-1', 7, '5.3.0', Plugin::VERSION, 'key-5.3.0'], [
            $report->id, $report->userId, $report->diviVersion, $report->pluginVersion, $report->stateKey,
        ]);
        self::assertSame(
            ['manifest', 'mirrors', 'catalog', 'format', 'write'],
            array_map(static fn (CheckStep $step): string => $step->key, $report->steps)
        );
    }

    public function testNoWriteTestWhenDiviFunctionsAreMissing(): void
    {
        $probe = Mockery::mock(WriteProbe::class);
        $probe->expects('run')->never();

        $report = $this->check(['Seiten: et_x()' => static fn (): bool => false], [], $probe)->run(7);

        self::assertSame(['Seiten: et_x()'], $report->step(CheckStep::MANIFEST)?->problems);
        self::assertTrue($report->step(CheckStep::WRITE)?->skipped);
    }

    public function testChangedFingerprintsStillRunTheWriteTest(): void
    {
        $probe = Mockery::mock(WriteProbe::class);
        $probe->expects('run')->once()->andReturn([]);

        $report = $this->check([], ['TB: Nachbau von y()' => static fn (): bool => false], $probe)->run(7);

        self::assertFalse($report->green());
        self::assertTrue($report->step(CheckStep::WRITE)?->green());
    }

    public function testAThrowingStepIsARedStep(): void
    {
        $report = $this->check([], [], null, static function (): never {
            throw new RuntimeException('Katalog weg');
        })->run(7);

        self::assertSame(['Prüfschritt abgebrochen: Katalog weg'], $report->step(CheckStep::CATALOG)?->problems);
    }
}