<?php

namespace Modules\Internal\Http\Controllers\Api;
use App\Helpers\Helper;
use App\Models\DailyMonitoring;
use App\Models\RequestDailyMonitoring;
use App\Models\MedicalPlan;
use DB;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\File as Files;
use Modules\Internal\Transformers\DailyMonitoringResource;
use App\Models\File;
use Carbon\Carbon;


/**
 * Bagaskoro BSD 27-10-2023
 *
 * Controller untuk daily monitoring
 */
class DailyMonitoringController extends Controller
{
    protected $path_for_store  = 'public/lab_result';
    protected function messages()
    {
        return [
            'required'      => ':attribute harus diisi',
            'integer'       => ':attribute harus angka',
            'unique'        => ':attribute (:input) sudah ada',
            'max'           => ':attribute maximal :max karakter',
            'exists'        => ':attribute (:input) tidak ditemukan',
            'numeric'       => ':attribute harus angka',
            'digits_between'=> ':attribute maximal :max digit minimal :min digit'
        ];
    }

    public function GetMemberList(Request $request)
    {
        $startDate = $request->start_date ? Carbon::parse($request->start_date) : Carbon::today();
        $endDate = $request->end_date ? Carbon::parse($request->end_date)->addDay() : Carbon::today()->addDay();

        $memberList = DB::table('request_log_daily_monitorings')
                ->leftJoin('request_logs', 'request_log_daily_monitorings.request_log_id', '=', 'request_logs.id')
                ->leftJoin('members', 'request_logs.member_id', '=', 'members.id')
                ->leftJoin('organizations', 'organizations.id', '=', 'request_logs.organization_id')
                ->select(
                    'members.member_id',
                    'members.name',
                    'members.birth_date',
                    'request_logs.type_of_member as member_type',
                    'members.members_effective_date AS startdate',
                    'members.members_expire_date AS enddate',
                    'request_logs.submission_date as addmision_date',
                    'organizations.name as provider',
                    'request_logs.organization_id',
                    'request_logs.code',
                    // Using a subquery to fetch medical_plan
                    DB::raw('(SELECT plan FROM request_log_medical_plan rdm WHERE rdm.request_log_daily_monitoring_id = request_log_daily_monitorings.id AND type = 1 LIMIT 1) as medical_plan'),
                    DB::raw('(SELECT plan FROM request_log_medical_plan rdm WHERE rdm.request_log_daily_monitoring_id = request_log_daily_monitorings.id AND type = 2 LIMIT 1) as non_medical_plan'),
                    'request_log_daily_monitorings.*'
                )
                ->whereNull('request_logs.deleted_at')  // Use whereNull() for checking NULL
                ->when($request->search, function ($q, $search) {
                    $q->where(function ($subQ) use ($search) {
                        $subQ->where('members.member_id', 'LIKE', "%{$search}%");
                        $subQ->orWhere('members.name', 'LIKE', "%{$search}%");
                    });
                })
                ->when($startDate, function ($q) use ($startDate) {
                    $q->where('request_log_daily_monitorings.submission_date', '>=', $startDate);
                })
                ->when($endDate, function ($q) use ($endDate) {
                    $q->where('request_log_daily_monitorings.submission_date', '<=', Carbon::parse($endDate)->addDay());
                })
                ->orderBy('request_logs.created_at', 'desc')
                ->paginate();
        return Helper::paginateResources(DailyMonitoringResource::collection($memberList));
    }

    /**
     * Claim List - by member id
     */
    public function GetClaimList(Request $request, $member_id)
    {
        $memberDetail = DB::table('members')
            ->select('id','member_id','name')
            ->where('member_id', $member_id)
            ->first();

        $claimList = DB::table('request_logs')
            ->leftJoin('services', 'services.code', '=', 'request_logs.service_code')
            ->leftJoin('members', 'members.id', '=', 'request_logs.member_id')
            ->select('request_logs.id','request_logs.submission_date AS admission_date','request_logs.discharge_date','request_logs.code','services.name as service_name','request_logs.status','members.name', 'members.member_id')
            ->where('request_logs.service_code', 'IP')
            ->where('request_logs.deleted_at', null)
            // ->where('request_logs.status_final_log', 'approved')
            ->where("request_logs.member_id", "=", $memberDetail->id)
            ->where("request_logs.organization_id", "=", $request->organization_id)
            ->when($request->search, function ($q, $search) {
                $q->where('request_logs.code', 'LIKE', "%".$search."%");
            })
            ->orderBy("request_logs.created_at", "desc")
            // ->get()
            ->paginate();

        return response()->json([
            'error'   => false,
            'message' => "success",
            'data'    => [
                'member_detail'=> $memberDetail,
                'claim_list'   => $claimList,
            ]
        ],200);
    }

    /**
     * Detail Monitoring List - by claim_code
     */
    public function GetDetailMonitoringList(Request $request, $request_code)
    {
        // get id request log
        $request_logs = DB::table('request_logs')
            ->select('id','organization_id')
            ->where('code', $request_code)
            ->first();

        $detail_list = RequestDailyMonitoring::where('request_log_id', empty($request_logs) == false ? $request_logs->id : '')
                            ->orderBy("submission_date", "desc")
                            ->get();

        return response()->json([
            'error'   => false,
            'message' => "success",
            'data'    => [
                'detail_list'=> $detail_list,
                'organization_id' => $request_logs ? $request_logs->organization_id : 0
            ]
        ],200);
    }

    public function GetDetailMonitoringListbyID(Request $request, $id)
    {

        $detail = RequestDailyMonitoring::where('id', $id)
                    ->orderBy("created_at", "desc")
                    ->first();
    
        if ($detail) {
            // Ubah menjadi array agar bisa dimodifikasi
            $detailArray = $detail->toArray();
        
            // Ubah nama key dari request_log_id menjadi log_id
            $detailArray['log_code'] = $detailArray['request_log_id'];
            unset($detailArray['request_log_id']);
        } else {
            $detailArray = null;
        }
        
        return response()->json([
            'error'   => false,
            'message' => "success",
            'data'    => $detailArray,
        ], 200);
    
    }

    public function UpdateDetailMonitoringbyID(Request $request)
    {
        // validation rule
        $validator = Validator::make($request->all(),[
            'log_code'           => 'required',
            'reason'            => 'required',
        ],$this->messages());

        // validation error
        if ($validator->fails()) {
            return response()->json([
                'error'   => true,
                'message' => $validator->getMessageBag()
            ],400);
        }
        try {
            // insert claim daily monitoring
            $db_response = RequestDailyMonitoring::where('id', $request->id)
                            ->update([
                                'request_log_id'    => $request->log_code,
                                'submission_date'   => $request->submission_date,
                                'subject'           => $request->subject,
                                'object'            => $request->objective,
                                'sistole'           => $request->sistole,
                                'diastole'          => $request->diastole,
                                'body_temperature'  => $request->body_temperature,
                                'respiration_rate'  => $request->respiration_rate,
                                'analysis'          => $request->analysis,
                                'lab_date'          => $request->lab_date,
                                'provider'          => $request->provider,
                                'examination'       => $request->examination,
                                'doctor_1'          => $request->doctor_1,
                                'doctor_2'          => $request->doctor_2,
                                'temp_diagnosis'    => $request->temp_diagnosis,
                                'final_diagnosis'   => $request->final_diagnosis,
                                'approval_pendamping'  => $request->approval_pendamping,
                                'description'        => $request->keterangan,
                                'note'              => $request->catatan,
                                'reason'            => $request->reason,
                                'created_by'        => auth()->user()->id,
                            ]);

            // cek medical plan
            $num_medical_plan = 0;
            foreach ($request->medical_plan as $row) {
                if ($row['medical_plan_str']) {
                    $num_medical_plan++;
                }
            }

            if ($num_medical_plan == 0) {
                DB::rollBack();
                return response()->json([
                    'error'   => true,
                    'message' => [
                        'medical_plan' => ['medical plan harus diisi']
                    ],
                    'data'    => []
                ],400);
            }
            if ($request->medical_plan){
                // delete medical plan
                DB::table('request_log_medical_plan')
                ->where([
                    'request_log_daily_monitoring_id' => $request->id,
                    'type' => 1
                ])
                ->delete();
                // insert medical plan
                foreach ($request->medical_plan as $row) {
                    DB::table('request_log_medical_plan')->insert([
                        'request_log_daily_monitoring_id' => $request->id,
                        'plan' => $row['medical_plan_str'],
                        'type' => 1,
                        'created_at' => date('Y-m-d'),
                    ]);
                }
            }

            if ($request->non_medikamentosa_plan){
                // delete medical plan
                DB::table('request_log_medical_plan')
                    ->where([
                        'request_log_daily_monitoring_id' => $request->id,
                        'type' => 2
                    ])
                    ->delete();
                // insert non medical plan
                foreach ($request->non_medikamentosa_plan as $row) {
                    DB::table('request_log_medical_plan')->insert([
                        'request_log_daily_monitoring_id' => $request->id,
                        'plan' => $row['non_medikamentosa_plan_str'],
                        'type' => 2,
                        'created_at' => date('Y-m-d'),
                    ]);
                }
            }           

            // insert file result
            if ($request->confirmation_medical_leter){
                // $fileCurrents = File::where([
                //     'fileable_id' => $request->id, 
                //     'type'        => 'confirmation-medical-letter',
                // ])->get();
                // if ($fileCurrents){
                //     foreach($fileCurrents as $fileCurrent){
                //         if (Files::exists($fileCurrent->path)) {
                //             Files::delete();
                //         }
                //         File::find($fileCurrent->id)->delete();
                //     }
                // }
                foreach ($request->confirmation_medical_leter as $file) {
                    $fileData = File::storeFile('confirmation-medical-letter', $request->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $request->id,
                        'type'          => 'confirmation-medical-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                        'extension'     => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by' => auth()->user()->id,
                        'updated_by' => auth()->user()->id,
                    ]);

                }
            }
            if ($request->medical_action_letter){
                // $fileCurrents = File::where([
                //     'fileable_id' => $request->id, 
                //     'type'        => 'medical-action-letter',
                // ])->get();
                // if ($fileCurrents){
                //     foreach($fileCurrents as $fileCurrent){
                //         if (Files::exists($fileCurrent->path)) {
                //             Files::delete();
                //         }
                //         File::find($fileCurrent->id)->delete();
                //     }
                // }
                foreach ($request->medical_action_letter as $file) {
                    $fileData = File::storeFile('confirmation-medical-letter', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $request->id,
                        'type'          => 'confirmation-medical-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                         'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);
                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }
            if ($request->result){
                // $fileCurrents = File::where([
                //     'fileable_id' => $request->id, 
                //     'type'        => 'laboratorium-result',
                // ])->get();
                // if ($fileCurrents){
                //     foreach($fileCurrents as $fileCurrent){
                //         if (Files::exists($fileCurrent->path)) {
                //             Files::delete();
                //         }
                //         File::find($fileCurrent->id)->delete();
                //     }
                // }
                foreach ($request->result as $file) {
                    $fileData = File::storeFile('laboratorium-result', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $request->id,
                        'type'          => 'laboratorium-result',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                         'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }
            DB::commit();

            return response()->json([
                'error'   => false,
                'message' => "success",
                'data'    => []
            ],200);
        }
        catch (Exception $e) {
            DB::rollBack();
            return response()->json([
                'error'   => true,
                'message' => $e->getMessage(),
                'data'    => []
            ],500);
        }
    }

    /**
     * Add Detail Monitoring List
     */
    public function AddDetailMonitoringList(Request $request, $claim_code)
    {
        $request->merge(['claim_code' => $claim_code]);

        // validation rule
        $validator = Validator::make($request->all(),[
            'claim_code'        => 'required|exists:claim_requests,code',
            'subject'           => 'required',
            'sistole'           => 'required|numeric',
            'diastole'          => 'required|numeric',
            'body_temperature'  => 'required|numeric',
            'respiration_rate'  => 'required|numeric',
            'analysis'          => 'required',
            'complaints'        => 'required',
            'medical_plan'      => 'required',
        ],$this->messages());

        // validation error
        if ($validator->fails()) {
            return response()->json([
                'error'   => true,
                'message' => $validator->getMessageBag()
            ],400);
        }

        // get claim request
        $claim_request = DB::table('claim_requests')
            ->select('id')
            ->where('code', $claim_code)
            ->first();

        // get claim
        $claim = DB::table('claims')
            ->select('id')
            ->where('claim_request_id', $claim_request->id)
            ->first();
        DB::beginTransaction();
        try {
            // insert claim daily monitoring
            $db_response = DailyMonitoring::create([
                'claim_id'          => $claim->id,
                'subject'           => $request->subject,
                'objective'         => $request->objective,
                'sistole'           => $request->sistole,
                'diastole'          => $request->diastole,
                'body_temperature'  => $request->body_temperature,
                'respiration_rate'  => $request->respiration_rate,
                'analysis'          => $request->analysis,
                'complaints'        => $request->complaints,
            ]);


            // cek medical plan
            $num_medical_plan = 0;

            foreach ($request->medical_plan as $row) {
                if ($row['medical_plan_str']) {
                    $num_medical_plan++;
                }
            }

            if ($num_medical_plan == 0) {
                DB::rollBack();

                return response()->json([
                    'error'   => true,
                    'message' => [
                        'medical_plan' => ['medical plan harus diisi']
                    ],
                    'data'    => []
                ],400);
            }

            // insert medical plan
            foreach ($request->medical_plan as $row) {
                MedicalPlan::create([
                    'claim_daily_monitoring_id' => $db_response->id,
                    'plan'                      => $row['medical_plan_str'],
                ]);
            }

            DB::commit();

            return response()->json([
                'error'   => false,
                'message' => "success",
                'data'    => []
            ],200);
        }
        catch (Exception $e) {
            DB::rollBack();
            return response()->json([
                'error'   => true,
                'message' => $e->getMessage(),
                'data'    => []
            ],500);
        }
    }

    /**
     * Add Detail Request LOG LIST
     */
    public function AddDetailMonitoringListRequestLog(Request $request, $request_code)
    {
        $request->merge(['request_code' => $request_code]);

        // validation rule
        $validator = Validator::make($request->all(),[
            'request_code'      => 'required|exists:request_logs,code',
            'subject'           => 'required',
            'submission_date'   => 'required',
            'body_temperature'  => 'required',
            'sistole'           => 'required',
            'diastole'          => 'required',
            'respiration_rate'  => 'required',
            'analysis'          => 'required',
            'medical_plan'      => 'required',
            'non_medikamentosa_plan' => 'required',
        ],$this->messages());

        // validation error
        if ($validator->fails()) {
            return response()->json([
                'error'   => true,
                'message' => $validator->getMessageBag()
            ],400);
        }

        // get claim request
        $request_log = DB::table('request_logs')
            ->select('id')
            ->where('code', $request_code)
            ->first();
        DB::beginTransaction();
        try {
            // insert claim daily monitoring
            $db_response = RequestDailyMonitoring::create([
                'request_log_id'    => $request_log->id,
                'submission_date'   => $request->submission_date,
                'subject'           => $request->subject,
                'object'            => $request->objective,
                'sistole'           => $request->sistole,
                'diastole'          => $request->diastole,
                'body_temperature'  => $request->body_temperature,
                'respiration_rate'  => $request->respiration_rate,
                'analysis'          => $request->analysis,
                'lab_date'          => $request->lab_date,
                'provider'          => $request->provider,
                'examination'       => $request->examination,
                'created_by'        => auth()->user()->id,
            ]);


            // cek medical plan
            $num_medical_plan = 0;
            foreach ($request->medical_plan as $row) {
                if ($row['medical_plan_str']) {
                    $num_medical_plan++;
                }
            }

            if ($num_medical_plan == 0) {
                DB::rollBack();
                return response()->json([
                    'error'   => true,
                    'message' => [
                        'medical_plan' => ['medical plan harus diisi']
                    ],
                    'data'    => []
                ],400);
            }

            // insert medical plan
            foreach ($request->medical_plan as $row) {
                DB::table('request_log_medical_plan')->insert([
                    'request_log_daily_monitoring_id' => $db_response->id,
                    'plan' => $row['medical_plan_str'],
                    'type' => 1,
                    'created_at' => date('Y-m-d'),
                ]);
            }

            // insert non medical plan
            foreach ($request->non_medikamentosa_plan as $row) {
                DB::table('request_log_medical_plan')->insert([
                    'request_log_daily_monitoring_id' => $db_response->id,
                    'plan' => $row['non_medikamentosa_plan_str'],
                    'type' => 2,
                    'created_at' => date('Y-m-d'),
                ]);
            }

            // insert file result
            if ($request->confirmation_medical_leter){
                foreach ($request->confirmation_medical_leter as $file) {
                    $fileData = File::storeFile('confirmation-medical-letter', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'confirmation-medical-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                        'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                }
            }
            if ($request->medical_action_letter){
                foreach ($request->medical_action_letter as $file) {
                    $fileData = File::storeFile('medical-action-letter', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'medical-action-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                         'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }
            if ($request->result){
                foreach ($request->result as $file) {
                    $fileData = File::storeFile('laboratorium-result', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'laboratorium-result',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                        'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }


            DB::commit();

            return response()->json([
                'error'   => false,
                'message' => "success",
                'data'    => []
            ],200);
        }
        catch (Exception $e) {
            DB::rollBack();
            return response()->json([
                'error'   => true,
                'message' => $e->getMessage(),
                'data'    => []
            ],500);
        }
    }

    public function AddListRequestLog(Request $request)
    {
        // validation rule
        $validator = Validator::make($request->all(),[
            'log_code'      => 'required|exists:request_logs,id',
            'subject'           => 'required',
            'submission_date'   => 'required',
            'body_temperature'  => 'required',
            'sistole'           => 'required',
            'diastole'          => 'required',
            'respiration_rate'  => 'required',
            'analysis'          => 'required',
            'medical_plan'      => 'required',
            'non_medikamentosa_plan' => 'required',
        ],$this->messages());

        // validation error
        if ($validator->fails()) {
            return response()->json([
                'error'   => true,
                'message' => $validator->getMessageBag()
            ],400);
        }

        // get claim request
        $request_log = DB::table('request_logs')
            ->select('id')
            ->where('id', $request->log_code)
            ->first();
        DB::beginTransaction();
        try {
            // insert claim daily monitoring
            $db_response = RequestDailyMonitoring::create([
                'request_log_id'    => $request->log_code,
                'submission_date'   => $request->submission_date,
                'doctor_1'          => $request->doctor_1,
                'doctor_2'          => $request->doctor_2,
                'temp_diagnosis'    => $request->temp_diagnosis,
                'final_diagnosis'   => $request->final_diagnosis,
                'approval_pendamping'  => $request->approval_pendamping,
                'description'        => $request->keterangan,
                'note'              => $request->catatan,
                'subject'           => $request->subject,
                'object'            => $request->objective,
                'sistole'           => $request->sistole,
                'diastole'          => $request->diastole,
                'body_temperature'  => $request->body_temperature,
                'respiration_rate'  => $request->respiration_rate,
                'analysis'          => $request->analysis,
                'lab_date'          => $request->lab_date,
                'provider'          => $request->provider,
                'examination'       => $request->examination,
                'created_by'        => auth()->user()->id,
            ]);


            // cek medical plan
            $num_medical_plan = 0;
            foreach ($request->medical_plan as $row) {
                if ($row['medical_plan_str']) {
                    $num_medical_plan++;
                }
            }

            if ($num_medical_plan == 0) {
                DB::rollBack();
                return response()->json([
                    'error'   => true,
                    'message' => [
                        'medical_plan' => ['medical plan harus diisi']
                    ],
                    'data'    => []
                ],400);
            }

            // insert medical plan
            foreach ($request->medical_plan as $row) {
                DB::table('request_log_medical_plan')->insert([
                    'request_log_daily_monitoring_id' => $db_response->id,
                    'plan' => $row['medical_plan_str'],
                    'type' => 1,
                    'created_at' => date('Y-m-d'),
                ]);
            }

            // insert non medical plan
            foreach ($request->non_medikamentosa_plan as $row) {
                DB::table('request_log_medical_plan')->insert([
                    'request_log_daily_monitoring_id' => $db_response->id,
                    'plan' => $row['non_medikamentosa_plan_str'],
                    'type' => 2,
                    'created_at' => date('Y-m-d'),
                ]);
            }

            // insert file result
            if ($request->confirmation_medical_leter){
                foreach ($request->confirmation_medical_leter as $file) {
                    $fileData = File::storeFile('confirmation-medical-letter', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'confirmation-medical-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                         'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                }
            }
            if ($request->medical_action_letter){
                foreach ($request->medical_action_letter as $file) {
                    $fileData = File::storeFile('medical-action-letter', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'medical-action-letter',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                         'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }
            if ($request->result){
                foreach ($request->result as $file) {
                    $fileData = File::storeFile('laboratorium-result', $db_response->id, $file);
                    File::create([
                        'fileable_type' => 'App\Models\LaboratoriumResult',
                        'fileable_id'   => $db_response->id,
                        'type'          => 'laboratorium-result',
                        'name'          => $fileData['name'],
                        'original_name' => $file->getClientOriginalName(),
                        'extension' => $file->getClientOriginalExtension(),
                        'source'        => env('FILESYSTEM_DISK'),
                        'path'          => $fileData['path'],
                        'created_by'    => auth()->user()->id,
                        'updated_by'    => auth()->user()->id,
                    ]);

                    // $file->storeAs($this->path_for_store, $fileName);
                }
            }


            DB::commit();

            return response()->json([
                'error'   => false,
                'message' => "success",
                'data'    => []
            ],200);
        }
        catch (Exception $e) {
            DB::rollBack();
            return response()->json([
                'error'   => true,
                'message' => $e->getMessage(),
                'data'    => []
            ],500);
        }
    }

    /**
     * Delete Listing Daily Monitoring
     */
    public function deleteDetailMonitoringListRequestLog(Request $request, $id)
    {
        $listDailyMonitoring = RequestDailyMonitoring::find($id);
        $listDailyMonitoring->reason = $request->reason;
        $listDailyMonitoring->save();
        
        if (!$listDailyMonitoring) {
            return response()->json([
                'error'   => true,
                'message' => "Data not found.",
            ], 404);
        }
        
        $listDailyMonitoring->delete();
        
        return response()->json([
            'error'   => false,
            'message' => "Delete success",
            'data'    => $listDailyMonitoring
        ], 200);
    }

    /**
     * Delete File Daily Monitoring
     */
    public function deleteFileDetailMonitoringListRequestLog(Request $request, $id){
        $fileCurrent = File::where([
                    'id' => $id, 
                ])->first();
        if ($fileCurrent){
            if (Files::exists($fileCurrent->path)) {
                Files::delete();
            }
            $fileCurrent->deleted_at = now();
            $fileCurrent->reason = $request->reason;
            $fileCurrent->deleted_by = auth()->user()->id;
            $fileCurrent->save();
            
            return response()->json([
                'error'   => false,
                'message' => "Delete success",
                'data'    => $fileCurrent
            ], 200);
        } else {
            return response()->json([
                'error'   => true,
                'message' => "Data not found.",
            ], 404);
        }
    }

    /**
     * Update Status Request LOG
     */
    public function UpdateListRequestLog(Request $request, $request_code)
    {
        // get claim request
        $request_log = DB::table('request_logs')
                ->where('code', $request_code)
                ->update([
                    'discharge_date' => now(),
                    'updated_by' => auth()->user()->id,
                    'updated_at' => now()
                ]);
        if ($request_log) {
            return response()->json([
                'error'   => false,
                'message' => "success",
                'data'    => []
            ], 200);
        } else {
            return response()->json([
                'error'   => true,
                'message' => $e->getMessage(),
                'data'    => []
            ],500);
        }
    }
}