<?php

declare(strict_types=1);

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

use Brain\Monkey\Actions;
use Brain\Monkey\Functions;
use LIT\MCP\Admin\AdminPostAction;
use LIT\MCP\Integrations\Divi\Admin\DiviTab;
use LIT\MCP\Integrations\Divi\Release\CheckReport;
use LIT\MCP\Integrations\Divi\Release\CheckReportStore;
use LIT\MCP\Integrations\Divi\Release\CheckStep;
use LIT\MCP\Integrations\Divi\Release\DiviFeature;
use LIT\MCP\Integrations\Divi\Release\FeatureOverview;
use LIT\MCP\Integrations\Divi\Release\FeatureStatus;
use LIT\MCP\Integrations\Divi\Release\ReleaseGate;
use LIT\MCP\Integrations\Divi\Release\ReleaseState;
use LIT\MCP\Integrations\Divi\Release\ReleaseStatus;
use LIT\MCP\Integrations\Divi\Release\ReleaseStore;
use LIT\MCP\Integrations\Divi\Release\WriteProbe;
use LIT\MCP\Plugin;
use LIT\MCP\Tests\Support\FakeChangeLog;
use LIT\MCP\Tests\Support\FeatureFakeTool;
use LIT\MCP\Tests\Support\MatrixFixtures;
use LIT\MCP\Tests\Support\ReleaseMatrices;
use LIT\MCP\Tests\Unit\TestCase;
use Mockery;
use WP_Post;

final class DiviTabTest extends TestCase
{
    private ?string $redirect = null;

    protected function setUp(): void
    {
        parent::setUp();
        $this->redirect = null;
        Functions\stubEscapeFunctions();
        Functions\stubTranslationFunctions();
        Functions\when('current_user_can')->justReturn(true);
        Functions\when('check_admin_referer')->justReturn(1);
        Functions\when('get_current_user_id')->justReturn(1);
        Functions\when('wp_safe_redirect')->alias(function (string $url): bool {
            $this->redirect = $url;

            return true;
        });
        Functions\when('admin_url')->alias(static fn (string $path = ''): string => 'https://k.de/wp-admin/' . $path);
        Functions\when('add_query_arg')->alias(
            static fn (array $args, string $url): string => $url . '?' . http_build_query($args)
        );
        Functions\when('sanitize_key')->alias(static fn (string $key): string => strtolower($key));
    }

    protected function tearDown(): void
    {
        unset($_GET['tab']);
        parent::tearDown();
    }

    private static function report(bool $green = true, string $version = '5.3.0', string $key = 'key'): CheckReport
    {
        $steps = array_map(
            static fn (string $step): CheckStep => new CheckStep($step, $green ? [] : ['rot']),
            [CheckStep::MANIFEST, CheckStep::MIRRORS, CheckStep::CATALOG, CheckStep::FORMAT, CheckStep::WRITE]
        );

        return new CheckReport('r1', '2026-10-01T08:00:00+00:00', 1, $version, Plugin::VERSION, $key, $steps);
    }

    private function tab(
        ?CheckReport $report,
        ReleaseStore $releases,
        ?FakeChangeLog $log = null,
        ?FeatureOverview $overview = null
    ): DiviTab {
        $reports = Mockery::mock(CheckReportStore::class);
        $reports->allows('latest')->andReturn($report);

        return new DiviTab(
            $reports,
            $releases,
            $log ?? FakeChangeLog::forbidden(),
            new AdminPostAction(static function (): void {
            }),
            static fn (): string => '5.3.0',
            static fn (string $version): string => 'key',
            $overview
        );
    }

    public function testReleaseNeedsAFreshGreenReport(): void
    {
        $reports = [null, self::report(false), self::report(true, '5.2.9'), self::report(true, '5.3.0', 'old')];
        foreach ($reports as $report) {
            $this->redirect = null;
            $releases = Mockery::mock(ReleaseStore::class);
            $releases->expects('add')->never();

            $this->tab($report, $releases)->release();

            self::assertStringContainsString('lit_mcp_notice=divi_release_refused', (string) $this->redirect);
        }
    }

    public function testReleaseStoresTheEntryAndLogsIt(): void
    {
        $releases = Mockery::mock(ReleaseStore::class);
        $releases->expects('add')->once()->with('5.3.0', Plugin::VERSION, 1, 'r1');
        $log = new FakeChangeLog();

        $this->tab(self::report(), $releases, $log)->release();

        self::assertStringContainsString('lit_mcp_notice=divi_released', (string) $this->redirect);
        self::assertSame('lit/divi-release', $log->records[0]['ability']);
        self::assertStringContainsString('Divi 5.3.0', $log->records[0]['summary']);
    }

    public function testWithdrawRemovesTheEntryOfTheInstalledVersion(): void
    {
        $releases = Mockery::mock(ReleaseStore::class);
        $releases->expects('withdraw')->once()->with('5.3.0', Plugin::VERSION)->andReturn(true);
        $log = new FakeChangeLog();

        $this->tab(null, $releases, $log)->withdraw();

        self::assertStringContainsString('lit_mcp_notice=divi_withdrawn', (string) $this->redirect);
        self::assertSame('lit/divi-release', $log->records[0]['ability']);
    }

    public function testActionsNeedNonceAndManageOptions(): void
    {
        Functions\when('current_user_can')->justReturn(false);
        Functions\expect('wp_die')->twice()->andReturnUsing(static function (): never {
            throw new \RuntimeException('died');
        });
        $releases = Mockery::mock(ReleaseStore::class);
        $releases->expects('add')->never();
        $releases->expects('withdraw')->never();
        $tab = $this->tab(self::report(), $releases);

        foreach (['release', 'withdraw'] as $method) {
            try {
                $tab->{$method}();
                self::fail($method . ' without manage_options');
            } catch (\RuntimeException $e) {
                self::assertSame('died', $e->getMessage());
            }
        }

    }

    public function testReleaseChecksTheNonce(): void
    {
        Functions\when('check_admin_referer')->alias(static function (string $action): never {
            throw new \RuntimeException('bad nonce for ' . $action);
        });
        $releases = Mockery::mock(ReleaseStore::class);
        $releases->expects('add')->never();

        $this->expectExceptionMessage('bad nonce for lit_mcp_divi_release');
        $this->tab(self::report(), $releases)->release();
    }

    /** @return string The rendered tab. */
    private function rendered(ReleaseStatus $status, ?CheckReport $report, ?DiviTab $tab = null): string
    {
        return $this->renderedTab($status, $tab ?? $this->tab($report, Mockery::mock(ReleaseStore::class)));
    }

    private function renderedWith(ReleaseStatus $status, ?CheckReport $report, FeatureOverview $overview): string
    {
        return $this->renderedTab(
            $status,
            $this->tab($report, Mockery::mock(ReleaseStore::class), null, $overview)
        );
    }

    private function renderedTab(ReleaseStatus $status, DiviTab $tab): string
    {
        ReleaseGate::useResolver(static fn (): ReleaseStatus => $status);
        Functions\when('rest_url')->justReturn('https://k.de/wp-json/lit-mcp/v1/divi-check');
        Functions\when('wp_create_nonce')->justReturn('n');
        Functions\when('wp_nonce_field')->justReturn('');
        Functions\when('submit_button')->alias(static function (string $text, string $type = 'primary'): void {
            echo '<button class="' . $type . '">' . $text . '</button>';
        });
        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Jan']);
        Functions\when('date_i18n')->justReturn('01.10.2026 10:00');
        Functions\when('get_option')->justReturn('d.m.Y');

        ob_start();
        $tab->render();

        return (string) ob_get_clean();
    }

    public function testUntestedWithAFreshGreenReportOffersTheRelease(): void
    {
        $html = $this->rendered(ReleaseMatrices::uniform(ReleaseState::Untested), self::report());

        self::assertStringContainsString('ungetestet', $html);
        self::assertStringContainsString('Prüfung starten', $html);
        self::assertStringContainsString('Divi 5.3.0 freigeben', $html);
        self::assertStringContainsString('name="_wpnonce" value="n"', $html);
    }

    public function testCheckButtonSaysWhatItDoesAndLeadsWhileNothingElseCanBeDone(): void
    {
        $stale = $this->rendered(ReleaseMatrices::uniform(ReleaseState::Untested), self::report(true, '5.2.9'));
        $fresh = $this->rendered(ReleaseMatrices::uniform(ReleaseState::Untested), self::report());
        $released = $this->rendered(ReleaseMatrices::released('5.3.0'), self::report());

        foreach ([$stale, $fresh, $released] as $html) {
            self::assertStringContainsString('legt eine private Testseite an', $html);
        }
        self::assertStringContainsString('<button class="primary">Prüfung starten</button>', $stale);
        self::assertStringContainsString('<button class="secondary">Prüfung starten</button>', $fresh);
        self::assertStringContainsString('<button class="primary">Divi 5.3.0 freigeben</button>', $fresh);
        self::assertStringContainsString('<button class="secondary">Prüfung starten</button>', $released);
    }

    public function testUntestedWithAStaleReportAsksForANewCheck(): void
    {
        $html = $this->rendered(ReleaseMatrices::uniform(ReleaseState::Untested), self::report(true, '5.2.9'));

        self::assertStringNotContainsString('Divi 5.3.0 freigeben', $html);
        self::assertStringContainsString('Prüfung erneut ausführen', $html);
    }

    public function testReleasedFromCodeOffersNeitherReleaseNorWithdrawal(): void
    {
        $html = $this->rendered(ReleaseMatrices::released('5.3.0'), self::report());

        self::assertStringContainsString('freigegeben', $html);
        self::assertStringContainsString('im Plugin als getestet hinterlegt', $html);
        self::assertStringNotContainsString('freigeben</button>', $html);
        self::assertStringNotContainsString('Freigabe zurückziehen', $html);
    }

    public function testAnAutomaticReleaseSaysSoAndOffersNeitherReleaseNorWithdrawal(): void
    {
        $html = $this->rendered(ReleaseMatrices::released('5.99.0', ReleaseStatus::SOURCE_AUTO), self::report());

        self::assertStringContainsString('Automatisch freigegeben', $html);
        self::assertStringNotContainsString('freigeben</button>', $html);
        self::assertStringNotContainsString('Freigabe zurückziehen', $html);
    }

    public function testADatabaseReleaseCanBeWithdrawn(): void
    {
        $status = ReleaseMatrices::released('5.3.0', ReleaseStatus::SOURCE_DATABASE, [
            'released_at' => '2026-10-01T08:00:00+00:00', 'user_id' => 1,
        ]);

        self::assertStringContainsString('Freigabe zurückziehen', $this->rendered($status, self::report()));
    }

    public function testWithoutDiviShowsOnlyAShortNotice(): void
    {
        ReleaseGate::useResolver(static function (): ReleaseStatus {
            self::fail('resolver called although Divi is not active');
        });
        $reports = Mockery::mock(CheckReportStore::class);
        $reports->expects('latest')->never();
        $tab = new DiviTab(
            $reports,
            Mockery::mock(ReleaseStore::class),
            FakeChangeLog::forbidden(),
            new AdminPostAction(static function (): void {
            }),
            static fn (): string => '',
            static fn (string $version): string => 'key'
        );

        ob_start();
        $tab->render();
        $html = (string) ob_get_clean();

        self::assertStringContainsString(
            'Divi ist auf dieser Website nicht aktiv; die Divi-Freigabe ist ohne Bedeutung.',
            $html
        );
        self::assertStringNotContainsString('Prüfung starten', $html);
    }

    public function testIncompatibleListsTheProblems(): void
    {
        $html = $this->rendered(
            ReleaseMatrices::uniform(ReleaseState::Incompatible, '5.3.0', ['Theme Builder: Nachbau von x() – y']),
            null
        );

        self::assertStringContainsString('inkompatibel', $html);
        self::assertStringContainsString('Theme Builder: Nachbau von x() – y', $html);
        self::assertStringContainsString('Plugin-Update', $html);
    }

    /** The tab removes the pages of a dead check in the settings page's load hook, never while rendering. */
    public function testRegistersTheCleanupOnTheSettingsPageLoadHook(): void
    {
        Actions\expectAdded('admin_post_lit_mcp_divi_release')->once();
        Actions\expectAdded('admin_post_lit_mcp_divi_withdraw')->once();
        Actions\expectAdded('load-settings_page_lit-mcp')->once()->with(Mockery::type('array'));

        $this->tab(null, Mockery::mock(ReleaseStore::class))->registerActions();
    }

    public function testTheLoadHookOnThisTabRemovesOrphansAndTheTabReportsThem(): void
    {
        $_GET['tab'] = 'divi';
        Functions\expect('get_posts')->once()->andReturn([
            new WP_Post(['ID' => 51, 'post_title' => WriteProbe::TITLE . ' 2026-10-18 08:00']),
        ]);
        Functions\expect('wp_delete_post')->once()->with(51, true)->andReturn(new WP_Post(['ID' => 51]));
        $tab = $this->tab(self::report(), Mockery::mock(ReleaseStore::class));

        $tab->removeOrphans();
        $html = $this->rendered(ReleaseMatrices::released('5.3.0'), self::report(), $tab);

        self::assertStringContainsString('Liegengebliebene Prüfseiten gelöscht: 51', $html);
    }

    public function testRenderingAloneDeletesNothing(): void
    {
        Functions\expect('get_posts')->never();
        Functions\expect('wp_delete_post')->never();

        $html = $this->rendered(ReleaseMatrices::released('5.3.0'), self::report());

        self::assertStringNotContainsString('Liegengebliebene Prüfseiten', $html);
    }

    public function testTheLoadHookDeletesNothingOnOtherTabsWithoutTheRightOrWithoutDivi(): void
    {
        Functions\expect('get_posts')->never();
        $tab = $this->tab(null, Mockery::mock(ReleaseStore::class));

        unset($_GET['tab']);
        $tab->removeOrphans();
        $_GET['tab'] = 'tools';
        $tab->removeOrphans();

        $_GET['tab'] = 'divi';
        Functions\when('current_user_can')->justReturn(false);
        $tab->removeOrphans();

        Functions\when('current_user_can')->justReturn(true);
        (new DiviTab(
            Mockery::mock(CheckReportStore::class),
            Mockery::mock(ReleaseStore::class),
            FakeChangeLog::forbidden(),
            null,
            static fn (): string => ''
        ))->removeOrphans();
    }

    private static function mixedStatus(): ReleaseStatus
    {
        $matrix = MatrixFixtures::released('auto', [
            new FeatureStatus(
                DiviFeature::PageWrite,
                ReleaseState::Incompatible,
                ['Seiten: Signatur von et_pb_x() <geändert>'],
                null
            ),
            new FeatureStatus(DiviFeature::Catalog, ReleaseState::Untested, [], null),
        ]);

        return ReleaseStatus::of('5.3.0', $matrix);
    }

    public function testTheFeatureTableShowsStateSourceProblemsAndTools(): void
    {
        $overview = new FeatureOverview(static fn (): array => [
            new FeatureFakeTool('lit/divi-insert', true, [DiviFeature::PageRead, DiviFeature::PageWrite]),
            new FeatureFakeTool('lit/divi-presets-assign', false, [DiviFeature::PresetWrite]),
        ]);

        $html = $this->renderedWith(self::mixedStatus(), null, $overview);

        self::assertStringContainsString('<th scope="col">Betroffene Werkzeuge</th>', $html);
        self::assertStringContainsString(
            '<td>Seiten schreiben</td><td><strong>inkompatibel</strong></td><td>–</td>',
            $html
        );
        self::assertStringContainsString('<td>Modulkatalog</td><td><strong>ungetestet</strong></td>', $html);
        self::assertStringContainsString(
            '<td>Seiten lesen</td><td><strong>freigegeben</strong></td><td>Automatik (auto)</td>',
            $html
        );
        self::assertStringContainsString('<li><code>lit-divi-insert</code></li>', $html);
        self::assertStringContainsString('<li><code>lit/divi-presets-assign</code></li>', $html);
    }

    public function testFeatureProblemsAreEscaped(): void
    {
        $html = $this->rendered(self::mixedStatus(), null);

        self::assertStringContainsString('Seiten: Signatur von et_pb_x() &lt;geändert&gt;', $html);
        self::assertStringNotContainsString('<geändert>', $html);
    }

    public function testTheTableNamesEverySourceInWords(): void
    {
        $code = $this->rendered(ReleaseMatrices::released('5.3.0'), null);
        $database = $this->rendered(
            ReleaseStatus::of('5.3.0', MatrixFixtures::released('database'), [
                'released_at' => '2026-10-01T08:00:00+00:00', 'user_id' => 1,
            ]),
            self::report()
        );

        self::assertStringContainsString('Plugin (code)', $code);
        self::assertStringContainsString('Freigabe auf dieser Website (database)', $database);
    }

    public function testTheTabExplainsTheAutomationAndTheFilter(): void
    {
        $html = $this->rendered(ReleaseMatrices::released('5.3.0'), null);

        self::assertStringContainsString('gibt LIT MCP jede Fähigkeit einzeln frei', $html);
        self::assertStringContainsString('<code>lit_mcp_divi_auto_release</code>', $html);
        self::assertStringContainsString('als ungetestet', $html);
        self::assertStringContainsString('Aufrufe', $html);
        self::assertStringNotContainsString('Verhalten geprüft', $html);
    }

    public function testTheTabNoLongerSaysWritingIsLockedAsAWhole(): void
    {
        $untested = $this->rendered(
            ReleaseStatus::of('5.3.0', MatrixFixtures::with(DiviFeature::Catalog, ReleaseState::Untested)),
            null
        );
        $incompatible = $this->rendered(self::mixedStatus(), null);

        foreach ([$untested, $incompatible] as $html) {
            self::assertStringNotContainsString('Schreiben bleibt gesperrt', $html);
            self::assertStringNotContainsString('lesen nur', $html);
            self::assertStringContainsString('alle anderen laufen weiter', $html);
        }
    }

    public function testADatabaseReleaseCanBeWithdrawnWhileOneFeatureIsIncompatible(): void
    {
        $matrix = MatrixFixtures::released('database', [
            new FeatureStatus(DiviFeature::PageWrite, ReleaseState::Incompatible, ['Seiten: x() fehlt'], null),
        ]);
        $status = ReleaseStatus::of('5.3.0', $matrix, [
            'released_at' => '2026-10-01T08:00:00+00:00', 'user_id' => 1,
        ]);

        self::assertStringContainsString('Freigabe zurückziehen', $this->rendered($status, self::report()));
    }

    public function testWithoutADatabaseReleaseNothingCanBeWithdrawnWhateverTheState(): void
    {
        self::assertStringNotContainsString('Freigabe zurückziehen', $this->rendered(self::mixedStatus(), null));
    }

    /** @return string The admin notice of this request. */
    private function notice(ReleaseStatus $status, string $version = '5.3.0'): string
    {
        ReleaseGate::useResolver(static fn (): ReleaseStatus => $status);
        $tab = new DiviTab(
            Mockery::mock(CheckReportStore::class),
            Mockery::mock(ReleaseStore::class),
            FakeChangeLog::forbidden(),
            new AdminPostAction(static function (): void {
            }),
            static fn () => $version,
            static fn (string $v): string => 'key'
        );

        ob_start();
        $tab->renderNotice();

        return (string) ob_get_clean();
    }

    public function testTheNoticeNamesTheUnusableFeaturesAndLinksToTheTab(): void
    {
        $html = $this->notice(self::mixedStatus());

        self::assertStringContainsString('class="notice notice-warning"', $html);
        self::assertStringContainsString('Mit Divi 5.3.0 sind diese Fähigkeiten nicht nutzbar', $html);
        self::assertStringContainsString('Seiten schreiben, Modulkatalog', $html);
        self::assertStringContainsString('alle anderen laufen weiter', $html);
        self::assertStringContainsString('page=lit-mcp&tab=divi', $html);
    }

    public function testNoNoticeWhileEveryFeatureIsUsable(): void
    {
        self::assertSame('', $this->notice(ReleaseMatrices::released('5.3.0')));
    }

    public function testNoNoticeForUsersWithoutManageOptions(): void
    {
        Functions\when('current_user_can')->justReturn(false);

        self::assertSame('', $this->notice(self::mixedStatus()));
    }

    public function testNoNoticeWithoutDivi(): void
    {
        self::assertSame('', $this->notice(self::mixedStatus(), ''));
    }

    public function testNoNoticeOnTheDiviTabItself(): void
    {
        Functions\when('get_current_screen')->justReturn((object) ['id' => 'settings_page_lit-mcp']);
        $_GET['tab'] = 'divi';

        self::assertSame('', $this->notice(self::mixedStatus()));
    }

    public function testTheNoticeStillShowsOnOtherTabsOfThePluginPage(): void
    {
        Functions\when('get_current_screen')->justReturn((object) ['id' => 'settings_page_lit-mcp']);
        $_GET['tab'] = 'tools';

        self::assertStringContainsString('nicht nutzbar', $this->notice(self::mixedStatus()));
    }

    public function testTheNoticeIsRegisteredOnAdminNotices(): void
    {
        $tab = $this->tab(null, Mockery::mock(ReleaseStore::class));
        Actions\expectAdded('admin_notices')->once()->with([$tab, 'renderNotice']);

        $tab->registerNotice();
    }

    public function testRegisteringTheTabsActionsAlsoRegistersTheNotice(): void
    {
        $tab = $this->tab(null, Mockery::mock(ReleaseStore::class));
        Actions\expectAdded('admin_notices')->once()->with([$tab, 'renderNotice']);

        $tab->registerActions();
    }
}