<?php

namespace Tests\Feature\Api\Admin;

use App\Enums\ExtensionOwnerType;
use App\Models\Permission;
use App\Models\Role;
use App\Models\Template;
use App\Models\TemplateLayout;
use App\Models\TemplateLayoutVersion;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

/**
 * LayoutController API 테스트
 *
 * GET /api/admin/templates/{id}/layouts 엔드포인트 테스트
 * GET /api/admin/templates/{id}/layouts/{name} 엔드포인트 테스트
 * PUT /api/admin/templates/{id}/layouts/{name} 엔드포인트 테스트
 */
class LayoutControllerTest extends TestCase
{
    use RefreshDatabase;

    private User $adminUser;
    private User $normalUser;
    private Template $template;
    private string $token;

    protected function setUp(): void
    {
        parent::setUp();

        // 관리자 사용자 생성 (필요한 권한 포함)
        $this->adminUser = $this->createAdminUser([
            'core.templates.read',
            'core.templates.activate',
        ]);
        $this->token = $this->adminUser->createToken('test-token')->plainTextToken;

        // 일반 사용자 생성
        $this->normalUser = User::factory()->create();

        // 테스트용 템플릿 생성
        $this->template = Template::factory()->create();
    }

    /**
     * 관리자 사용자 생성 (필요한 권한 포함)
     * admin 미들웨어를 통과하기 위해 admin 역할도 함께 할당
     */
    private function createAdminUser(array $permissions = []): User
    {
        $user = User::factory()->create();

        // 권한 생성
        $permissionIds = [];
        foreach ($permissions as $permissionIdentifier) {
            $permission = Permission::firstOrCreate(
                ['identifier' => $permissionIdentifier],
                [
                    'name' => json_encode(['ko' => $permissionIdentifier, 'en' => $permissionIdentifier]),
                    'description' => json_encode(['ko' => $permissionIdentifier, 'en' => $permissionIdentifier]),
                    'extension_type' => ExtensionOwnerType::Core,
                    'extension_identifier' => 'core',
                    'type' => 'admin',
                ]
            );
            $permissionIds[] = $permission->id;
        }

        // 고유한 식별자로 역할 생성 (테스트별 격리를 위해)
        $roleIdentifier = 'admin_test_'.uniqid();
        $testRole = Role::create([
            'identifier' => $roleIdentifier,
            'name' => json_encode(['ko' => '테스트 관리자', 'en' => 'Test Administrator']),
            'description' => json_encode(['ko' => '테스트 관리자', 'en' => 'Test Administrator']),
            'is_active' => true,
        ]);

        // admin 역할도 추가 (admin 미들웨어 통과용)
        $adminRole = Role::firstOrCreate(
            ['identifier' => 'admin'],
            [
                'name' => json_encode(['ko' => '관리자', 'en' => 'Administrator']),
                'description' => json_encode(['ko' => '시스템 관리자', 'en' => 'System Administrator']),
                'extension_type' => ExtensionOwnerType::Core,
                'extension_identifier' => 'core',
                    'type' => 'admin',
                'is_active' => true,
            ]
        );

        // 테스트용 역할에 권한 할당
        $testRole->permissions()->sync($permissionIds);

        // 사용자에게 admin 역할과 테스트용 역할 모두 할당
        $user->roles()->attach($adminRole->id, [
            'assigned_at' => now(),
            'assigned_by' => null,
        ]);
        $user->roles()->attach($testRole->id, [
            'assigned_at' => now(),
            'assigned_by' => null,
        ]);

        return $user->fresh();
    }

    /**
     * 인증된 요청 헬퍼 메서드
     */
    private function authRequest(): static
    {
        return $this->withHeaders([
            'Authorization' => 'Bearer '.$this->token,
            'Accept' => 'application/json',
        ]);
    }

    /**
     * 레이아웃 목록 조회 성공
     */
    public function test_can_list_layouts(): void
    {
        // Arrange
        TemplateLayout::factory()->count(3)->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts");

        // Assert
        $response->assertStatus(200)
            ->assertJsonStructure([
                'success',
                'message',
                'data' => [
                    '*' => [
                        'id',
                        'template_id',
                        'name',
                        'endpoint',
                        'components',
                        'data_sources',
                        'metadata',
                    ],
                ],
            ]);

        $this->assertCount(3, $response->json('data'));
    }

    /**
     * 인증되지 않은 사용자 접근 거부
     */
    public function test_unauthenticated_user_cannot_list_layouts(): void
    {
        // Act
        $response = $this->getJson("/api/admin/templates/{$this->template->identifier}/layouts");

        // Assert
        $response->assertStatus(401);
    }

    /**
     * 권한 없는 사용자 접근 거부
     */
    public function test_unauthorized_user_cannot_list_layouts(): void
    {
        // Act
        $response = $this->actingAs($this->normalUser)
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts");

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 빈 목록 조회 (레이아웃이 없을 때)
     */
    public function test_returns_empty_array_when_no_layouts(): void
    {
        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts");

        // Assert
        $response->assertStatus(200);
        $this->assertCount(0, $response->json('data'));
    }

    /**
     * 레이아웃 상세 조회 성공
     */
    public function test_can_show_layout(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/admin/test',
                'components' => [],
                'data_sources' => [],
                'metadata' => [],
            ],
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}");

        // Assert
        $response->assertStatus(200)
            ->assertJsonStructure([
                'success',
                'message',
                'data' => [
                    'id',
                    'template_id',
                    'name',
                    'endpoint',
                    'components',
                    'data_sources',
                    'metadata',
                ],
            ])
            ->assertJsonFragment([
                'name' => 'test-layout',
                'endpoint' => '/api/admin/test',
            ]);
    }

    /**
     * 존재하지 않는 레이아웃 조회 시 404 응답
     */
    public function test_returns_404_for_nonexistent_layout(): void
    {
        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/nonexistent");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 인증되지 않은 사용자는 레이아웃 상세 조회 불가
     */
    public function test_unauthenticated_user_cannot_show_layout(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}");

        // Assert
        $response->assertStatus(401);
    }

    /**
     * 권한 없는 사용자는 레이아웃 상세 조회 불가
     */
    public function test_unauthorized_user_cannot_show_layout(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->actingAs($this->normalUser)
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}");

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 레이아웃 업데이트 성공
     */
    public function test_can_update_layout(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/test',
                'components' => ['component' => 'old'],
                'data_sources' => [],
                'metadata' => ['key' => 'old_value'],
            ],
        ]);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/admin/test',
                'components' => [
                    [
                        'id' => 'comp_1',
                        'name' => 'NewContainer',
                        'type' => 'composite',
                        'props' => ['new' => 'value'],
                    ],
                ],
                'data_sources' => [],
                'metadata' => ['key' => 'new_value'],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(200);

        // 응답 JSON 구조 확인
        $responseData = $response->json('data');
        $this->assertIsArray($responseData['components']);
        $this->assertCount(1, $responseData['components']);
        $this->assertEquals('comp_1', $responseData['components'][0]['id']);
        $this->assertEquals('NewContainer', $responseData['components'][0]['name']);
        $this->assertEquals('composite', $responseData['components'][0]['type']);

        $this->assertDatabaseHas('template_layouts', [
            'id' => $layout->id,
            'name' => 'test-layout',
        ]);
    }

    /**
     * 레이아웃 업데이트 시 유효성 검증 실패
     */
    public function test_update_layout_validation_fails(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        $invalidData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test',
                'endpoint' => '/api/test',
                'components' => 'not_an_array', // 배열이 아님
                'metadata' => 'not_an_array', // 배열이 아님
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $invalidData);

        // Assert
        $response->assertStatus(422)
            ->assertJsonValidationErrors(['content.components', 'content.metadata']);
    }

    /**
     * 존재하지 않는 레이아웃 업데이트 시 500 응답
     */
    public function test_update_nonexistent_layout_returns_500(): void
    {
        // Arrange
        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'nonexistent',
                'endpoint' => '/api/admin/test',
                'components' => [
                    [
                        'id' => 'comp_1',
                        'name' => 'NewContainer',
                        'type' => 'composite',
                        'props' => ['new' => 'value'],
                    ],
                ],
                'data_sources' => [],
                'metadata' => [],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/nonexistent", $updateData);

        // Assert
        $response->assertStatus(500);
    }

    /**
     * 권한 없는 사용자는 레이아웃 업데이트 불가
     */
    public function test_unauthorized_user_cannot_update_layout(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test',
                'endpoint' => '/api/test',
                'components' => ['component' => 'new'],
                'data_sources' => [],
                'metadata' => [],
            ],
        ];

        // Act
        $response = $this->actingAs($this->normalUser)
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 레이아웃 상세 조회 시 민감한 정보 제외
     */
    public function test_response_excludes_sensitive_fields(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}");

        // Assert
        $response->assertStatus(200);

        $data = $response->json('data');
        $this->assertArrayNotHasKey('created_by', $data);
        $this->assertArrayNotHasKey('updated_by', $data);
        $this->assertArrayNotHasKey('deleted_at', $data);
    }

    /**
     * 레이아웃 버전 목록 조회 성공
     */
    public function test_can_list_layout_versions(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
        ]);

        TemplateLayoutVersion::factory()->count(3)->create([
            'layout_id' => $layout->id,
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions");

        // Assert
        $response->assertStatus(200)
            ->assertJsonStructure([
                'success',
                'message',
                'data' => [
                    '*' => [
                        'id',
                        'layout_id',
                        'version',
                        'endpoint',
                        'components',
                        'data_sources',
                        'metadata',
                        'changes_summary',
                        'created_at',
                    ],
                ],
            ]);

        $this->assertCount(3, $response->json('data'));
    }

    /**
     * 존재하지 않는 레이아웃의 버전 조회 시 404 응답
     */
    public function test_returns_404_for_nonexistent_layout_versions(): void
    {
        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/nonexistent/versions");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 권한 없는 사용자는 버전 목록 조회 불가
     */
    public function test_unauthorized_user_cannot_list_versions(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->actingAs($this->normalUser)
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions");

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 특정 버전 조회 성공
     */
    public function test_can_show_specific_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
        ]);

        $version = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 2,
            'content' => [
                'endpoint' => '/api/test',
                'components' => ['component' => 'test'],
                'data_sources' => [],
                'metadata' => ['key' => 'value'],
            ],
            'changes_summary' => ['updated' => 'components'],
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$version->version}");

        // Assert
        $response->assertStatus(200)
            ->assertJsonStructure([
                'success',
                'message',
                'data' => [
                    'id',
                    'layout_id',
                    'version',
                    'endpoint',
                    'components',
                    'data_sources',
                    'metadata',
                    'changes_summary',
                    'created_at',
                ],
            ])
            ->assertJsonFragment([
                'endpoint' => '/api/test',
            ]);

        $this->assertEquals(2, $response->json('data.version'));
    }

    /**
     * 존재하지 않는 버전 조회 시 404 응답
     */
    public function test_returns_404_for_nonexistent_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/999");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 권한 없는 사용자는 특정 버전 조회 불가
     */
    public function test_unauthorized_user_cannot_show_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        $version = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 1,
        ]);

        // Act
        $response = $this->actingAs($this->normalUser)
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$version->version}");

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 버전 응답에 민감한 정보 제외
     */
    public function test_version_response_excludes_sensitive_fields(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        $version = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 1,
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$version->version}");

        // Assert
        $response->assertStatus(200);

        $data = $response->json('data');
        $this->assertArrayNotHasKey('created_by', $data);
    }

    /**
     * 버전 복원 성공
     */
    public function test_can_restore_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/current',
                'components' => ['component' => 'current'],
                'data_sources' => [],
                'metadata' => ['key' => 'current_value'],
            ],
        ]);

        // 이전 버전 생성
        $oldVersion = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 1,
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/old',
                'components' => ['component' => 'old'],
                'data_sources' => [],
                'metadata' => ['key' => 'old_value'],
            ],
        ]);

        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$oldVersion->id}/restore");

        // Assert
        $response->assertStatus(200)
            ->assertJsonStructure([
                'success',
                'message',
                'data' => [
                    'id',
                    'layout_id',
                    'version',
                    'endpoint',
                    'components',
                ],
            ]);

        // 레이아웃의 content가 복원되었는지 확인
        $layout->refresh();
        $this->assertEquals('/api/old', $layout->content['endpoint']);
        $this->assertEquals(['component' => 'old'], $layout->content['components']);
        $this->assertEquals(['key' => 'old_value'], $layout->content['metadata']);

        // 새 버전이 생성되었는지 확인
        $this->assertDatabaseHas('template_layout_versions', [
            'layout_id' => $layout->id,
            'version' => 2, // 복원 후 새 버전 번호
        ]);
    }

    /**
     * 존재하지 않는 버전 복원 시 404 응답
     */
    public function test_restore_nonexistent_version_returns_404(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/999/restore");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 존재하지 않는 레이아웃의 버전 복원 시 404 응답
     */
    public function test_restore_version_for_nonexistent_layout_returns_404(): void
    {
        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/nonexistent/versions/1/restore");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 권한 없는 사용자는 버전 복원 불가
     */
    public function test_unauthorized_user_cannot_restore_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
        ]);

        $version = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 1,
        ]);

        // Act
        $response = $this->actingAs($this->normalUser)
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$version->id}/restore");

        // Assert
        $response->assertStatus(403);
    }

    /**
     * 버전 복원 후 새 버전이 생성되는지 확인
     */
    public function test_restore_creates_new_version(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'content' => [
                'endpoint' => '/api/v3',
                'components' => ['version' => '3'],
            ],
        ]);

        // 버전 1 생성
        $version1 = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 1,
            'content' => [
                'endpoint' => '/api/v1',
                'components' => ['version' => '1'],
            ],
        ]);

        // 버전 2 생성
        TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout->id,
            'version' => 2,
            'content' => [
                'endpoint' => '/api/v2',
                'components' => ['version' => '2'],
            ],
        ]);

        // Act - 버전 1로 복원
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}/versions/{$version1->id}/restore");

        // Assert
        $response->assertStatus(200);

        // 버전 3이 생성되었는지 확인 (복원 전의 content를 저장)
        $newVersion = TemplateLayoutVersion::where('layout_id', $layout->id)
            ->where('version', 3)
            ->first();

        $this->assertNotNull($newVersion);
        // 새 버전은 복원 전의 content (v3)를 저장하여 히스토리 보존
        $this->assertEquals('/api/v3', $newVersion->content['endpoint']);
        $this->assertEquals(['version' => '3'], $newVersion->content['components']);

        // 레이아웃이 v1으로 복원되었는지 확인
        $layout->refresh();
        $this->assertEquals('/api/v1', $layout->content['endpoint']);
        $this->assertEquals(['version' => '1'], $layout->content['components']);
    }

    /**
     * 다른 레이아웃의 버전으로 복원 시도 시 404 응답
     */
    public function test_cannot_restore_version_from_different_layout(): void
    {
        // Arrange
        $layout1 = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'layout-1',
        ]);

        $layout2 = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'layout-2',
        ]);

        $version2 = TemplateLayoutVersion::factory()->create([
            'layout_id' => $layout2->id,
            'version' => 1,
        ]);

        // Act - layout1에 layout2의 버전을 복원 시도
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout1->name}/versions/{$version2->id}/restore");

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 레이아웃 업데이트 시 이전 버전과 현재 버전 모두 버전 히스토리에 저장
     *
     * 저장 시 2개의 버전이 생성되어야 함:
     * 1. 이전 버전 (롤백용)
     * 2. 현재 저장 버전 (최신 상태 기록)
     */
    public function test_update_layout_creates_both_old_and_new_versions(): void
    {
        // Arrange - user 템플릿 생성 (버전 히스토리는 user 템플릿에서만 저장)
        $userTemplate = Template::factory()->create([
            'type' => 'user',
        ]);

        $layout = TemplateLayout::factory()->create([
            'template_id' => $userTemplate->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/admin/test',
                'components' => [['id' => 'old_comp', 'type' => 'basic', 'name' => 'OldComponent']],
                'data_sources' => [],
                'metadata' => ['key' => 'old_value'],
            ],
        ]);

        // 기존 버전 없음 확인
        $initialVersionCount = TemplateLayoutVersion::where('layout_id', $layout->id)->count();
        $this->assertEquals(0, $initialVersionCount);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/admin/test',
                'components' => [['id' => 'new_comp', 'type' => 'basic', 'name' => 'NewComponent']],
                'data_sources' => [],
                'metadata' => ['key' => 'new_value'],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$userTemplate->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(200);

        // 2개의 버전이 생성되어야 함 (이전 버전 + 현재 저장 버전)
        $versions = TemplateLayoutVersion::where('layout_id', $layout->id)
            ->orderBy('version', 'asc')
            ->get();

        $this->assertCount(2, $versions);

        // 버전 1: 이전 content (롤백용)
        $this->assertEquals(1, $versions[0]->version);
        $this->assertEquals('old_comp', $versions[0]->content['components'][0]['id']);
        $this->assertEquals('old_value', $versions[0]->content['metadata']['key']);

        // 버전 2: 현재 저장된 content (최신 상태)
        $this->assertEquals(2, $versions[1]->version);
        $this->assertEquals('new_comp', $versions[1]->content['components'][0]['id']);
        $this->assertEquals('new_value', $versions[1]->content['metadata']['key']);
    }

    /**
     * 연속 업데이트 시 버전 히스토리가 올바르게 누적되는지 확인
     */
    public function test_multiple_updates_accumulate_version_history_correctly(): void
    {
        // Arrange - user 템플릿 생성
        $userTemplate = Template::factory()->create([
            'type' => 'user',
        ]);

        $layout = TemplateLayout::factory()->create([
            'template_id' => $userTemplate->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/admin/test',
                'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                'data_sources' => [],
                'metadata' => ['step' => 'initial'],
            ],
        ]);

        // Act - 첫 번째 업데이트
        $response1 = $this->authRequest()
            ->putJson("/api/admin/templates/{$userTemplate->identifier}/layouts/{$layout->name}", [
                'content' => [
                    'version' => '1.0.0',
                    'layout_name' => 'test-layout',
                    'endpoint' => '/api/admin/test',
                    'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                    'data_sources' => [],
                    'metadata' => ['step' => 'first_update'],
                ],
            ]);
        $response1->assertStatus(200);

        // Act - 두 번째 업데이트
        $response2 = $this->authRequest()
            ->putJson("/api/admin/templates/{$userTemplate->identifier}/layouts/{$layout->name}", [
                'content' => [
                    'version' => '1.0.0',
                    'layout_name' => 'test-layout',
                    'endpoint' => '/api/admin/test',
                    'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                    'data_sources' => [],
                    'metadata' => ['step' => 'second_update'],
                ],
            ]);
        $response2->assertStatus(200);

        // Assert
        $versions = TemplateLayoutVersion::where('layout_id', $layout->id)
            ->orderBy('version', 'asc')
            ->get();

        // 첫 번째 업데이트: 2개 버전 (v1: old, v2: new)
        // 두 번째 업데이트: 2개 버전 추가 (v3: old, v4: new)
        // 총 4개 버전
        $this->assertCount(4, $versions);

        // 버전 1: 최초 content
        $this->assertEquals(1, $versions[0]->version);
        $this->assertEquals('initial', $versions[0]->content['metadata']['step']);

        // 버전 2: 첫 번째 업데이트된 content
        $this->assertEquals(2, $versions[1]->version);
        $this->assertEquals('first_update', $versions[1]->content['metadata']['step']);

        // 버전 3: 두 번째 업데이트 전 content (first_update)
        $this->assertEquals(3, $versions[2]->version);
        $this->assertEquals('first_update', $versions[2]->content['metadata']['step']);

        // 버전 4: 두 번째 업데이트된 content
        $this->assertEquals(4, $versions[3]->version);
        $this->assertEquals('second_update', $versions[3]->content['metadata']['step']);
    }

    /**
     * 레이아웃 업데이트 시 meta 필드 포함
     *
     * meta 필드가 validated() 결과에 포함되어 저장되는지 확인
     * (이전에는 rules에 없어서 meta가 사라지는 버그가 있었음)
     */
    public function test_update_layout_preserves_meta_field(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'meta' => [
                    'title' => 'Old Title',
                    'description' => 'Old Description',
                ],
                'endpoint' => '/api/test',
                'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                'data_sources' => [],
            ],
        ]);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'meta' => [
                    'title' => '$t:new.title',
                    'description' => '$t:new.description',
                    'auth_required' => true,
                ],
                'endpoint' => '/api/admin/test',
                'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                'data_sources' => [],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(200);

        $layout->refresh();
        $this->assertArrayHasKey('meta', $layout->content);
        $this->assertEquals('$t:new.title', $layout->content['meta']['title']);
        $this->assertEquals('$t:new.description', $layout->content['meta']['description']);
        $this->assertTrue($layout->content['meta']['auth_required']);
    }

    /**
     * 레이아웃 업데이트 시 modals, state, init_actions 필드 포함
     */
    public function test_update_layout_preserves_additional_fields(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-layout',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'endpoint' => '/api/test',
                'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                'data_sources' => [],
            ],
        ]);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-layout',
                'meta' => [
                    'title' => 'Test Title',
                ],
                'endpoint' => '/api/admin/test',
                'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
                'data_sources' => [],
                'modals' => [
                    [
                        'id' => 'test_modal',
                        'type' => 'composite',
                        'name' => 'Modal',
                    ],
                ],
                'state' => [
                    'selectedItem' => null,
                    'isLoading' => false,
                ],
                'init_actions' => [
                    [
                        'handler' => 'setState',
                        'params' => [
                            'target' => 'global',
                            'testValue' => true,
                        ],
                    ],
                ],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(200);

        $layout->refresh();
        $this->assertArrayHasKey('modals', $layout->content);
        $this->assertArrayHasKey('state', $layout->content);
        $this->assertArrayHasKey('init_actions', $layout->content);
        $this->assertCount(1, $layout->content['modals']);
        $this->assertEquals('test_modal', $layout->content['modals'][0]['id']);
        $this->assertFalse($layout->content['state']['isLoading']);
        $this->assertEquals('setState', $layout->content['init_actions'][0]['handler']);
    }

    /**
     * 레이아웃 업데이트 시 extends 레이아웃도 모든 필드 보존
     */
    public function test_update_extends_layout_preserves_all_fields(): void
    {
        // Arrange - 부모 레이아웃 먼저 생성 (Base 레이아웃)
        // Base 레이아웃에는 slot이 정의된 컴포넌트가 있어야 자식이 해당 슬롯을 사용할 수 있음
        TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => '_admin_base',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => '_admin_base',
                'meta' => [
                    'title' => 'Admin Base',
                    'is_base' => true,
                ],
                'components' => [
                    [
                        'id' => 'root',
                        'type' => 'layout',
                        'name' => 'Container',
                        'children' => [
                            [
                                'id' => 'content_slot',
                                'type' => 'layout',
                                'name' => 'Div',
                                'slot' => 'content',  // content 슬롯 정의
                            ],
                        ],
                    ],
                ],
            ],
        ]);

        // extends 레이아웃 (부모 상속)
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'test-child-layout',
            'extends' => '_admin_base',
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-child-layout',
                'extends' => '_admin_base',
                'meta' => [
                    'title' => 'Old Title',
                ],
                'slots' => [
                    'content' => [],
                ],
                'data_sources' => [],
            ],
        ]);

        $updateData = [
            'content' => [
                'version' => '1.0.0',
                'layout_name' => 'test-child-layout',
                'extends' => '_admin_base',
                'meta' => [
                    'title' => 'New Title',
                    'description' => 'New Description',
                ],
                'slots' => [
                    'content' => [
                        ['id' => 'new_component', 'type' => 'basic', 'name' => 'Div'],
                    ],
                ],
                'data_sources' => [
                    ['id' => 'test_data', 'type' => 'api', 'endpoint' => '/api/admin/test'],
                ],
                'state' => [
                    'selectedTab' => 'info',
                ],
                'modals' => [],
            ],
        ];

        // Act
        $response = $this->authRequest()
            ->putJson("/api/admin/templates/{$this->template->identifier}/layouts/{$layout->name}", $updateData);

        // Assert
        $response->assertStatus(200);

        $layout->refresh();
        $this->assertEquals('_admin_base', $layout->content['extends']);
        $this->assertEquals('New Title', $layout->content['meta']['title']);
        $this->assertEquals('New Description', $layout->content['meta']['description']);
        $this->assertCount(1, $layout->content['slots']['content']);
        $this->assertArrayHasKey('state', $layout->content);
        $this->assertEquals('info', $layout->content['state']['selectedTab']);
    }

    // ========================================
    // 미리보기 (Preview) 테스트
    // ========================================

    /**
     * 미리보기 생성 성공
     */
    public function test_can_store_preview(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'main',
        ]);

        $content = [
            'version' => '1.0.0',
            'layout_name' => 'main',
            'components' => [['id' => 'root', 'type' => 'layout', 'name' => 'Container']],
            'data_sources' => [],
        ];

        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/main/preview", [
                'content' => $content,
            ]);

        // Assert
        $response->assertStatus(200);
        $response->assertJsonStructure([
            'data' => ['token', 'preview_url', 'expires_at'],
        ]);

        $token = $response->json('data.token');
        $this->assertNotEmpty($token);
        $this->assertStringStartsWith('/preview/', $response->json('data.preview_url'));

        // DB에 저장 확인
        $this->assertDatabaseHas('template_layout_previews', [
            'token' => $token,
            'template_id' => $this->template->id,
            'layout_name' => 'main',
            'admin_id' => $this->adminUser->id,
        ]);
    }

    /**
     * 슬래시 포함 레이아웃 이름으로 미리보기 생성 성공
     */
    public function test_can_store_preview_with_slash_in_layout_name(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'auth/reset_password',
        ]);

        $content = [
            'version' => '1.0.0',
            'layout_name' => 'auth/reset_password',
            'components' => [],
        ];

        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/auth/reset_password/preview", [
                'content' => $content,
            ]);

        // Assert
        $response->assertStatus(200);
        $response->assertJsonStructure([
            'data' => ['token', 'preview_url', 'expires_at'],
        ]);
    }

    /**
     * 미리보기 생성 시 content 필수 검증
     */
    public function test_store_preview_requires_content(): void
    {
        // Act
        $response = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/main/preview", []);

        // Assert
        $response->assertStatus(422);
        $response->assertJsonValidationErrors(['content']);
    }

    /**
     * 동일 조합으로 미리보기 재생성 시 이전 미리보기 삭제
     */
    public function test_store_preview_replaces_existing_preview(): void
    {
        // Arrange
        $content1 = ['version' => '1.0.0', 'components' => [['id' => 'v1']]];
        $content2 = ['version' => '1.0.0', 'components' => [['id' => 'v2']]];

        // Act - 첫 번째 미리보기 생성
        $response1 = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/main/preview", [
                'content' => $content1,
            ]);
        $token1 = $response1->json('data.token');

        // Act - 두 번째 미리보기 생성 (동일 레이아웃)
        $response2 = $this->authRequest()
            ->postJson("/api/admin/templates/{$this->template->identifier}/layouts/main/preview", [
                'content' => $content2,
            ]);
        $token2 = $response2->json('data.token');

        // Assert - 첫 번째 토큰은 삭제되고 두 번째만 존재
        $this->assertDatabaseMissing('template_layout_previews', ['token' => $token1]);
        $this->assertDatabaseHas('template_layout_previews', ['token' => $token2]);
    }

    /**
     * 존재하지 않는 템플릿으로 미리보기 생성 시 404
     */
    public function test_store_preview_with_nonexistent_template_returns_404(): void
    {
        // Act
        $response = $this->authRequest()
            ->postJson('/api/admin/templates/nonexistent-template/layouts/main/preview', [
                'content' => ['version' => '1.0.0', 'components' => []],
            ]);

        // Assert
        $response->assertStatus(404);
    }

    /**
     * 미인증 사용자 미리보기 생성 불가
     */
    public function test_unauthenticated_user_cannot_store_preview(): void
    {
        // Act
        $response = $this->postJson("/api/admin/templates/{$this->template->identifier}/layouts/main/preview", [
            'content' => ['version' => '1.0.0', 'components' => []],
        ]);

        // Assert
        $response->assertStatus(401);
    }

    /**
     * 슬래시 포함 레이아웃 이름 조회 성공
     */
    public function test_can_show_layout_with_slash_in_name(): void
    {
        // Arrange
        $layout = TemplateLayout::factory()->create([
            'template_id' => $this->template->id,
            'name' => 'auth/login',
        ]);

        // Act
        $response = $this->authRequest()
            ->getJson("/api/admin/templates/{$this->template->identifier}/layouts/auth/login");

        // Assert
        $response->assertStatus(200);
    }
}