<?php

namespace App\Modules\Courses\Http;

use App\Http\Controllers\Controller;
use App\Modules\Courses\Application\CourseVersionEditor;
use App\Modules\Courses\Domain\Block;
use App\Modules\Courses\Domain\CourseModule;
use App\Modules\Courses\Domain\CourseVersion;
use App\Modules\Courses\Domain\Lesson;
use App\Modules\Courses\Http\Requests\ReorderStructureRequest;
use App\Modules\Courses\Http\Requests\StoreLessonRequest;
use App\Modules\Courses\Http\Requests\StoreModuleRequest;
use App\Modules\Courses\Http\Requests\UpdateLessonRequest;
use App\Modules\Courses\Http\Requests\UpdateModuleRequest;
use App\Modules\Identity\Application\RolePermissions;
use App\Modules\Identity\Domain\Enums\Permission;
use App\Modules\Tenancy\Application\TenantContext;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;

final class CourseStructureController extends Controller
{
    public function __construct(private readonly TenantContext $tenant, private readonly RolePermissions $permissions, private readonly CourseVersionEditor $versions) {}

    public function storeModule(StoreModuleRequest $request, string $version): JsonResponse
    {
        $this->authorize($request);
        $versionModel = $this->version($version);
        $this->versions->assertDraft($versionModel);
        $module = CourseModule::query()->create(['organization_id' => $this->tenant->id(), 'course_version_id' => $versionModel->getKey(), 'title' => $request->validated('title'), 'position' => ((int) $versionModel->modules()->max('position')) + 1]);

        return response()->json(['data' => $this->modulePayload($module)], 201);
    }

    public function updateModule(UpdateModuleRequest $request, string $module): JsonResponse
    {
        $this->authorize($request);
        $model = $this->module($module);
        $this->versions->assertDraft($this->version($model->course_version_id));
        $data = $request->validated();
        if ($model->is_locked && (($data['locked'] ?? null) !== false || count($data) !== 1)) {
            $this->locked('module');
        }
        $attributes = [];
        if (isset($data['title'])) {
            $attributes['title'] = $data['title'];
        }
        if (array_key_exists('locked', $data)) {
            $attributes['is_locked'] = $data['locked'];
        }
        $model->update($attributes);

        return response()->json(['data' => $this->modulePayload($model)]);
    }

    public function destroyModule(Request $request, string $module): JsonResponse
    {
        $this->authorize($request);
        $model = $this->module($module);
        $this->versions->assertDraft($this->version($model->course_version_id));
        $this->assertUnlocked($model);
        if ($model->lessons()->where('is_locked', true)->exists()) {
            $this->locked('lesson');
        }
        DB::transaction(function () use ($model) {
            $versionId = $model->course_version_id;
            $position = $model->position;
            $model->delete();
            CourseModule::query()->where('course_version_id', $versionId)->where('position', '>', $position)->decrement('position');
        });

        return response()->json(status: 204);
    }

    public function reorderModules(ReorderStructureRequest $request, string $version): JsonResponse
    {
        $this->authorize($request);
        $model = $this->version($version);
        $this->versions->assertDraft($model);
        $ids = $request->validated('ids');
        $this->assertComplete($ids, $model->modules()->pluck('id')->all());
        if ($model->modules()->where('is_locked', true)->exists()) {
            $this->locked('module order');
        }
        $this->reorder(CourseModule::class, 'course_version_id', $model->getKey(), $ids);

        return response()->json(['data' => ['ids' => $ids]]);
    }

    public function storeLesson(StoreLessonRequest $request, string $module): JsonResponse
    {
        $this->authorize($request);
        $moduleModel = $this->module($module);
        $version = $this->version($moduleModel->course_version_id);
        $this->versions->assertDraft($version);
        $this->assertUnlocked($moduleModel);
        $lesson = Lesson::query()->create(['organization_id' => $this->tenant->id(), 'course_version_id' => $version->getKey(), 'course_module_id' => $moduleModel->getKey(), 'title' => $request->validated('title'), 'presentation_mode' => $request->validated('presentationMode', 'flow'), 'position' => ((int) $moduleModel->lessons()->max('position')) + 1]);

        return response()->json(['data' => $this->lessonPayload($lesson)], 201);
    }

    public function updateLesson(UpdateLessonRequest $request, string $lesson): JsonResponse
    {
        $this->authorize($request);
        $model = $this->lesson($lesson);
        $version = $this->version($model->course_version_id);
        $this->versions->assertDraft($version);
        $data = $request->validated();
        $currentModule = $this->module($model->course_module_id);
        $this->assertUnlocked($currentModule);
        if ($model->is_locked && (($data['locked'] ?? null) !== false || count($data) !== 1)) {
            $this->locked('lesson');
        }
        DB::transaction(function () use ($model, $version, $data) {
            $attributes = [];
            if (isset($data['title'])) {
                $attributes['title'] = $data['title'];
            }
            if (isset($data['presentationMode'])) {
                $attributes['presentation_mode'] = $data['presentationMode'];
            }
            if (array_key_exists('locked', $data)) {
                $attributes['is_locked'] = $data['locked'];
            }
            if (isset($data['moduleId']) && $data['moduleId'] !== $model->course_module_id) {
                $target = CourseModule::query()->where('organization_id', $this->tenant->id())->where('course_version_id', $version->getKey())->findOrFail($data['moduleId']);
                $this->assertUnlocked($target);
                $oldModule = $model->course_module_id;
                $oldPosition = $model->position;
                $attributes['course_module_id'] = $target->getKey();
                $attributes['position'] = ((int) $target->lessons()->max('position')) + 1;
                $model->update($attributes);
                Lesson::query()->where('course_module_id', $oldModule)->where('position', '>', $oldPosition)->decrement('position');

                return;
            }
            $model->update($attributes);
        });

        return response()->json(['data' => $this->lessonPayload($model->fresh())]);
    }

    public function destroyLesson(Request $request, string $lesson): JsonResponse
    {
        $this->authorize($request);
        $model = $this->lesson($lesson);
        $this->versions->assertDraft($this->version($model->course_version_id));
        $this->assertUnlocked($this->module($model->course_module_id));
        $this->assertUnlocked($model);
        DB::transaction(function () use ($model) {
            $moduleId = $model->course_module_id;
            $position = $model->position;
            $model->delete();
            Lesson::query()->where('course_module_id', $moduleId)->where('position', '>', $position)->decrement('position');
        });

        return response()->json(status: 204);
    }

    public function reorderLessons(ReorderStructureRequest $request, string $module): JsonResponse
    {
        $this->authorize($request);
        $moduleModel = $this->module($module);
        $this->versions->assertDraft($this->version($moduleModel->course_version_id));
        $ids = $request->validated('ids');
        $this->assertComplete($ids, $moduleModel->lessons()->pluck('id')->all());
        if ($moduleModel->is_locked || $moduleModel->lessons()->where('is_locked', true)->exists()) {
            $this->locked('lesson order');
        }
        $this->reorder(Lesson::class, 'course_module_id', $moduleModel->getKey(), $ids);

        return response()->json(['data' => ['ids' => $ids]]);
    }

    private function reorder(string $model, string $parentKey, string $parentId, array $ids): void
    {
        DB::transaction(function () use ($model, $parentKey, $parentId, $ids) {
            $model::query()->where($parentKey, $parentId)->update(['position' => DB::raw('position + 100000')]);
            foreach ($ids as $index => $id) {
                $model::query()->whereKey($id)->update(['position' => $index + 1]);
            }
        });
    }

    private function assertComplete(array $ids, array $actual): void
    {
        if (count($ids) !== count($actual) || array_diff($ids, $actual) || array_diff($actual, $ids)) {
            throw ValidationException::withMessages(['ids' => ['The order must contain every item exactly once.']]);
        }
    }

    public function duplicateModule(Request $request, string $module): JsonResponse
    {
        $this->authorize($request);
        $source = $this->module($module);
        $version = $this->version($source->course_version_id);
        $this->versions->assertDraft($version);
        $this->assertUnlocked($source);
        $copy = DB::transaction(function () use ($source, $version) {
            $source->load('lessons.blocks');
            $module = CourseModule::query()->create([
                'organization_id' => $this->tenant->id(), 'course_version_id' => $version->getKey(),
                'title' => $source->title.' — کپی', 'position' => ((int) $version->modules()->max('position')) + 1,
                'settings' => $source->settings, 'is_locked' => false,
            ]);
            foreach ($source->lessons->sortBy('position') as $lesson) {
                $newLesson = Lesson::query()->create([
                    'organization_id' => $this->tenant->id(), 'course_version_id' => $version->getKey(),
                    'course_module_id' => $module->getKey(), 'title' => $lesson->title,
                    'position' => $lesson->position, 'presentation_mode' => $lesson->presentation_mode,
                    'settings' => $lesson->settings, 'is_locked' => false,
                ]);
                $this->copyBlocks($lesson, $newLesson);
            }

            return $module;
        });

        return response()->json(['data' => $this->modulePayload($copy)], 201);
    }

    public function duplicateLesson(Request $request, string $lesson): JsonResponse
    {
        $this->authorize($request);
        $source = $this->lesson($lesson);
        $version = $this->version($source->course_version_id);
        $this->versions->assertDraft($version);
        $module = $this->module($source->course_module_id);
        $this->assertUnlocked($module);
        $this->assertUnlocked($source);
        $copy = DB::transaction(function () use ($source, $version, $module) {
            $lesson = Lesson::query()->create([
                'organization_id' => $this->tenant->id(), 'course_version_id' => $version->getKey(),
                'course_module_id' => $module->getKey(), 'title' => $source->title.' — کپی',
                'position' => ((int) $module->lessons()->max('position')) + 1,
                'presentation_mode' => $source->presentation_mode, 'settings' => $source->settings, 'is_locked' => false,
            ]);
            $this->copyBlocks($source, $lesson);

            return $lesson;
        });

        return response()->json(['data' => $this->lessonPayload($copy)], 201);
    }

    private function copyBlocks(Lesson $source, Lesson $target): void
    {
        $source->loadMissing('blocks');
        foreach ($source->blocks->sortBy('position') as $block) {
            Block::query()->create([
                'organization_id' => $this->tenant->id(), 'course_version_id' => $target->course_version_id,
                'lesson_id' => $target->getKey(), 'type' => $block->type, 'schema_version' => $block->schema_version,
                'data' => $block->data, 'style' => $block->style, 'behavior' => $block->behavior,
                'responsive' => $block->responsive, 'accessibility' => $block->accessibility,
                'position' => $block->position, 'revision' => 1,
            ]);
        }
    }

    private function assertUnlocked(CourseModule|Lesson $model): void
    {
        if ($model->is_locked) {
            $this->locked($model instanceof CourseModule ? 'module' : 'lesson');
        }
    }

    private function locked(string $target): never
    {
        throw ValidationException::withMessages(['locked' => ["The {$target} is locked."]]);
    }

    private function version(string $id): CourseVersion
    {
        return CourseVersion::query()->where('organization_id', $this->tenant->id())->findOrFail($id);
    }

    private function module(string $id): CourseModule
    {
        return CourseModule::query()->where('organization_id', $this->tenant->id())->findOrFail($id);
    }

    private function lesson(string $id): Lesson
    {
        return Lesson::query()->where('organization_id', $this->tenant->id())->findOrFail($id);
    }

    private function modulePayload(CourseModule $module): array
    {
        return ['id' => $module->getKey(), 'title' => $module->title, 'position' => $module->position, 'locked' => $module->is_locked, 'lessons' => []];
    }

    private function lessonPayload(Lesson $lesson): array
    {
        return ['id' => $lesson->getKey(), 'title' => $lesson->title, 'position' => $lesson->position, 'presentationMode' => $lesson->presentation_mode, 'locked' => $lesson->is_locked, 'blockCount' => $lesson->blocks()->count()];
    }

    private function authorize(Request $request): void
    {
        abort_unless($this->permissions->allows($request->user(), Permission::CoursesAuthor), 403);
    }
}