<?php

declare(strict_types=1);

namespace Tests\Feature\FormBuilder\Schema;

use App\Enums\FormBuilder\FormFieldType;
use App\Enums\FormBuilder\FormFieldValidationRuleType;
use App\Enums\FormBuilder\FormPurpose;
use App\Models\FormBuilder\FormField;
use App\Models\FormBuilder\FormSchema;
use App\Models\FormBuilder\FormSubmission;
use App\Models\Organisation;
use App\Services\FormBuilder\FormSubmissionService;
use App\Support\Json\JsonCanonicalizer;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\DB;
use Tests\TestCase;

/**
 * Regression test for MySQL JSON key-order non-determinism.
 *
 * Session 2.6 surfaced that MySQL JSON columns may reorder
 * associative-array keys on round-trip. Session 2.7 introduced
 * JsonCanonicalizer to stabilize the writers. This test asserts
 * the contract end-to-end: a submission's schema_snapshot serialized
 * to canonical JSON must match the canonical serialization of the
 * raw bytes the DB returns on a separate read.
 */
final class SchemaSnapshotByteStableAcrossReemitsTest extends TestCase
{
    use RefreshDatabase;

    public function test_snapshot_bytes_are_stable_across_reads(): void
    {
        $org = Organisation::factory()->create();
        $schema = FormSchema::factory()->create([
            'organisation_id' => $org->id,
            'purpose' => FormPurpose::EVENT_REGISTRATION,
            'snapshot_mode' => 'on_submit',
            'is_published' => true,
            'public_token' => (string) \Illuminate\Support\Str::ulid(),
        ]);

        // Email field with entity binding + validation rule.
        FormField::factory()
            ->withValidationRule(FormFieldValidationRuleType::MaxLength, ['value' => 100])
            ->withEntityBinding('person', 'email')
            ->create([
                'form_schema_id' => $schema->id,
                'field_type' => FormFieldType::EMAIL->value,
                'slug' => 'contact_email',
                'label' => 'E-mail',
            ]);

        // Number field with min/max validation + conditional logic.
        FormField::factory()
            ->withValidationRule(FormFieldValidationRuleType::MinValue, ['value' => 18])
            ->withValidationRule(FormFieldValidationRuleType::MaxValue, ['value' => 99])
            ->withConditionalLogic([
                'operator' => 'all',
                'children' => [
                    ['field_slug' => 'contact_email', 'operator' => 'not_empty'],
                ],
            ])
            ->create([
                'form_schema_id' => $schema->id,
                'field_type' => FormFieldType::NUMBER->value,
                'slug' => 'leeftijd',
                'label' => 'Leeftijd',
            ]);

        // Select field with options + translations.
        FormField::factory()
            ->withOptions(['XS', 'S', 'M', 'L'])
            ->create([
                'form_schema_id' => $schema->id,
                'field_type' => FormFieldType::SELECT->value,
                'slug' => 'shirtmaat',
                'label' => 'Shirtmaat',
            ]);

        // Submit so schema_snapshot materializes.
        $service = resolve(FormSubmissionService::class);
        $draft = $service->createDraft($schema, null, null, []);
        $service->submit($draft, null);

        // First read: through Eloquent cast (decode → assoc array).
        $first = FormSubmission::query()->withoutGlobalScopes()->findOrFail($draft->id);
        $snapshotA = $first->schema_snapshot;

        // Second read: a fresh model instance (no cached attributes).
        $second = FormSubmission::query()->withoutGlobalScopes()->findOrFail($draft->id);
        $snapshotB = $second->schema_snapshot;

        // Third read: raw column bytes via the query builder, decoded once.
        $rawJson = (string) DB::table('form_submissions')
            ->where('id', $draft->id)
            ->value('schema_snapshot');
        $snapshotC = json_decode($rawJson, true);

        // All three roads must produce byte-identical canonical JSON.
        $this->assertSame(
            JsonCanonicalizer::encode($snapshotA),
            JsonCanonicalizer::encode($snapshotB),
        );
        $this->assertSame(
            JsonCanonicalizer::encode($snapshotA),
            JsonCanonicalizer::encode($snapshotC),
        );

        // And the canonical encode of every JSON-bearing nested fragment
        // must be byte-identical too — covers each field's options /
        // validation_rules / configs / bindings / conditional_logic
        // in one assertion via the whole-snapshot canonical encode.
        $this->assertNotEmpty($snapshotA['fields']);
        foreach ($snapshotA['fields'] as $idx => $fieldA) {
            $fieldC = $snapshotC['fields'][$idx];
            $this->assertSame(
                JsonCanonicalizer::encode($fieldA),
                JsonCanonicalizer::encode($fieldC),
                "field #{$idx} ({$fieldA['slug']}) drifted across reads",
            );
        }
    }
}