<?php

    namespace Modules\Lpj\Http\Controllers;

    use App\Http\Controllers\Controller;
    use Exception;
    use Illuminate\Support\Facades\DB;
    use Illuminate\Support\Facades\Storage;
    use Modules\Location\Models\City;
    use Modules\Location\Models\District;
    use Modules\Location\Models\Province;
    use Modules\Location\Models\Village;
    use Modules\Lpj\Http\Requests\DokumenJaminanRequest;
    use Modules\Lpj\Models\Debiture;
    use Modules\Lpj\Models\DetailDokumenJaminan;
    use Modules\Lpj\Models\DokumenJaminan;
    use Modules\Lpj\Models\HubunganPemilikJaminan;
    use Modules\Lpj\Models\JenisJaminan;
    use Modules\Lpj\Models\JenisLegalitasJaminan;
    use Modules\Lpj\Models\PemilikJaminan;
    use Illuminate\Http\JsonResponse;
    use Illuminate\Support\Collection;
    use ZipArchive;

    class DokumenJaminanController extends Controller
    {
        public $user;


        public function index($id)
        {
            $debitur   = Debiture::find($id);
            $documents = DokumenJaminan::with('pemilik', 'detail')->where('debiture_id', $id)->get();

            return view(
                'lpj::debitur.edit',
                compact('debitur', 'documents'),
            );
        }

        public function store(DokumenJaminanRequest $request, $id)
        {
            $debitur = Debiture::find($id);

            $validate = $request->validated();

            if ($validate) {
                try {
                    DB::beginTransaction();
                    $validate['debiture_id'] = $id;

                    if ($validate['pemilik_jaminan_id'] == 0) {
                        $pemilik_jaminan = [
                            'hubungan_pemilik_jaminan_id' => 1,
                            'npwp'                        => $debitur->npwp,
                            'email'                       => $debitur->email,
                            'phone'                       => $debitur->phone,
                            'province_code'               => $debitur->province_code,
                            'city_code'                   => $debitur->city_code,
                            'district_code'               => $debitur->district_code,
                            'village_code'                => $debitur->village_code,
                            'postal_code'                 => $debitur->postal_code,
                            'address'                     => $debitur->address,
                        ];

                        $pemilikJaminan                 = PemilikJaminan::updateOrCreate([
                            'debiture_id' => $id,
                            'name'        => $debitur->name,
                        ], $pemilik_jaminan);
                        $validate['pemilik_jaminan_id'] = $pemilikJaminan->id;
                    }

                    $document = DokumenJaminan::create($validate);

                    try {
                        foreach ($request->dokumen_jaminan as $key => $value) {
                            $file_name = $value->getClientOriginalName();

                            if ($file_name) {
                                try {
                                    $file_name = $value->getClientOriginalName();
                                    $value->storeAs(
                                        'public/jaminan/' . $debitur->id . '/' . $document->id . '/',
                                        $file_name,
                                    );

                                    $detail = [
                                        'dokumen_jaminan_id'         => $document->id,
                                        'jenis_legalitas_jaminan_id' => $request->jenis_legalitas_jaminan_id[$key],
                                        'dokumen_jaminan'            => 'jaminan/' . $debitur->id . '/' . $document->id . '/' . $file_name,
                                        'name'                       => $request->name[$key],
                                        'keterangan'                 => $request->keterangan[$key],
                                        'details'                    => isset($request->custom_field[$key]) ? json_encode($request->custom_field[$key]) : '',
                                    ];
                                    DetailDokumenJaminan::create($detail);
                                } catch (Exception $e) {
                                    DB::rollBack();
                                    return redirect()->route('debitur.jaminan.index', $id)->with(
                                        'error',
                                        'Gagal upload file dokumen jaminan ' . $key . ': ' . $e->getMessage(),
                                    );
                                }
                            }
                        }
                        DB::commit();
                    } catch (Exception $e) {
                        DB::rollBack();
                        return redirect()->route('debitur.jaminan.index', $id)->with(
                            'error',
                            'gg' . $e->getMessage(),
                        );
                    }

                    return redirect()->route('debitur.jaminan.index', $id)->with(
                        'success',
                        'Dokumen Jaminan berhasil ditambahkan',
                    );
                } catch (Exception $e) {
                    DB::rollBack();
                    return redirect()->route('debitur.jaminan.index', $id)->with('error', 'ggl' . $e->getMessage());
                }
            }
        }

        public function create($id)
        {
            $debitur               = Debiture::find($id);
            $provinces             = Province::all();
            $jenisJaminan          = JenisJaminan::all();
            $jenisLegalitasJaminan = JenisLegalitasJaminan::all();
            $pemilikJaminan        = PemilikJaminan::where('debiture_id', $id)->get();
            $hubunganPemilik       = HubunganPemilikJaminan::all();

            return view(
                'lpj::debitur.jaminan',
                compact(
                    'debitur',
                    'provinces',
                    'jenisJaminan',
                    'jenisLegalitasJaminan',
                    'pemilikJaminan',
                    'hubunganPemilik',
                ),
            );
        }

        public function update(DokumenJaminanRequest $request, $id, $jaminan)
        {
            $debitur = Debiture::find($id);

            $validate = $request->validated();
            if ($validate) {
                try {
                    DB::beginTransaction();
                    $validate['debiture_id'] = $id;

                    if ($validate['pemilik_jaminan_id'] == 00) {
                        $pemilik_jaminan = [
                            'hubungan_pemilik_jaminan_id' => request()->get('hubungan_pemilik_jaminan_id'),
                            'province_code'               => $debitur->province_code,
                            'city_code'                   => $debitur->city_code,
                            'district_code'               => $debitur->district_code,
                            'village_code'                => $debitur->village_code,
                            'postal_code'                 => $debitur->postal_code,
                            'address'                     => $debitur->address,
                            'nomor_id'                    => request()->get('nomor_id'),
                            'name'                        => request()->get('pemilik_name'),
                        ];

                        $detailSertifikat = [];
                        $names            = request()->input('detail_sertifikat.name', []);
                        $nomorIds         = request()->input('detail_sertifikat.nomor_id', []);

                        foreach ($names as $index => $name) {
                            if (isset($nomorIds[$index])) {
                                $detailSertifikat[] = [
                                    'name'     => $name,
                                    'nomor_id' => $nomorIds[$index],
                                ];
                            }
                        }

                        $pemilik_jaminan['detail_sertifikat'] = json_encode($detailSertifikat);

                        //dd($pemilik_jaminan);

                        try {
                            $pemilikJaminan = PemilikJaminan::updateOrCreate([
                                'debiture_id' => $id,
                                'name'        => request()->get('pemilik_name'),
                            ], $pemilik_jaminan);
                        } catch (Exception $e) {
                            return redirect()->route('debitur.jaminan.index', $id)->with(
                                'error',
                                'Gagal update pemilik jaminan: ' . $e->getMessage(),
                            );
                        }

                        $validate['pemilik_jaminan_id'] = $pemilikJaminan->id;
                    }


                    if ($validate['pemilik_jaminan_id'] == 0) {
                        $pemilik_jaminan = [
                            'hubungan_pemilik_jaminan_id' => 1,
                            'npwp'                        => $debitur->npwp,
                            'email'                       => $debitur->email,
                            'phone'                       => $debitur->phone,
                            'province_code'               => $debitur->province_code,
                            'city_code'                   => $debitur->city_code,
                            'district_code'               => $debitur->district_code,
                            'village_code'                => $debitur->village_code,
                            'postal_code'                 => $debitur->postal_code,
                            'address'                     => $debitur->address,
                        ];

                        $pemilikJaminan = PemilikJaminan::updateOrCreate([
                            'debiture_id' => $id,
                            'name'        => $debitur->name,
                        ], $pemilik_jaminan);

                        $validate['pemilik_jaminan_id'] = $pemilikJaminan->id;
                    }

                    $document = DokumenJaminan::find($jaminan);
                    $document->update($validate);

                    // Get existing detail documents
                    $existingDetails = DetailDokumenJaminan::where('dokumen_jaminan_id', $document->id)->get()->keyBy('id');

                    if($request->jenis_legalitas_jaminan_id){
                        foreach($request->jenis_legalitas_jaminan_id as $key => $value){
                            $detailData = [
                                'dokumen_jaminan_id' => $document->id,
                                'jenis_legalitas_jaminan_id' => $value,
                                'name' => $request->name[$key],
                                'keterangan' => $request->keterangan[$key],
                            ];

                            $dokumenJaminan = [];
                            if (isset($request->dokumen_jaminan[$key]) && is_array($request->dokumen_jaminan[$key])) {
                                foreach($request->dokumen_jaminan[$key] as $file) {
                                    if ($file) {
                                        $file_name = $file->getClientOriginalName();
                                        $file->storeAs(
                                            'public/jaminan/' . $debitur->id . '/' . $document->id . '/',
                                            $file_name
                                        );
                                        $dokumenJaminan[] = 'jaminan/' . $debitur->id . '/' . $document->id . '/' . $file_name;
                                    }
                                }
                            }

                            if (!empty($dokumenJaminan)) {
                                $detailData['dokumen_jaminan'] = json_encode($dokumenJaminan);
                            }

                            if (isset($request->detail_dokumen_jaminan_id[$key])) {
                                $detailId = $request->detail_dokumen_jaminan_id[$key];
                                $detailDocument = $existingDetails->get($detailId);
                                if ($detailDocument) {
                                    // Merge new files with existing ones
                                    if (!empty($dokumenJaminan)) {
                                        $existingFiles = json_decode($detailDocument->dokumen_jaminan, true) ?: [];
                                        $mergedFiles = array_merge($existingFiles, $dokumenJaminan);
                                        $detailData['dokumen_jaminan'] = json_encode($mergedFiles);
                                    }
                                    $detailDocument->update($detailData);
                                    $existingDetails->forget($detailId);
                                }
                            } else {
                                DetailDokumenJaminan::create($detailData);
                            }
                        }
                    }

                    // Delete any remaining existing details that weren't updated
                    foreach ($existingDetails as $detail) {
                        $files = json_decode($detail->dokumen_jaminan, true) ?: [];
                        foreach ($files as $file) {
                            Storage::delete('public/' . $file);
                        }
                        $detail->delete();
                    }

                    DB::commit();
                    return redirect()->route('debitur.jaminan.index', $id)->with(
                        'success',
                        'Dokumen Jaminan berhasil diubah',
                    );
                } catch (Exception $e) {
                    DB::rollBack();
                    return redirect()->route('debitur.jaminan.index', $id)->with('error', $e->getMessage());
                }
            }
        }

        public function edit(
            $id,
            $jaminan,
        ) {
            $document              = DokumenJaminan::find($jaminan);
            $details               = DetailDokumenJaminan::where('dokumen_jaminan_id', $document->id)->get();

            $debitur               = Debiture::find($document->debiture_id);
            $provinces             = Province::all();
            $cities                = City::where('province_code', $document->province_code)->get();
            $districts             = District::where('city_code', $document->city_code)->get();
            $villages              = Village::where('district_code', $document->district_code)->get();


            $jenisJaminan          = JenisJaminan::all();
            $jenisLegalitasJaminan = JenisLegalitasJaminan::all();

            $_jenisJaminan = JenisJaminan::find($document->jenis_jaminan_id);
            $legalitasJaminan = json_decode($_jenisJaminan->jenis_legalitas_jaminan_id, true);

            $currentLegalitasJaminan = JenisLegalitasJaminan::whereIn('id',$document->detail->pluck('jenis_legalitas_jaminan_id')->toArray())->get();


            // Remove values from $legalitasJaminan that are in $currentLegalitasJaminan
            $legalitasJaminan = array_diff($legalitasJaminan, $currentLegalitasJaminan->pluck('code')->toArray());

            $legalitas = JenisLegalitasJaminan::whereIn('code', $legalitasJaminan)->get();

            $pemilikJaminan        = PemilikJaminan::where('debiture_id', $document->debiture_id)->get();
            $hubunganPemilik       = HubunganPemilikJaminan::all();

            return view(
                'lpj::debitur.jaminan',
                compact(
                    'debitur',
                    'provinces',
                    'jenisJaminan',
                    'jenisLegalitasJaminan',
                    'document',
                    'details',
                    'cities',
                    'districts',
                    'villages',
                    'pemilikJaminan',
                    'hubunganPemilik',
                    'legalitas'
                ),
            );
        }

        public function destroy(
            $id,
            $jaminan_id,
        ) {
            try {
                $jaminan = DokumenJaminan::find($jaminan_id);
                $details = DetailDokumenJaminan::where('dokumen_jaminan_id', $jaminan->id)->get();
                foreach ($details as $detail) {
                    Storage::delete('public/' . $detail->dokumen_jaminan);
                    $detail->delete();
                }
                $jaminan->delete();
                echo json_encode(['success' => true, 'message' => 'Dokumen Jaminan deleted successfully']);
            } catch (Exception $e) {
                echo json_encode(['success' => false, 'message' => 'Failed to delete Dokumen Jaminan']);
            }
        }

        public function bulkDownload()
        {
            $dokumenIds = request()->get('jaminan'); // Expecting an array of dokumen_jaminan_id
            $documents  = DetailDokumenJaminan::where('dokumen_jaminan_id', $dokumenIds)->get();
            if ($documents->isEmpty()) {
                return redirect()->back()->with('error', 'No documents found for the provided IDs.');
            }

            $zip         = new ZipArchive;
            $zipFileName = 'documents_jaminan_' . $dokumenIds . '.zip';
            $zipFilePath = storage_path('app/public/' . $zipFileName);

            if ($zip->open($zipFilePath, ZipArchive::CREATE) === true) {
                foreach ($documents as $document) {
                    $files = is_array(json_decode($document->dokumen_jaminan)) ? json_decode($document->dokumen_jaminan) : [$document->dokumen_jaminan];

                    foreach ($files as $file) {
                        $filePath = storage_path('app/public/' . $file);
                        if (file_exists($filePath)) {
                            $zip->addFile($filePath, basename($filePath));
                        } else {
                            // Log or display an error message for missing files
                            return redirect()->back()->with('error', 'File not found: ' . $filePath);
                        }
                    }
                }
                $zip->close();

                if (!file_exists($zipFilePath)) {
                    return redirect()->back()->with('error', 'Failed to create ZIP file.');
                }
            } else {
                return redirect()->back()->with('error', 'Failed to create ZIP file.');
            }

            return response()->download($zipFilePath, $zipFileName, [
                'Content-Type'        => 'application/zip',
                'Content-Disposition' => 'attachment; filename="' . $zipFileName . '"',
                'Content-Length'      => filesize($zipFilePath),
            ])->deleteFileAfterSend(false);
        }


        public function download()
        {
            $dokumen  = request()->get('dokumen');
            $document = DetailDokumenJaminan::find($dokumen);
            $file = is_array(json_decode($document->dokumen_jaminan)) ? json_decode($document->dokumen_jaminan) : [$document->dokumen_jaminan];
            return response()->download(storage_path('app/public/' . $file[request()->get('index')]));
        }

        public function legalitasJaminan($id)
        {
            $jenisJaminan     = JenisJaminan::find($id);
            $legalitasJaminan = $jenisJaminan->jenis_legalitas_jaminan_id;

            $legalitas = JenisLegalitasJaminan::whereIn('code', json_decode($legalitasJaminan, true))->get();
            echo json_encode($legalitas);
        }


        public function getLegalitasJaminan($id = 10, $jenisJaminanId = 1) : JsonResponse
        {

            $jenisJaminan = JenisJaminan::findOrFail($jenisJaminanId);
            $legalitasJaminan = $jenisJaminan->jenis_legalitas_jaminan_id;
            $newLegalitasJaminan = JenisLegalitasJaminan::whereIn('code', json_decode($legalitasJaminan, true))->get();

            $existingLegalitas = [];
            $newLegalitas = [];

            // Create a set of new jenis_legalitas_jaminan_ids for quick lookup
            $newLegalitasIds = $newLegalitasJaminan->pluck('id')->toArray();

            if($id>0) {
                $document = DokumenJaminan::findOrFail($id);
                if ($document && $document->detail) {
                    foreach ($document->detail as $detail) {
                        // Only include existing legalitas if its id is in the new set
                        if (in_array($detail->jenis_legalitas_jaminan_id, $newLegalitasIds)) {
                            $existingLegalitas[] = [
                                'id'                         => $detail->id,
                                'jenis_legalitas_jaminan_id' => $detail->jenis_legalitas_jaminan_id,
                                'name'                       => $detail->jenisLegalitasJaminan->name,
                                'dokumen_jaminan'            => json_decode($detail->dokumen_jaminan) ?? $detail->dokumen_jaminan,
                                'custom_field'               => $detail->jenisLegalitasJaminan->custom_field,
                                'custom_field_type'          => $detail->jenisLegalitasJaminan->custom_field_type,
                                'details'                    => $detail->details,
                                'keterangan'                 => $detail->keterangan,
                                'is_existing'                => true
                            ];
                        }
                    }
                }
            }

            foreach ($newLegalitasJaminan as $legalitas) {
                if (!Collection::make($existingLegalitas)->contains('jenis_legalitas_jaminan_id', $legalitas->id)) {
                    $newLegalitas[] = [
                        'id' => null,
                        'jenis_legalitas_jaminan_id' => $legalitas->id,
                        'name' => $legalitas->name,
                        'dokumen_jaminan' => null,
                        'custom_field' => $legalitas->custom_field,
                        'custom_field_type' => $legalitas->custom_field_type,
                        'details' => null,
                        'keterangan' => null,
                        'is_existing' => false
                    ];
                }
            }

            $combinedLegalitas = array_merge($existingLegalitas, $newLegalitas);
            return response()->json($combinedLegalitas);
        }
    }