<?php

namespace App\Http\Controllers\Agent;

use App\Classes\Constant;
use App\Events\DeviceCurrentStatus;
use App\Http\Controllers\Controller;
use App\Models\Appointment;
use App\Models\Cart;
use App\Models\Doctor;
use App\Models\DoctorAppointment;
use App\Models\Item;
use App\Models\ItemHistory;
use App\Models\Lab;
use App\Models\LabKit;
use App\Models\LicenseNumberModel;
use App\Models\Patient;
use App\Models\PatientAnswer;
use App\Models\PatientLab;
use App\Models\PatientNote;
use App\Models\PatientPrescription;
use App\Models\PatientTask;
use App\Models\Prescription;
use App\Models\Question;
use App\Models\QuestionBuilder;
use App\Models\QuestionGroup;
use App\Models\Telemedpro;
use Carbon\Carbon;
use DateTime;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\File;
use App\Models\Setting;
use Illuminate\Support\Facades\Storage;
use Laravel\Prompts\Note;

class AppointmentController extends Controller
{
    public function index()
    {
        $user = Auth::user();
        $data = [];
        $appointments = Appointment::where('telemed_pros_id', $user->id)->get();
        foreach ($appointments as $appointment) {
            $patient = Patient::where('id', $appointment->patient_id)->first();
            array_push($data, [
                'id' => $appointment->id,
                'patient_name' => $patient->first_name . " " . $patient->last_name,
                'patient_id' => $appointment->patient_id,
                'telemed_pros_id ' => $appointment->telemed_pros_id,
                'appointment_time' => $appointment->appointment_time,
                'meeting_id' => $appointment->meeting_id,
                'created_at' => $appointment->created_at,
                'updated_at' => $appointment->updated_at,
                'in_call' => $appointment->in_call
            ]);
        }
        // dd($data);
        return  view('agent.appointments.index', ['appointments' => $data]);
    }

    public function profile(Request $request)
    {
        $user = Auth::user();
        return response()->json(['profile' => $user], 200);
    }
    public function profileImageUpload(Patient $patient, Request $request)
    {
        $user = $patient;
        $image = $request->get('image');
        $fileName = 'profile-' . time();

        $logo = base64_decode($image);
        $ext = (explode('/', finfo_buffer(finfo_open(), $logo, FILEINFO_MIME_TYPE))[1]);

        $imageName =  $fileName . '.' . $ext;
        Storage::disk('local')->put("public/profile_pictures/" . $imageName, $logo);
        $user->profile_picture = $imageName;
        $user->save();
        return response()->json(['profile' => $user], 200);
    }

    public function delete($id, Request $request)
    {
        Appointment::where('id', $id)->delete();
        $request->session()->flash('message', 'Appointment deleted successfully');
        return redirect()->back();
    }

    public function patientDetails($id)
    {
        $appointment = Appointment::where('id', $id)->first();
        $patient = Patient::where('id', $appointment->patient_id)->first();
        return  view('agent.appointments.patient-details', ['patient' => $patient, 'appointment_id' => $appointment->id]);
    }
    public function patientProfileDetails(Patient $patient)
    {
        return response()->json(['patient' => $patient], 200);
    }


    public function patientAddress($id)
    {
        $patient = Patient::where('id', $id)->first();
        return  view('agent.appointments.patient-address', ['patient' => $patient]);
    }

    public function savePatientAddress($id, Request $request)
    {
        $appointment = Appointment::where('id', $id)->first();
        $patient = Patient::where('id', $appointment->patient_id)->first();

        $address = $request->input('address');
        $city = $request->input('city');
        $state = $request->input('state');
        $zip_code = $request->input('zip_code');

        $patient->address = $address;
        $patient->city = $city;
        $patient->state = $state;
        $patient->zip_code = $zip_code;
        $patient->save();

        $request->session()->flash('message', 'Address saved successfully');


        return  view('agent.appointments.patient-details', ['patient' => $patient, 'appointment_id' => $appointment->id]);
    }

    public function patientLabs($id)
    {
        $patient = Patient::where('id', $id)->first();
        $labs = Lab::where('city', 'like', '%' . $patient->city . '%')
            ->orWhere('state', 'like', '%' . $patient->state . '%')
            ->orWhere('zip_code', 'like', '%' . $patient->zip_code . '%')
            ->get();
        return  view('agent.appointments.patient-labs', ['patient' => $patient, 'labs' => $labs]);
    }

    public function patientBookLab(Appointment $appointment, Request $request)
    {

        $lab = new Lab();
        $lab->address = $request->input('lab_address');
        $lab->name = $request->input('lab_name');
        $lab->city = $request->input('lab_city');
        $lab->state = $request->input('lab_state');
        $lab->distance = $request->input('lab_distance');
        $lab->contact_no = $request->input('lab_contact_no');
        $lab->lang = $request->input('lab_lang');
        $lab->lat = $request->input('lab_lat');

        $lab->slot_date = $request->input('slot_date');
        $lab->slot_time = $request->input('slot_time');
        $lab->booking_time = Carbon::now()->format('Y-m-d H:i:s');

        $lab->appointment_id = $appointment->id;
        $lab->save();

        return ['message' => 'Lab booked successfully'];
    }
    public function patientBookLabGet(Appointment $appointment)
    {
        $lab = Lab::where("appointment_id", $appointment->id)->first();
        return response()->json([
            'lab_name' => $lab->name,
            'lab_address' => $lab->address,
            'lab_city' => $lab->city,
            'lab_state' => $lab->state,
            'lab_distance' => $lab->distance,
            'lab_contact_no' => $lab->contact_no,
            'lab_lang' => $lab->lang,
            'lab_lat' => $lab->lat,
            'slot_date' => $lab->slot_date,
            'slot_time' => $lab->slot_time,
            'booking_time' => $lab->booking_time,
        ]);
    }

    public function doctorAppointment($id)
    {
        $appointment = Appointment::where('id', $id)->first();
        $patient = Patient::where('id', $appointment->patient_id)->first();
        $doctors = Doctor::all();
        return  view('agent.appointments.doctor-appointment', ['patient' => $patient, 'doctors' => $doctors, 'appointment' => $appointment]);
    }
    public function pendingAppointmentDetail()
    {

        $appointments = Appointment::whereNull('end_time')
            ->where(function ($query) {
                $startTimeM = Carbon::now()->subHours(12)->format('Y-m-d');
                $endTimeM = Carbon::now()->addHours(12)->format('Y-m-d');
                $startTime = Carbon::now()->subHours(12)->format('H:i:s');
                $endTime = Carbon::now()->addHours(12)->format('H:i:s');
                $query //->where('appointment_time', '>=', $startTime)
                    //->where('appointment_time', '<=', $endTime)
                    ->where('appointment_date', '>=', $startTimeM)
                    ->where('appointment_date', '<=', $endTimeM);
            })
            ->with('patient:id,first_name,last_name,address,city,state,zip_code,country')
            ->get([
                'id',
                'patient_id',
                'appointment_time',
                'appointment_date',
                'start_time',
                'end_time',
                'duration',
                'timezone'
            ])
            ->groupBy('patient_id', 'appointment_time', 'appointment_date', 'start_time')
            ->map(function ($group) {
                $patient = $group->first()->patient;
                $appointments = $group->sortByDesc('id');
                $array = [];
                foreach ($appointments as $appointment) {
                    $filePath = public_path("assets/profiles/{$patient->id}.png");

                    if (File::exists($filePath)) {
                        $patient->url = "/assets/profiles/{$patient->id}.png";
                    } else {
                        $patient->url = null;
                    }
                    $cart = Cart::where("appointment_id", $appointment->id)->first();
                    $array[] = [
                        'id' => $patient->id,
                        'patient_timezone' => $patient->timezone,
                        'appointment_timezone' => $appointment->timezone,
                        'name' => $patient->first_name . ' ' . $patient->last_name,
                        'address' => $patient->address,
                        'city' => $patient->city,
                        'state' => $patient->state,
                        'zip_code' => $patient->zip_code,
                        'url' => $patient->url,
                        'country' => $patient->country,
                        'time' => time(),
                        'order_id' => $cart->id ?? "",
                        'appointment' => [
                            'id' => $appointment->id,
                            'appointment_time' => $appointment->appointment_time,
                            'appointment_date' => $appointment->appointment_date,
                            'start_time' => $appointment->start_time,
                            'end_time' => $appointment->end_time,
                            'duration' => $appointment->duration,
                            'timezone' => $appointment->timezone

                        ]
                    ];
                }
                return $array;
            })->flatten(1);

        return response()->json($appointments, 200);
    }


    public function doctorAppointmentSave($id, Request $request)
    {
        $appointment_date = $request->input('appointment_date');
        $appointment_time = $request->input('appointment_time');
        $appointment_date = new DateTime($appointment_date);
        $appointment_date = $appointment_date->format('Y-m-d');
        $doctor_id = $request->input('doctor_id');

        $appointment = Appointment::where('id', $id)->first();

        $doctorAppointment = DoctorAppointment::where('patient_id', $appointment->patient_id)
            ->where('doctor_id', $doctor_id)
            ->where('appointment_id', $id)
            ->where('appointment_date', $appointment_date)
            ->where('appointment_time', $appointment_time)
            ->first();

        if (empty($doctorAppointment)) {
            DoctorAppointment::create([
                'patient_id' => $appointment->patient_id,
                'doctor_id' => $doctor_id,
                'appointment_id' => $id,
                'appointment_date' => $appointment_date,
                'appointment_time' => $appointment_time
            ]);


            return response()->json(['message' => 'Doctor appointment booked'], 200);
        } else {
            return response()->json(['message' => 'Error in booking Appointment!'], 200);
        }
        return redirect()->back();
    }

    public function patientTasks($id)
    {
        $appointment = Appointment::where('id', $id)->first();
        $patient = Patient::where('id', $appointment->patient_id)->first();
        $patientTasks = PatientTask::where('patient_id', $appointment->patient_id)->get();
        return  view('agent.appointments.patient-tasks', ['patient' => $patient, 'appointment' => $appointment, 'patientTasks' => $patientTasks]);
    }

    public function patientTasksSave($id, Request $request)
    {
        $description = $request->input('description');

        PatientTask::create([
            'patient_id' => $id,
            'description' => $description,
        ]);

        $request->session()->flash('message', 'Task saved successfully');
        return redirect()->back();
    }

    public function patientTaskDelete($id, Request $request)
    {
        PatientTask::where('id', $id)->delete();
        $request->session()->flash('message', 'Task deleted successfully');
        return redirect()->back();
    }
    public function questions()
    {
        return 'ddd';
    }
    public function questionsList()
    {
        $questionsData = [];
        $groups = QuestionGroup::all();
        foreach ($groups as $group) {
            $questions = Question::where('group_id', $group->id)->get()->toArray();
            $questionsData[$group->title] = $questions;
        }
        return response()->json(
            $questionsData
        );
    }
    public function questionsAnswers($patient_id, $appointment_id)
    {
        $questionsData = [];
        $answers = [];
        $groups = QuestionGroup::all();
        foreach ($groups as $group) {
            $questions = Question::where('group_id', $group->id)->get();
            foreach ($questions as $question) {

                $answer = PatientAnswer::where('question_id', $question->id)->where('patient_id', $patient_id)->where('appointment_id', $appointment_id)->first();
                if (isset($answer->answer))
                    $question['answer'] = $answer->answer;
                else
                    $question['answer'] = null;
            }
            $questionsData[$group->title] = $questions;
        }
        return response()->json(
            $questionsData
        );
    }

    public function storeAnswers(Patient $patient, Appointment $appointment, Request $request)
    {

        $data = $request->input("data");

        foreach ($data as $row) {
            if (isset($row['answer']))
                PatientAnswer::create([
                    'patient_id' => $patient->id,
                    'appointment_id' => $appointment->id,
                    'question_id' => $row['question_id'],
                    'answer' => $row['answer']
                ]);
        }

        return response()->json([
            'message' => 'Answers stored successfully'
        ]);
    }
    public function getQuestions(Patient $patient, Appointment $appointment, Request $request)
    {
        $questions = PatientAnswer::select('questions.*', 'patient_answers.answer')
            ->leftJoin('questions', 'questions.id', '=', 'patient_answers.question_id')
            ->where('patient_answers.patient_id', $patient->id)
            ->where('patient_answers.appointment_id', $appointment->id)
            ->get();

        return response()->json([
            'questions' => $questions
        ]);
    }
    public function switchButton(Telemedpro $agent, $switch)
    {
        if ($switch == 1)
            $agent->recording_switch = $switch;
        else
            $agent->recording_switch = 0;
        $agent->save();

        return response()->json([
            'message' => 'Recording Switched: ' . $switch
        ]);
    }
    public function switchButtonGet(Telemedpro $agent)
    {
        return response()->json([
            'recording_switch' => $agent->recording_switch,
        ]);
    }
    public function switchAiButton(Telemedpro $agent, $switch)
    {
        if ($switch == 1)
            $agent->ai_switch = $switch;
        else
            $agent->ai_switch = 0;
        $agent->save();

        return response()->json([
            'message' => 'AI Switched: ' . $switch
        ]);
    }
    public function switchAiButtonGet(Telemedpro $agent)
    {
        return response()->json([
            'ai_switch' => $agent->ai_switch,
        ]);
    }
    public function getProfile(Request $request)
    {
        $user = Auth::user();
        return response()->json([
            'ai_switch' => $user,
        ]);
    }


    public function questionsListV1()
    {
        $questionGroups = QuestionGroup::with('questions')->get();

        $formattedGroups = [];

        foreach ($questionGroups as $group) {
            $formattedGroups[$group->title] = [];
            foreach ($group->questions as $question) {
                $formattedGroups[$group->title][$question->question] = [$question->type => unserialize($question->options)];
            }
        }

        return response()->json($formattedGroups);
    }
    public function DeviceCurrentStatus(Request $request)
    {
        /*  $patient = Patient::where("id", $patient_id)->firstOrFail(); */
        $micStatus = $request->input('micStatus');
        $camStatus = $request->input('camStatus');
        event(new DeviceCurrentStatus($micStatus, $camStatus));

        return true;
    }
    public function getAnalytics($filter = '12_months')
    {
        $currentMonth = Carbon::now();

        // Filter logic
        switch ($filter) {
            case 'current_month':
                $startDate = $currentMonth->copy()->startOfMonth();
                break;
            case '1_month':
                $startDate = $currentMonth->copy()->subMonth()->startOfMonth();
                break;
            case '2_months':
                $startDate = $currentMonth->copy()->subMonths(2)->startOfMonth();
                break;
            case '3_months':
                $startDate = $currentMonth->copy()->subMonths(3)->startOfMonth();
                break;
            case '6_months':
                $startDate = $currentMonth->copy()->subMonths(6)->startOfMonth();
                break;
            default: // Default to 12 months
                $startDate = $currentMonth->copy()->subMonths(12)->startOfMonth();
        }

        $endDate = $currentMonth->endOfMonth();


        $appointments = Appointment::with('patient')
            ->where("telemed_pros_id", Auth::user()->id)
            ->whereBetween('created_at', [$startDate, $endDate])
            ->get();

        $totalSessions = $appointments->count();
        $totalCallTime = 10; // Assuming you have some logic to calculate this
        if ($totalSessions != 0) {
            $avgSessionTime = $totalCallTime / $totalSessions;
            $avgSessionTime = round(($avgSessionTime / 60), 2);
        } else
            $avgSessionTime = '';


        $monthlyData = [];

        // Loop through each month in the last 12 months
        for ($date = $startDate->copy(); $date->lte($endDate); $date->addMonth()) {
            $monthStart = $date->startOfMonth()->format('Y-m-d');
            $monthEnd = $date->copy()->endOfMonth()->format('Y-m-d'); // Key change here!

            $monthAppointments = Appointment::with('patient')
                ->where("telemed_pros_id", Auth::user()->id)
                ->whereBetween('created_at', [$monthStart, $monthEnd])
                ->get();


            // Calculate any metrics you need from $monthAppointments
            $monthlyData[] = [
                'month' => $date->format('M'), // Example: Jan 2024
                'appointment_count' => $monthAppointments->count()
                // Add other metrics as needed
            ];
        }
        $monthsList = [];
        $monthlySessionCount = [];

        foreach ($monthlyData as $dataPoint) {
            $monthsList[] = $dataPoint['month'];
            $monthlySessionCount[] = $dataPoint['appointment_count'];
        }


        return response()->json([
            'total_sessions' => $totalSessions,
            'total_call_time' => $totalCallTime,
            'avg_session_time' => $avgSessionTime,
            'data' => array_values($monthlySessionCount),  // Ensure consistent order
            'months_list' => $monthsList,
        ]);
    }

    public function getMeetingHistory($filter = '12_months')
    {
        $currentMonth = Carbon::now();

        // Filter logic
        switch ($filter) {
            case 'current_month':
                $startDate = $currentMonth->copy()->startOfMonth();
                break;
            case '1_month':
                $startDate = $currentMonth->copy()->subMonth()->startOfMonth();
                break;
            case '2_months':
                $startDate = $currentMonth->copy()->subMonths(2)->startOfMonth();
                break;
            case '3_months':
                $startDate = $currentMonth->copy()->subMonths(3)->startOfMonth();
                break;
            case '6_months':
                $startDate = $currentMonth->copy()->subMonths(6)->startOfMonth();
                break;
            default: // Default to 12 months
                $startDate = $currentMonth->copy()->subMonths(12)->startOfMonth();
        }

        $endDate = $currentMonth->endOfMonth();

        // Fetch patient names and appointment counts directly from the database
        $monthlyData = Appointment::select(
            'appointments.patient_id',
            /* DB::raw('COUNT(*) as appointment_count'), */
            'appointment_time',
            'appointment_date',
            'start_time',
            'end_time',
            'duration',
            'appointments.id as appointment_id',
            'carts.id as order_id'
        )
            ->leftJoin('carts', 'carts.appointment_id', 'appointments.id')
            ->where("appointments.telemed_pros_id", Auth::user()->id)
            ->whereBetween('appointments.created_at', [$startDate, $endDate])

            ->get();

        $patients = [];

        foreach ($monthlyData as $dataPoint) {
            $patient = $dataPoint->patient;
            /* $appointmentCount = $dataPoint->appointment_count; */
            $start_time = $dataPoint->start_time;
            $end_time = $dataPoint->end_time;
            $duration = $dataPoint->duration;
            $appointment_time = $dataPoint->appointment_time;
            $appointment_date = $dataPoint->appointment_date;
            $appointment_id = $dataPoint->appointment_id;
            $order_id = $dataPoint->order_id;

            $patients[] = [
                'patient' => $patient,
                'appointment_time' => $appointment_time,
                'appointment_date' => $appointment_date,
                /* 'appointment_count' => $appointmentCount, */
                'start_time' => $start_time,
                'end_time' => $end_time,
                'duration' => $duration,
                'appointment_id' => $appointment_id,
                'order_id' => $order_id
            ];
        }

        return response()->json([
            'patients' => $patients,
        ]);
    }
    public function sessionHistory(Request $request)
    {
        $user = $request->user();

        // Assuming user can be either telemedPro or patient
        $history = Appointment::select(
            'appointments.*',
            'appointments.patient_id',
            'patients.first_name as patient_name',
            'carts.id as order_id'
        )
            ->leftJoin('patients', 'appointments.patient_id', '=', 'patients.id')
            ->leftJoin('carts', 'carts.appointment_id', '=', 'appointments.id')
            ->where(function ($query) use ($user) {
                $query->where('appointments.telemed_pros_id', $user->id);
            })
            ->whereNotNull("appointments.end_time")
            ->orderBy('appointments.appointment_date', 'desc')
            ->get();

        return response()->json(['history' => $history]);

        return response()->json(['history' => $history]);
    }
    public function getAppointmentByid($patient, $appointment, Request $request)
    {
        $user = $request->user();

        // Assuming user can be either telemedPro or patient
        $data = Appointment::select(
            'appointments.*',
            'telemed_pros.name as agent_name',
        )
            ->leftJoin('telemed_pros', 'appointments.telemed_pros_id', '=', 'telemed_pros.id')
            ->where('appointments.telemed_pros_id', $user->id)
            ->where('appointments.patient_id', $patient)
            ->where('appointments.id', $appointment)
            ->first();
        $order = Cart::where('appointment_id', $data->id)->first();
        $orderItems = Item::leftJoin('plans_v1', 'plans_v1.id', 'items.plans_id')
            ->where('cart_id', $order->id)->get();
        $data->order = $order;
        $data->telemedPro;
        // $data->order_items = $orderItems;
        $totalPrice = 0;
        $total_products = 0;
        $quantity = [];
        $totalShippingCost = 0;
        $data->order_notes = PatientNote::where('appointment_id', $appointment)->get();
        foreach ($orderItems as $item) {
            $totalShippingCost += $item->shipping_cost;
            $item->total_price = $item->quantity * $item->price;
            $totalPrice += $item->total_price;
            $order->order_total_amount = $totalPrice;
            $order->order_total_shipping = $totalShippingCost;
            $item->plansV1->qty = $item->quantity;
        }
        $data->order_items = $orderItems;

        $data->shipping_activity = ItemHistory::where('cart_id', $order->id)->get();
        return response()->json(['data' => $data]);
    }
    public function addNotePatient(Patient $patient, Appointment $appointment, Request $request)
    {
        $user = Auth::user();
        $addNotePatient = PatientNote::create([
            'note' => $request->input('note'),
            'note_type' => $request->input('note_type'),
            'patient_id' => $patient->id,
            'appointment_id' => $appointment->id,
            'telemed_pros_id' => $user->id
        ]);
        $addNotePatient->file_url = "";
        if ($request->hasFile('file')) {
            $file = $request->file('file');

            $filename = $addNotePatient->id . '.' . $file->getClientOriginalExtension();

            $file->move(public_path('assets/files'), $filename);

            $addNotePatient->file_url = "assets/files" . $addNotePatient->id . '.' . $file->getClientOriginalExtension();
        }
        $patient = $addNotePatient->patient;
        $setting = Setting::find(1);
        Mail::send('emails.noteAdded', ['patient' => $patient, 'agent' => $user, 'setting' => $setting], function ($message) use ($patient, $user) {
            $message->to($patient->email, $patient->first_name)
                ->subject('You Have a New Note from ' . $user->name);
        });
        return response()->json([
            'message' => 'Note created',
            'data' => $addNotePatient
        ], 200);
    }

    public function getNotePatient(Patient $patient, Appointment $appointment, Request $request)
    {
        $patientNotes = PatientNote::where("patient_id", $patient->id)
            ->where("appointment_id", $appointment->id)
            ->with('appointment')
            ->get();

        $data = $patientNotes->map(function ($patientNote) {
            $fileUrl = "/assets/files/{$patientNote->id}.png";
            $filePath = public_path($fileUrl);

            if (File::exists($filePath)) {
                $fileUrl = "/assets/files/{$patientNote->id}.png";
            } else {
                $fileUrl = null;
            }

            return [
                'id' => $patientNote->id,
                'note' => $patientNote->note,
                'note_type' => $patientNote->note_type,
                'created_at' => $patientNote->created_at,
                'patient_id' => $patientNote->patient_id,
                'appointment' => $patientNote->appointment,
                'telemedPro' => $patientNote->telemedPro,
                'file_url' => $fileUrl,
                'telemedPro' => $patientNote->appointment?->telemedPro
            ];
        });

        return response()->json([
            'message' => 'Patient notes retrieved',
            'data' => $data
        ], 200);
    }

    public function getQuestionBuilderStore(Patient $patient, Request $request)
    {

        $questionBuilder = QuestionBuilder::select('key', 'value')->where("customer_id", $patient->id)->get();
        $jsonData = $questionBuilder->mapWithKeys(function ($item) {
            return [$item->key => $item->value];
        });
        // Store data
        return response()->json([
            'message' => 'Data Sent',
            'data' => $jsonData
        ], 200);
    }
    public function getPrescription()
    {
        $prescriptions = Prescription::all();
        return response()->json($prescriptions);
    }
    public function storePrescription(Request $request)
    {
        $prescription = Prescription::create($request->all());
        return response()->json($prescription, 200);
    }
    public function storePatientPrescription(Request $request)
    {
        $user = Auth::user();
        $prescription = PatientPrescription::create($request->all());
        $prescription->status = "pending";
        $prescription->save();
        $patient = $prescription->patient;
        $setting = Setting::find(1);
        Mail::send('emails.prescriptionAdd', ['patient' => $patient, 'prescription' => $prescription, 'setting' => $setting], function ($message) use ($patient, $user) {
            $message->to($patient->email, $patient->first_name)
                ->subject('New Prescription Details from ' . $user->name);
        });
        return response()->json($prescription, 200);
    }
    public function updateStatusPrescription($patient_prescription_id, Request $request)
    {
        $status = $request->input("status");
        $prescription = PatientPrescription::find($patient_prescription_id);
        $prescription->status = $status;
        $prescription->save();
        $patient = $prescription->patient;
        $setting = Setting::find(1);
        Mail::send('emails.prescriptionUpdated', ['patient' => $patient, 'setting' => $setting], function ($message) use ($patient) {
            $message->to($patient->email, $patient->first_name)
                ->subject('Prescription updated.');
        });
        return response()->json($prescription, 200);
    }

    public function getStatusPrescription($patient_prescription_id)
    {
        $prescription = PatientPrescription::find($patient_prescription_id);
        return response()->json($prescription, 200);
    }
    public function getPatientPrescription($patient_id, $appointment_id)
    {
        $patientPrescription = PatientPrescription::with('prescription')
            ->where('patient_id', $patient_id)
            ->where('appointment_id', $appointment_id)
            ->get();

        $prescriptionData = [];
        foreach ($patientPrescription as $prescription) {
            $prescriptionData[] = [
                'patient' => $prescription->patient,
                'prescription' => $prescription->prescription,
                'created_at' => $prescription->created_at,
                'updated_at' => $prescription->updated_at,
                'direction_one' => $prescription->direction_one,
                'direction_two' => $prescription->direction_two,
                'dont_substitute' => $prescription->dont_substitute,
                'comments' => $prescription->comments,
                'appointment_id' => $prescription->appointment_id,
                'status' => $prescription->status,
                'appointment' => $prescription->appointment,
                'telemedPro' => $prescription->appointment->telemedPro,
                'licenseNumber' => LicenseNumberModel::where("provider_id", $patient_id)->orderBy('id', 'DESC')->first()
            ];
        }
        if (!$patientPrescription->isEmpty()) {
            return response()->json($prescriptionData);
        } else {
            return response()->json(['message' => 'Prescription not found'], 404);
        }
    }
    public function getOrderData(Cart $cart, Request $request)
    {
        $cart = Cart::with("patient")->get();
        return response()->json(['cart' => $cart], 200);
    }

    public function getLabKit(Cart $cart, Request $request)
    {
        $kit = LabKit::all();
        return response()->json(['kit' => $kit], 200);
    }

    public function orderLabKit(LabKit $labkit, Patient $patient, Request $request)
    {


        $user = $patient;
        $cart = new Cart();
        $cart->lab_kit_id = $labkit->id;
        $cart->first_name = $patient->first_name;
        $cart->last_name = $patient->last_name;
        $cart->email = $patient->email;
        $cart->phone = $patient->phone_no;
        $cart->status = "pending";

        $cart->date_of_birth = $patient->dob ?? null;

        $cart->patient_id = $user->id;

        $cart->shipping_address1 = $patient->address;
        $cart->shipping_city = $patient->city;
        $cart->shipping_state = $patient->state;
        $cart->shipping_zipcode = $patient->zip_code;
        $cart->shipping_country = $patient->country;


        $cart->shipping_amount = $labkit->amount;
        $cart->total_amount = $labkit->amount;

        $cart->save();
        return response()->json(['status' => 'Success', 'cart' => $cart], 200);
    }

    public function getorderedLabKit(LabKit $labkit, Patient $patient, Request $request)
    {
        $detail = Cart::select("carts.*", "lab_kit.name")->leftJoin("lab_kit", "carts.lab_kit_id", "=", "lab_kit.id")
            ->where("carts.lab_kit_id", $labkit->id)
            ->where("carts.patient_id", $patient->id)
            ->get();

        return response()->json(['order' => $detail], 200);
    }
    public function getorderedLabKitBasedOnPatient(Patient $patient, Request $request)
    {
        $detail = Cart::select("carts.*", "lab_kit.name")->leftJoin("lab_kit", "carts.lab_kit_id", "=", "lab_kit.id")
            ->where("carts.patient_id", $patient->id)
            ->get();

        return response()->json(['order' => $detail], 200);
    }
    public function updateStatusOrderData(Cart $cart, Request $request)
    {

        $cart = Cart::where("id", $cart->id)->firstOrFail();
        $cart->status = $request->input("status");
        $cart->save();

        return response()->json(['status' => 'Success', 'cart' => $cart], 200);
    }
    public function PatientAppointment()
    {
        $user = Auth::user();
        $data = [];
        $appointments = Appointment::select('patient_id')->where('telemed_pros_id', $user->id)->groupBy('patient_id')->get();
        foreach ($appointments as $appointment) {
            $patient = Patient::where('id', $appointment->patient_id)->first();
            array_push($data, $patient->toArray());
        }
        return response()->json(['status' => 'Success', 'patient' => $data], 200);
    }
}