<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\{Category,User,InsuranceDetail,Country,Appointment,InsuranceDocument,InsuranceClaimDetail,Diagnosis,ReferalDetails,InsuranceCompany,WebSetting,DependantAccountHolder};
use App\Http\Requests\InsuranceDetailsAddRequest;
use App\Http\Requests\InsuranceAppointmentListRequest;
use App\Http\Requests\InsuranceClaimDetailsRequest;
use App\Http\Requests\AppointmentDetailRequest;
use App\Http\Resources\AppointmentCollection;
use App\Http\Resources\AppointmentResource;
use Auth;
use Config;
use Storage;
use Carbon\Carbon;
use DB;
use DateTime;
use PDF;

use Illuminate\Database\QueryException;
use Throwable;
use Exception;
use App\Library\S3Library;
use App\Enums\AppoitmentStatusEnum;

class InsuranceController extends Controller
{
    public function addInsuranceDetail(InsuranceDetailsAddRequest $request)
    {
        try {
            $validated = $request->validated();
            /** @var \App\User $authRole */
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            DB::beginTransaction();
            $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
            // $result = $subscriptionLibrary->status($auth_id);
            $result = $subscriptionLibrary->newStatus($auth_id);
            $response = $subscriptionLibrary->list();
          
            if($result['plan'] == 'free') {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.upgrade_plan_to_avail_this'));
            }
            else if($result['status'] != '1' || (Carbon::now()->format('Y-m-d') > Carbon::parse($result['end_period'])->format('Y-m-d'))) {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.subscription_plan_expired'));
            }
            if(!empty($request->country_code))
            {
                $country = Country::where('phone_code', $request->country_code)->first();
                if(!$country)
                    return self::sentResponse(401, [], __('digimed_validation.error_response.country_code_not_valid'));
            }

            if(!empty($request->country_id))
            {
                $country = Country::where('id', $request->country_id)->first();
                if(!$country)
                    return self::sentResponse(401, [], __('digimed_validation.form_validation_error.country_id_invalid'));
            }

            $insuranceDetail = InsuranceDetail::firstOrNew(['user_id' => $auth_id]);

            $data_cover_from = $request->cover_from;
            $data_cover_to = $request->cover_to;
            $data_dob = $request->dob;
            /**
             * @var string $data_cover_from
             * @var string $data_cover_to
             * @var string $data_dob
             */

            $insuranceDetail->insurance_company_id = $request->insurance_company_id;
            $insuranceDetail->policy_number = $request->policy_number;
            $insuranceDetail->company_name = $request->company_name;
            $insuranceDetail->cover_from = date('Y-m-d', strtotime($data_cover_from));
            $insuranceDetail->cover_to = date('Y-m-d', strtotime($data_cover_to));
            $insuranceDetail->insurance_type = $request->insurance_type;

            if($request->insurance_type == 'dependent') {
                $insuranceDetail->first_name = $request->first_name;
                $insuranceDetail->last_name = $request->last_name;
                $insuranceDetail->passport_number = $request->passport_number;
                $insuranceDetail->dob = date('Y-m-d', strtotime($data_dob));
                $insuranceDetail->country_code = $request->country_code;
                $insuranceDetail->mobile_number = $request->mobile_number;
                $insuranceDetail->email = $request->email;
                $insuranceDetail->country_id = $request->country_id;
                $insuranceDetail->post_code = $request->post_code;
                $insuranceDetail->address = $request->address;
            }

            $insuranceDetail->beneficiary_name = $request->beneficiary_name;
            $insuranceDetail->iban = $request->iban;
            $insuranceDetail->bic = $request->bic;
            $insuranceDetail->created_by = $auth_id;
            $insuranceDetail->updated_by = $auth_id;
            $insuranceDetail->save();

            DB::commit();
            return self::sentResponse(200, [], __('digimed_validation.success_response.insurance_details_stored_success'));
        } catch(Exception | Throwable | QueryException $e) {
            DB::rollback();
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function getInsuranceDetail(Request $request)
    {
        try {
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $data = InsuranceDetail::where('user_id',$auth_id)->first();
            return self::sentResponse(200, $data, __('digimed_validation.success_response.insurance_details_fetch_success'));
        } catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500,[], $e->getMessage());
        }
    }

    public function index(Request $request)
    {
        try {
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $data = InsuranceCompany::get();
            return self::sentResponse(200, $data, __('digimed_validation.success_response.insurance_company_list_success'));
        } catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500,[], $e->getMessage());
        }
    }

    public function appointmentList(InsuranceAppointmentListRequest $request)
    {
        try {
            $validated = $request->validated();
            $paginate = $request->count_per_page ? $request->count_per_page : 10;
            /** @var int|null $paginate */
            $orderBy = $request->order_by ? $request->order_by : 'desc';
            $pageNumber = $request->page ? $request->page : 1;
            $sort_by = $request->sort_by;

            /** @var \App\User $authRole */
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
            // $result = $subscriptionLibrary->status($auth_id);
            $result = $subscriptionLibrary->newStatus($auth_id);
           
            $response = $subscriptionLibrary->list();
           
        
            if($result['plan'] == 'free') {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.upgrade_plan_to_avail_this'));
            }
            else if($result['status'] != '1' || (Carbon::now()->format('Y-m-d') > Carbon::parse($result['end_period'])->format('Y-m-d'))) {
               
                return self::sentResponse(401, $response, __('digimed_validation.error_response.subscription_plan_expired'));
            }
           
            $dependantArr = [$auth_id];
            $dependantQ = DependantAccountHolder::where('user_id', $auth_id)->where('status', 1)->get();
            for ($i=0; $i < count($dependantQ); $i++) {
                array_push($dependantArr, $dependantQ[$i]->dependant_id);
            }
            $list = Appointment::whereIn('patient_id',$dependantArr)->doesntHave('insuranceClaimDetails');
            $list = $list->where('appointment_status', AppoitmentStatusEnum::COMPLETED());
            // $list = $list->where('consultation_end_time', '!=', NULL);
            /**
             * @var string $sort_by
             * @var string $orderBy
             */

            $list = $list->orderBy($sort_by,$orderBy);
            return new AppointmentCollection($list->paginate($paginate), 200);
        } catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function InsuranceClaimForm(InsuranceClaimDetailsRequest $request, S3Library $S3Library)
    {
        try {
            $validated = $request->validated();
            /** @var \App\User $authRole */
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
            // $result = $subscriptionLibrary->status($auth_id);
            $result = $subscriptionLibrary->newStatus($auth_id);
            
            $response = $subscriptionLibrary->list();
            if($result['plan'] == 'free') {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.upgrade_plan_to_avail_this'));
            }
            else if($result['status'] != '1' || (Carbon::now()->format('Y-m-d') > Carbon::parse($result['end_period'])->format('Y-m-d'))) {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.subscription_plan_expired'));
            }
            DB::beginTransaction();
            $insuranceClaimDetail = InsuranceClaimDetail::firstOrNew(['appointment_id' => $request->appointment_id]);
            $insuranceClaimDetail->aditional_information = $request->aditional_information;

            $data_first_visit_date = $request->first_visit_date;
            /** @var string $data_first_visit_date */

            $insuranceClaimDetail->first_visit_date = date('Y-m-d', strtotime($data_first_visit_date));
            $insuranceClaimDetail->is_caused_by_third_party = $request->is_caused_by_third_party;     //yes,no
            $insuranceClaimDetail->details_caused_by_third_party = $request->details_caused_by_third_party;
            $insuranceClaimDetail->is_another_policy = $request->is_another_policy;    //yes,no
            $insuranceClaimDetail->details_of_another_policy = $request->details_of_another_policy;
            $insuranceClaimDetail->created_by = $auth_id;
            $insuranceClaimDetail->updated_by = $auth_id;
            $insuranceClaimDetail->save();
            $lastInsertId = $insuranceClaimDetail->id;
            //multiple
            $files = $request->attachments;
            if(!empty($files))
            {
                /** @var array|null $files */
                $exists = InsuranceDocument::where("claim_details_id",$lastInsertId)->delete();
                for ($i=0; $i < count($files); $i++) {
                    /** @var array $files */
                    $description = $files[$i]['description'];
                    $amount = $files[$i]['amount'];
                    $file = $files[$i]['file'];

                    $fileName = NULL;
                    if (!empty($file)) {

                        if($S3Library->is_base64($file)) {  //Base 64

                            $digimedFile = $S3Library->base64($file, $request->appointment_id, ['image','application'], 'digimed/images/insurance-documents/'.$request->appointment_id.'/');
                            if($digimedFile['code'] == 200) {
                                $fileName = $digimedFile['data'];
                            }

                        } else {
                            DB::rollback();
                            return self::sentResponse(500, [], __('digimed_validation.error_response.file_upload_faild_try'));
                        }
                    }
                    InsuranceDocument::create([
                        'appointment_id' => $request->appointment_id,
                        'claim_details_id' => $lastInsertId,
                        'amount' => $amount,
                        'attachment' => $fileName,
                        'description' => $description,
                        'created_by' => $auth_id,
                        'updated_by' => $auth_id,
                    ]);
                }
            }

            $appointment_id = $request->appointment_id;
            $appointment = Appointment::with(['patientDetails','doctorDetails','insuranceClaimDetails','appointmentHealthRecord','appointmentReason','appointmentSymptoms'])->find($appointment_id);

            $patient_id = $appointment->patientDetails->id;
            $IfDependantQuery = User::with('roles')->find($patient_id);
            $roleGet = $IfDependantQuery->roles->pluck('name');
            if($roleGet[0] == "dependant") {
                $DependantAccountHolder = DependantAccountHolder::with('user')->where('dependant_id', $IfDependantQuery->id)->first();
                $main_user_id = $DependantAccountHolder['user']['id'];
            } else {
                $main_user_id = $appointment->patientDetails->id;
            }
            $insuranceDetail = InsuranceDetail::where('user_id',$main_user_id)->first();

            if(Config::get('filesystems.default') == "s3") {
                $logo_image = Storage::temporaryUrl('digimed/images/assets/img/logo.svg', now()->addMinutes(30));
            } else {
                $logo_image = Storage::disk('public')->url('images/logo.png');
            }

            if(Config::get('filesystems.default') == "s3") {
                $doctor_signature = Storage::temporaryUrl('digimed/images/user_signature/'.$appointment->doctor_id.'/'.$appointment->doctorDetails->signature, now()->addMinutes(30));
            } else {
                $doctor_signature = Storage::url('app/public/images/user_signature/'.$appointment->doctor_id.'/'.$appointment->doctorDetails->signature);
            }

            if(Config::get('filesystems.default') == "s3") {
                $patient_image = $appointment->patientDetails->profile_image;
            } else {
                $patient_image = Storage::url('app/public/images/profile-images/'.$appointment->patientDetails->profile_image);
            }

            if(Config::get('filesystems.default') == "s3") {
                $doctor_image = $appointment->doctorDetails->profile_image;
            } else {
                $doctor_image = Storage::url('app/public/images/profile-images/'.$appointment->doctorDetails->profile_image);
            }

            $diagnosis = Diagnosis::where("appointment_id", $appointment_id)->first();
            $web_settings = WebSetting::find(1);
            $contact_email = $web_settings->contact_email;
            $website = $web_settings->website;

            $referal = ReferalDetails::where("appointment_id", $appointment_id)->first();
            $pdf = PDF::loadView('pdf.insurance_pdf', compact('logo_image','appointment','doctor_signature','patient_image','doctor_image','referal','diagnosis','contact_email','website','insuranceDetail'));

            if(Config::get('filesystems.default') == "s3") {
                Storage::disk('s3')->put('digimed/images/insurance/insurance_'.$appointment_id.'.pdf', $pdf->output());
                $finalLink = Storage::temporaryUrl('digimed/images/insurance/insurance_'.$appointment_id.'.pdf', now()->addMinutes(30));
            } else {
                Storage::put('insurance/insurance_'.$appointment_id.'.pdf', $pdf->output());
                $finalLink = Storage::url('insurance/insurance_'.$appointment_id.'.pdf');
            }

            $result = ['pdf_link' => $finalLink];

            DB::commit();
            return self::sentResponse(200, $result, __('digimed_validation.success_response.claim_form_submitted_success'));
        } catch(Exception | Throwable | QueryException $e) {
            DB::rollback();
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function insuranceClaimDetailView(AppointmentDetailRequest $request)
    {
        try {
            /** @var \App\User $authRole */
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
            $result = $subscriptionLibrary->newStatus($auth_id);
            $response = $subscriptionLibrary->list();
            if($result['plan'] == 'free') {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.upgrade_plan_to_avail_this'));
            }
            else if($result['status'] != '1' || (Carbon::now()->format('Y-m-d') > Carbon::parse($result['end_period'])->format('Y-m-d'))) {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.subscription_plan_expired'));
            }

            $appointment_id = $request->appointment_id;
            $appointment = Appointment::with(['patientDetails','doctorDetails','insuranceClaimDetails','appointmentHealthRecord','paymentDetails'])->find($appointment_id);
            $patient_id = $appointment->patientDetails->id;
            $IfDependantQuery = User::with('roles')->find($patient_id);
            $roleGet = $IfDependantQuery->roles->pluck('name');
            if($roleGet[0] == "dependant") {
                $DependantAccountHolder = DependantAccountHolder::with('user')->where('dependant_id', $IfDependantQuery->id)->first();
                $main_user_id = $DependantAccountHolder['user']['id'];
            } else {
                $main_user_id = $appointment->patientDetails->id;
            }
            $insuranceDetail = InsuranceDetail::where('user_id',$main_user_id)->first();
            $result = new AppointmentResource($appointment,$insuranceDetail);
            return self::sentResponse(200, $result, __('digimed_validation.success_response.data_fetch_success'));
        } catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function insuranceClaimDetailPdf(AppointmentDetailRequest $request)
    {
        try {
            /** @var \App\User $authRole */
            $authRole = Auth::user();
            $auth_id = auth()->user()->id;
            $plan = User::find($auth_id)->subscription_plan;
            $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
            // $result = $subscriptionLibrary->status($auth_id);
            $result = $subscriptionLibrary->newStatus($auth_id);
            $response = $subscriptionLibrary->list();
            if($result['plan'] == 'free') {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.upgrade_plan_to_avail_this'));
            }
            else if($result['status'] != '1' || (Carbon::now()->format('Y-m-d') > Carbon::parse($result['end_period'])->format('Y-m-d'))) {
                return self::sentResponse(401, $response, __('digimed_validation.error_response.subscription_plan_expired'));
            }

            $appointment_id = $request->appointment_id;
            $appointment = Appointment::with(['patientDetails','doctorDetails','insuranceClaimDetails','appointmentHealthRecord','appointmentReason','appointmentSymptoms'])->find($appointment_id);

            $patient_id = $appointment->patientDetails->id;
            $IfDependantQuery = User::with('roles')->find($patient_id);
            $roleGet = $IfDependantQuery->roles->pluck('name');
            if($roleGet[0] == "dependant") {
                $DependantAccountHolder = DependantAccountHolder::with('user')->where('dependant_id', $IfDependantQuery->id)->first();
                $main_user_id = $DependantAccountHolder['user']['id'];
            } else {
                $main_user_id = $appointment->patientDetails->id;
            }
            $insuranceDetail = InsuranceDetail::where('user_id',$main_user_id)->first();

            if(Config::get('filesystems.default') == "s3") {
                $logo_image = Storage::temporaryUrl('digimed/images/assets/img/logo.svg', now()->addMinutes(30));
            } else {
                $logo_image = Storage::disk('public')->url('images/logo.png');
            }

            if(Config::get('filesystems.default') == "s3") {
                $doctor_signature = Storage::temporaryUrl('digimed/images/user_signature/'.$appointment->doctor_id.'/'.$appointment->doctorDetails->signature, now()->addMinutes(30));
            } else {
                $doctor_signature = Storage::url('app/public/images/user_signature/'.$appointment->doctor_id.'/'.$appointment->doctorDetails->signature);
            }

            if(Config::get('filesystems.default') == "s3") {
                $patient_image = $appointment->patientDetails->profile_image;
            } else {
                $patient_image = Storage::url('app/public/images/profile-images/'.$appointment->patientDetails->profile_image);
            }

            if(Config::get('filesystems.default') == "s3") {
                $doctor_image = $appointment->doctorDetails->profile_image;
            } else {
                $doctor_image = Storage::url('app/public/images/profile-images/'.$appointment->doctorDetails->profile_image);
            }
            $diagnosis = Diagnosis::where("appointment_id", $appointment_id)->first();
            $web_settings = WebSetting::find(1);
            $contact_email = $web_settings->contact_email;
            $website = $web_settings->website;

            $referal = ReferalDetails::where("appointment_id", $appointment_id)->first();
            $pdf = PDF::loadView('pdf.insurance_pdf', compact('logo_image','appointment','doctor_signature','patient_image','doctor_image','referal','diagnosis','contact_email','website','insuranceDetail'));
            if(Config::get('filesystems.default') == "s3") {
                Storage::disk('s3')->put('digimed/images/insurance/insurance_'.$appointment_id.'.pdf', $pdf->output());
                $finalLink = Storage::temporaryUrl('digimed/images/insurance/insurance_'.$appointment_id.'.pdf', now()->addMinutes(30));
            } else {
                Storage::put('insurance/insurance_'.$appointment_id.'.pdf', $pdf->output());
                $finalLink = Storage::url('insurance/insurance_'.$appointment_id.'.pdf');
            }

            $result = ['pdf_link' => $finalLink];
            return self::sentResponse(200, $result, __('digimed_validation.success_response.pdf_generate_success'));
        } catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }
}