<?php

namespace App\Http\Controllers;

use App\Models\AcademicYear;
use App\Models\Department;
use App\Models\DocumentType;
use App\Models\SchoolClass;
use App\Models\Student;
use App\Models\StudentAchievement;
use App\Models\StudentDocument;
use App\Models\StudentExit;
use App\Models\StudentGraduation;
use App\Models\StudentTransfer;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Storage;
use Illuminate\View\View;
use RealRashid\SweetAlert\Facades\Alert;

class MaintenanceController extends Controller
{
    protected array $availableTargets = [
        'academic_years' => 'Tahun Angkatan',
        'departments' => 'Program Keahlian',
        'classes' => 'Kelas',
        'document_types' => 'Jenis Dokumen',
        'students' => 'Data Siswa',
        'student_parents' => 'Orang Tua / Wali',
        'student_documents' => 'Dokumen Siswa + file storage',
        'student_academic_histories' => 'Histori Akademik Siswa',
        'student_achievements' => 'Prestasi Siswa + file storage',
        'student_exits' => 'Arsip Siswa Keluar + file storage',
        'student_transfers' => 'Arsip Mutasi Siswa + file storage',
        'student_graduations' => 'Arsip Kelulusan Siswa + file storage',
    ];

    public function index(): View
    {
        return view('maintenance.reset-data', [
            'stats' => [
                'academicYears' => AcademicYear::count(),
                'departments' => Department::count(),
                'classes' => SchoolClass::count(),
                'documentTypes' => DocumentType::count(),
                'students' => Student::withTrashed()->count(),
                'studentParents' => DB::table('student_parents')->count(),
                'studentDocuments' => StudentDocument::withTrashed()->count(),
                'studentAcademicHistories' => DB::table('student_academic_histories')->count(),
                'studentAchievements' => StudentAchievement::count(),
                'studentExits' => StudentExit::count(),
                'studentTransfers' => StudentTransfer::count(),
                'studentGraduations' => StudentGraduation::count(),
            ],
            'targets' => $this->availableTargets,
            'resolvedTargetsPreview' => $this->buildResolvedTargetPreview(),
        ]);
    }


    public function reset(Request $request): RedirectResponse
    {
        $data = $request->validate([
            'targets' => ['required', 'array', 'min:1'],
            'targets.*' => ['string'],
            'admin_password' => ['required', 'string'],
        ]);

        if (! Hash::check($data['admin_password'], (string) $request->user()->password)) {
            return back()->withErrors([
                'admin_password' => 'Password admin tidak valid.',
            ])->withInput();
        }

        $targets = collect($data['targets'])
            ->filter(fn ($target) => array_key_exists($target, $this->availableTargets))
            ->values();

        if ($targets->isEmpty()) {
            return back()->withErrors([
                'targets' => 'Pilih minimal satu kelompok data yang ingin dikosongkan.',
            ])->withInput();
        }

        $resolvedTargets = $this->resolveTargets($targets->all());

        DB::transaction(function () use ($resolvedTargets) {
            if (in_array('student_achievements', $resolvedTargets, true)) {
                StudentAchievement::query()->get()->each(function (StudentAchievement $achievement) {
                    foreach ([$achievement->certificate_file, $achievement->activity_photo] as $path) {
                        if ($path && Storage::disk('public')->exists($path)) {
                            Storage::disk('public')->delete($path);
                        }
                    }
                });
                DB::table('student_achievements')->delete();
            }

            if (in_array('student_exits', $resolvedTargets, true)) {
                StudentExit::query()->get()->each(function (StudentExit $studentExit) {
                    if ($studentExit->exit_letter_file_path && Storage::disk('public')->exists($studentExit->exit_letter_file_path)) {
                        Storage::disk('public')->delete($studentExit->exit_letter_file_path);
                    }
                });
                DB::table('student_exits')->delete();
            }

            if (in_array('student_transfers', $resolvedTargets, true)) {
                StudentTransfer::query()->get()->each(function (StudentTransfer $studentTransfer) {
                    if ($studentTransfer->transfer_letter_file_path && Storage::disk('public')->exists($studentTransfer->transfer_letter_file_path)) {
                        Storage::disk('public')->delete($studentTransfer->transfer_letter_file_path);
                    }
                });
                DB::table('student_transfers')->delete();
            }

            if (in_array('student_graduations', $resolvedTargets, true)) {
                StudentGraduation::query()->get()->each(function (StudentGraduation $graduation) {
                    foreach ([
                        $graduation->skl_file_path,
                        $graduation->ijazah_file_path,
                        $graduation->transcript_file_path,
                        $graduation->ukk_certificate_file_path,
                        $graduation->lsp_certificate_file_path,
                    ] as $path) {
                        if ($path && Storage::disk('public')->exists($path)) {
                            Storage::disk('public')->delete($path);
                        }
                    }
                });
                DB::table('student_graduations')->delete();
            }

            if (in_array('students', $resolvedTargets, true)) {
                Student::withTrashed()->get()->each->forceDelete();
            }

            if (in_array('student_documents', $resolvedTargets, true)) {
                StudentDocument::withTrashed()->get()->each(function (StudentDocument $document) {
                    if ($document->file_path && Storage::disk('public')->exists($document->file_path)) {
                        Storage::disk('public')->delete($document->file_path);
                    }
                });
                DB::table('student_documents')->delete();
            }

            if (in_array('student_parents', $resolvedTargets, true)) {
                DB::table('student_parents')->delete();
            }

            if (in_array('student_academic_histories', $resolvedTargets, true)) {
                DB::table('student_academic_histories')->delete();
            }

            if (in_array('students', $resolvedTargets, true)) {
                DB::table('students')->delete();
            }

            if (in_array('classes', $resolvedTargets, true)) {
                DB::table('classes')->delete();
            }

            if (in_array('document_types', $resolvedTargets, true)) {
                DB::table('document_types')->delete();
            }

            if (in_array('departments', $resolvedTargets, true)) {
                DB::table('departments')->delete();
            }

            if (in_array('academic_years', $resolvedTargets, true)) {
                DB::table('academic_years')->delete();
            }
        });

        if (in_array('student_documents', $resolvedTargets, true)) {
            Storage::disk('public')->deleteDirectory('student-documents');
        }

        if (in_array('student_achievements', $resolvedTargets, true)) {
            Storage::disk('public')->deleteDirectory('student-achievements');
        }

        if (in_array('student_exits', $resolvedTargets, true)) {
            Storage::disk('public')->deleteDirectory('student-exit-letters');
        }

        if (in_array('student_transfers', $resolvedTargets, true)) {
            Storage::disk('public')->deleteDirectory('student-transfer-letters');
        }

        if (in_array('student_graduations', $resolvedTargets, true)) {
            Storage::disk('public')->deleteDirectory('student-graduation-documents');
        }

        $labels = collect($resolvedTargets)
            ->map(fn ($target) => $this->availableTargets[$target] ?? $target)
            ->implode(', ');

        Alert::success('Berhasil', 'Data berhasil dikosongkan: ' . $labels . '.');

        return redirect()->route('settings.reset-data.index')->with('success', 'Data berhasil dikosongkan: ' . $labels . '.');
    }

    protected function resolveTargets(array $targets): array
    {
        $resolved = collect($targets);

        if ($resolved->contains('students')) {
            $resolved = $resolved->merge([
                'student_documents',
                'student_parents',
                'student_academic_histories',
                'student_achievements',
                'student_exits',
                'student_transfers',
                'student_graduations',
            ]);
        }

        if ($resolved->contains('classes')) {
            $resolved = $resolved->merge([
                'students',
                'student_academic_histories',
                'student_achievements',
                'student_exits',
                'student_transfers',
                'student_graduations',
            ]);
        }

        if ($resolved->contains('document_types')) {
            $resolved = $resolved->merge(['student_documents']);
        }

        if ($resolved->contains('departments')) {
            $resolved = $resolved->merge([
                'classes',
                'students',
                'student_academic_histories',
                'student_achievements',
                'student_exits',
                'student_transfers',
                'student_graduations',
            ]);
        }

        if ($resolved->contains('academic_years')) {
            $resolved = $resolved->merge([
                'classes',
                'students',
                'student_academic_histories',
                'student_achievements',
                'student_exits',
                'student_transfers',
                'student_graduations',
            ]);
        }

        return $resolved->unique()->values()->all();
    }

    protected function buildResolvedTargetPreview(): array
    {
        return collect(array_keys($this->availableTargets))
            ->mapWithKeys(function (string $target) {
                $resolved = $this->resolveTargets([$target]);

                return [
                    $target => collect($resolved)
                        ->map(fn (string $resolvedTarget) => $this->availableTargets[$resolvedTarget] ?? $resolvedTarget)
                        ->values()
                        ->all(),
                ];
            })
            ->all();
    }

}