<?php

declare(strict_types=1);

namespace LIT\MCP\Tests\Unit\Integrations\WordPress\Content;

use Brain\Monkey\Actions;
use Brain\Monkey\Functions;
use LIT\MCP\Abilities\Rev;
use LIT\MCP\Abilities\WriteFailed;
use LIT\MCP\ChangeLog\ChangeLog;
use LIT\MCP\Integrations\WordPress\Content\ContentUpdateAbility;
use LIT\MCP\Integrations\WordPress\Content\PostPresenter;
use LIT\MCP\Integrations\WordPress\Content\PostWriter;
use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
use LIT\MCP\Tests\Support\FakeBuilderDetector;
use LIT\MCP\Tests\Support\FakeChangeLog;
use LIT\MCP\Tests\Support\SchemaFixture;
use LIT\MCP\Tests\Unit\TestCase;
use Mockery;
use RuntimeException;
use WP_Post;

final class ContentUpdateAbilityTest extends TestCase
{
    private WP_Post $post;

    protected function setUp(): void
    {
        parent::setUp();
        $this->post = new WP_Post([
            'ID' => 5,
            'post_type' => 'page',
            'post_status' => 'publish',
            'post_title' => 'Team',
            'post_name' => 'team',
            'post_content' => '<p>Alt</p>',
        ]);
        Functions\when('get_post')->justReturn($this->post);
        Functions\when('current_user_can')->justReturn(true);
    }

    private function schema(): ContentSchema
    {
        $schema = SchemaFixture::managed();

        return $schema;
    }

    private function ability(
        PostWriter $writer,
        ?ChangeLog $log = null,
        ?PostPresenter $presenter = null
    ): ContentUpdateAbility {
        return new ContentUpdateAbility($this->schema(), $writer, $log ?? FakeChangeLog::forbidden(), $presenter);
    }

    public function testRevIsRequired(): void
    {
        $writer = Mockery::mock(PostWriter::class);
        Functions\expect('wp_update_post')->never();

        self::assertContains('rev', $this->ability($writer)->inputSchema()['required']);
        self::assertSame(
            'lit_rev_mismatch',
            $this->ability($writer)->execute(['post_id' => 5, 'title' => 'Neu'])->get_error_code()
        );
    }

    public function testATrashedPostIsRefused(): void
    {
        $this->post->post_status = 'trash';
        Functions\expect('wp_update_post')->never();

        $result = $this->ability(Mockery::mock(PostWriter::class))
            ->execute(['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Neu']);

        self::assertToolError($result, 'validation_failed');
    }

    public function testAMissedScheduleIsRefusedBecauseSavingWouldPublish(): void
    {
        $this->post->post_status = 'future';
        $this->post->post_date_gmt = gmdate('Y-m-d H:i:s', time() - 600);
        Functions\expect('wp_update_post')->never();
        Functions\expect('wp_save_post_revision')->never();

        $result = $this->ability(Mockery::mock(PostWriter::class))
            ->execute(['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Neu']);

        self::assertToolError($result, 'validation_failed');
        self::assertArrayHasKey('post_id', self::errorFields($result));
        self::assertStringContainsString('lit/post-schedule', $result->get_error_data()['hint']);
    }

    public function testStaleRevIsRejectedWithoutWriting(): void
    {
        Functions\expect('wp_update_post')->never();

        $result = $this->ability(Mockery::mock(PostWriter::class))
            ->execute(['post_id' => 5, 'rev' => 'stale', 'title' => 'Neu']);

        self::assertToolError($result, 'rev_mismatch');
        self::assertStringContainsString('lit-content-get', $result->get_error_data()['hint']);
    }

    public function testAContentOnlyRevIsStaleBecauseTitleAndStatusCountToo(): void
    {
        $result = $this->ability(Mockery::mock(PostWriter::class))
            ->execute(['post_id' => 5, 'rev' => Rev::of('<p>Alt</p>'), 'title' => 'Neu']);

        self::assertToolError($result, 'rev_mismatch');
    }

    public function testRawContentOnDiviPagesIsUnsupported(): void
    {
        $writer = Mockery::mock(PostWriter::class);
        $writer->expects('prepare')->never();
        $presenter = new PostPresenter($this->schema(), new FakeBuilderDetector(false, [5]));

        $result = $this->ability($writer, null, $presenter)
            ->execute(['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'content' => '<p>Neu</p>']);

        self::assertToolError($result, 'unsupported');
        self::assertStringContainsString(PostPresenter::DIVI_INACTIVE_NOTE, $result->get_error_data()['hint']);
    }

    public function testNothingToChangeIsAValidationError(): void
    {
        $writer = Mockery::mock(PostWriter::class);
        $writer->allows('postData')->andReturn([]);
        $writer->allows('hasExtras')->andReturn(false);

        $result = $this->ability($writer)->execute(['post_id' => 5, 'rev' => Rev::ofPost($this->post)]);

        self::assertToolError($result, 'validation_failed');
    }

    public function testUpdateKeepsTheStatusAndCapturesARestorePointFirst(): void
    {
        $order = [];
        $prepared = ['fields' => [], 'terms' => [], 'warnings' => []];
        $input = ['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Unser Team'];
        $writer = Mockery::mock(PostWriter::class);
        $writer->allows('postData')->andReturn(['post_title' => 'Unser Team']);
        $writer->allows('hasExtras')->andReturn(false);
        $writer->allows('prepare')->with('page', $input, false)->andReturn($prepared);
        $writer->allows('snapshot')->andReturn(['fields' => [], 'terms' => []]);
        $writer->expects('writeExtras')->with(5, 'page', $prepared, $input);
        Functions\expect('wp_save_post_revision')->once()->with(5)->andReturnUsing(static function () use (&$order) {
            $order[] = 'revision';
            return 811;
        });
        Functions\when('wp_get_post_revisions')->justReturn([811 => new WP_Post(['ID' => 811])]);
        Functions\expect('wp_update_post')->once()->with(['post_title' => 'Unser Team', 'ID' => 5], true)
            ->andReturnUsing(static function () use (&$order): int {
                $order[] = 'update';
                return 5;
            });
        Actions\expectDone('lit_mcp_after_save')->once()->with(5, 'lit/content-update', $input);
        Functions\when('get_preview_post_link')->justReturn('https://kunde.de/team/');
        Functions\when('get_edit_post_link')->justReturn('https://kunde.de/wp-admin/post.php?post=5&action=edit');
        $log = new FakeChangeLog(4711);

        $result = $this->ability($writer, $log)->execute($input);

        self::assertSame(['revision', 'update'], $order);
        self::assertSame(811, $result['revision_id']);
        self::assertSame(4711, $result['log_id']);
        self::assertSame('updated', $result['changed'][0]['action']);
        self::assertSame(Rev::ofPost($this->post), $result['rev']);
        self::assertStringContainsString('Status unverändert: publish', $result['summary']);
        $log->assertRecorded([
            'ability' => 'lit/content-update',
            'object_type' => 'page',
            'object_id' => '5',
            'revision_id' => 811,
        ]);
    }

    /**
     * @param array<string, mixed> $data
     * @return array{PostWriter&\Mockery\MockInterface, array<string, mixed>}
     */
    private function failingWriter(array $data, bool $restoreWorks = true): array
    {
        $input = ['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Unser Team', 'fields' => ['a' => 1]];
        $snapshot = ['fields' => ['a' => 0], 'terms' => []];
        $writer = Mockery::mock(PostWriter::class);
        $writer->allows('postData')->andReturn($data);
        $writer->allows('prepare')->andReturn(['fields' => ['a' => 1], 'terms' => [], 'warnings' => []]);
        $writer->expects('snapshot')->with(5, 'page', Mockery::type('array'), $input)->andReturn($snapshot);
        $writer->allows('writeExtras')->andThrow(new RuntimeException('meta kaputt'));
        $restore = $writer->expects('restore')->with(5, 'page', $snapshot);
        if (! $restoreWorks) {
            $restore->andThrow(new RuntimeException('restore kaputt'));
        }
        $writer->expects('deleteCreatedTerms');
        Functions\when('wp_save_post_revision')->justReturn(811);
        Functions\when('wp_get_post_revisions')->justReturn([811 => new WP_Post(['ID' => 811])]);
        Actions\expectDone('lit_mcp_after_save')->never();

        return [$writer, $input];
    }

    /** @param array<string, mixed> $input */
    private function executeExpectingFailure(PostWriter $writer, array $input, ?ChangeLog $log = null): WriteFailed
    {
        if ($log === null) {
            $log = FakeChangeLog::forbidden();
        }

        try {
            $this->ability($writer, $log)->execute($input);
        } catch (WriteFailed $e) {
            self::assertStringContainsString('meta kaputt', $e->getMessage());
            return $e;
        }

        self::fail('WriteFailed expected');
    }

    /** @return list<array<string, mixed>> Captured wp_update_post() calls. */
    private function captureUpdates(array &$updates): void
    {
        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
            $updates[] = $data;
            return 5;
        });
    }

    public function testFailingExtrasRestoreTheRevisionAndTheOldValues(): void
    {
        [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team', 'post_name' => 'unser-team']);
        $updates = [];
        $this->captureUpdates($updates);
        Functions\when('wp_revisions_enabled')->justReturn(true);
        Functions\expect('wp_restore_post_revision')->once()->with(811, ['post_title'])->andReturn(5);

        $failure = $this->executeExpectingFailure($writer, $input);

        self::assertTrue($failure->rolledBack);
        self::assertToolError($failure->toError(), 'write_failed');
        $message = $failure->toError()->get_error_message();
        self::assertStringNotContainsString('Nichts wurde gespeichert', $message);
        self::assertStringContainsString('Die Änderung wurde nicht gespeichert (Revision 811 bleibt erhalten).', $message);
        self::assertSame([
            ['post_title' => 'Unser Team', 'post_name' => 'unser-team', 'ID' => 5],
            ['post_name' => 'team', 'ID' => 5],
        ], $updates);
    }

    public function testWithoutRevisionsTheOldColumnValuesIncludingTheOldTemplateAreWrittenBack(): void
    {
        [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team', 'page_template' => 'tpl-wide.php']);
        $template = 'tpl-alt.php';
        $updates = [];
        Functions\when('get_page_template_slug')->alias(static function () use (&$template): string {
            return $template;
        });
        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates, &$template): int {
            $updates[] = $data;
            $template = (string) ($data['page_template'] ?? $template);
            return 5;
        });
        Functions\when('wp_revisions_enabled')->justReturn(false);
        Functions\expect('wp_restore_post_revision')->never();

        $this->executeExpectingFailure($writer, $input);

        self::assertSame([
            ['post_title' => 'Unser Team', 'page_template' => 'tpl-wide.php', 'ID' => 5],
            ['post_title' => 'Team', 'page_template' => 'tpl-alt.php', 'ID' => 5],
        ], $updates);
    }

    public function testAnUpdateThatThrowsStillRestoresTheRow(): void
    {
        [$writer, $input] = $this->failingWriter(['post_name' => 'unser-team']);
        $writer->shouldNotReceive('writeExtras');
        $updates = [];
        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
            $updates[] = $data;
            if (count($updates) === 1) {
                throw new RuntimeException('meta kaputt im save_post-Hook');
            }
            return 5;
        });

        $failure = $this->executeExpectingFailure($writer, $input);

        self::assertTrue($failure->rolledBack);
        self::assertSame(['post_name' => 'team', 'ID' => 5], $updates[1]);
    }

    public function testTheRollbackNeverRewritesARowWhoseScheduleHasPassedMeanwhile(): void
    {
        [$writer, $input] = $this->failingWriter(['post_name' => 'unser-team']);
        $post = $this->post;
        $updates = [];
        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates, $post): int {
            $updates[] = $data;
            // The entry turned into a missed schedule while the call ran (e.g. edited in WordPress).
            $post->post_status = 'future';
            $post->post_date_gmt = gmdate('Y-m-d H:i:s', time() - 5);
            return 5;
        });
        Functions\when('wp_revisions_enabled')->justReturn(true);
        Functions\expect('wp_restore_post_revision')->never();
        $log = FakeChangeLog::partialsOnly();

        $failure = $this->executeExpectingFailure($writer, $input, $log);

        self::assertFalse($failure->rolledBack);
        self::assertCount(1, $updates);
        self::assertStringContainsString('publish', $failure->getMessage());
        $log->assertPartials([]);
    }

    public function testAnIncompleteRollbackIsAPartialWriteAndLogged(): void
    {
        [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team'], false);
        $updates = [];
        $this->captureUpdates($updates);
        Functions\when('wp_revisions_enabled')->justReturn(false);
        $log = FakeChangeLog::partialsOnly();

        $failure = $this->executeExpectingFailure($writer, $input, $log);

        self::assertFalse($failure->rolledBack);
        self::assertStringContainsString('restore kaputt', $failure->getMessage());
        $error = $failure->toError();
        self::assertToolError($error, 'partial_write');
        self::assertSame(5, $error->get_error_data()['post_id']);
        self::assertSame(811, $error->get_error_data()['revision_id']);
        $log->assertPartials([
            'ability' => 'lit/content-update',
            'object_type' => 'page',
            'object_id' => '5',
            'revision_id' => 811,
        ]);
    }

    public function testFailuresAfterTheWriteOnlyAddWarnings(): void
    {
        $input = ['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Unser Team'];
        $writer = Mockery::mock(PostWriter::class);
        $writer->allows('postData')->andReturn(['post_title' => 'Unser Team']);
        $writer->allows('prepare')->andReturn(['fields' => [], 'terms' => [], 'warnings' => []]);
        $writer->allows('snapshot')->andReturn(['fields' => [], 'terms' => []]);
        $writer->allows('writeExtras');
        Functions\when('wp_save_post_revision')->justReturn(811);
        Functions\when('wp_get_post_revisions')->justReturn([811 => new WP_Post(['ID' => 811])]);
        Functions\when('wp_update_post')->justReturn(5);
        Functions\when('get_preview_post_link')->justReturn('');
        Functions\when('get_edit_post_link')->justReturn('');
        Actions\expectDone('lit_mcp_after_save')->once()->whenHappen(static function (): void {
            throw new RuntimeException('listener kaputt');
        });
        $log = new FakeChangeLog(1, new RuntimeException('db weg'));
        $file = (string) tempnam(sys_get_temp_dir(), 'lit-mcp-log');
        $previous = ini_set('error_log', $file);

        try {
            $result = $this->ability($writer, $log)->execute($input);
        } finally {
            ini_set('error_log', (string) $previous);
        }

        self::assertTrue($result['ok']);
        self::assertNull($result['log_id']);
        self::assertCount(2, $result['warnings']);
        self::assertStringContainsString('listener kaputt', (string) file_get_contents($file));
        unlink($file);
        $log->assertRecorded([]);
    }

    /** Security audit 2026-11, B2: overwriting a post must not look like "only adds" to an MCP client. */
    public function testOverwritesSoItIsMarkedDestructive(): void
    {
        $annotations = $this->ability(\Mockery::mock(PostWriter::class))->annotations();

        self::assertTrue($annotations['destructive']);
        self::assertFalse($annotations['readonly']);
    }
}