streamline-emr/docker/streamline-src/Modules/Pharmacy/Http/Controllers/PharmacyController.php

<?php

namespace Modules\Pharmacy\Http\Controllers;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use \Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Validator;
use Illuminate\View\View;
use Streamline\Models\CancelledPatientOpdDispensation;
use Streamline\Models\CancerProtocolWardChart;
use Streamline\Models\Consultation;
use Streamline\Models\EyeGlasses;
use Streamline\Models\HospitalInformation;
use Streamline\Models\InsuranceClaim;
use Streamline\Models\OpticalStockReconciliation;
use Streamline\Models\PatientEpisode;
use Streamline\Models\ReturnedDrugsPerWardChart;
use Streamline\Models\Treatment;
use Streamline\Models\Patient;
use Streamline\Models\Drug;
use Streamline\Models\Sundry;
use Streamline\Models\Radiology;
use Streamline\Models\Dental;
use Streamline\Models\Lab;
use Streamline\Models\TreatmentOpdProgressive;
use Streamline\Models\User;
use Streamline\Models\Ward;
use Streamline\Models\WardDispensing;
use Streamline\Models\DosageFrequency;
use Streamline\Models\PatientDispensing;
use Streamline\Models\PrescriptionError;
use Streamline\Models\TemporaryRequisition;
use Streamline\Models\Requisition;
use Streamline\Models\Allergy;
use Streamline\Models\Alert;
use Streamline\Models\InpatientInfo;
use Streamline\Models\WardTreatmentDispensation;
use Streamline\Models\WardTreatment;
use Streamline\Models\WardChartApproval;
use Streamline\Models\IncomingWardChart;
use Streamline\Models\ChartOfAccount;
use Streamline\Models\PharmacyStockReconciliation;
use Streamline\Models\PharmacySundryStockReconciliation;
use Carbon\Carbon;
use Streamline\Models\GeneralItem;
use Barryvdh\Snappy\Facades\SnappyPdf;
use Streamline\Models\CancerProtocol;
use Streamline\Services\UserService;
use Modules\Stores\Services\StoresItemService;
use Streamline\Models\BatchConsumptionTracking;
use Streamline\Models\ItemBatchWatcher;
use Streamline\Models\WardTreatmentBatchDispensation;
use Streamline\Services\WardManagement\WardTreatmentDispensationService;

class PharmacyController extends Controller {

    public function __construct(
        protected UserService $userService,
        protected StoresItemService $itemService,
        protected WardTreatmentDispensationService $dispensationService
    ) {
        $this->middleware('auth');
        $this->middleware('permission:pharmacy-incoming-prescriptions', ['only' => ['index']]);
        $this->middleware('permission:pharmacy-ward-dispensing', ['only' => ['store', 'ward_dispensing']]);
        $this->middleware('permission:pharmacy-stock-sheet', ['only' => ['stock_sheet']]);
        $this->middleware('permission:pharmacy-optical-stock-sheet', ['only' => ['pharmacy_optical_stock_sheet']]);
        $this->middleware('permission:pharmacy-drug-requisition', ['only' => ['requisition_for_drugs', 'store_requisition']]);
        $this->middleware('permission:pharmacy-saved-requisitions', ['only' => ['select_temporary_requisition', 'edit_temporary_requisition']]);
        $this->middleware('permission:pharmacy-previous-requisitions', ['only' => ['previous_drug_requisitions', 'edit_previous_requisition', 'update_previous_requisition']]);
        $this->middleware('permission:confirm-prescriptions', ['only' => ['confirm_prescriptions','confirm_dispensing_details','store_prescription_confirmation','view_dispensing_details_error']]);
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index() {

        $today = Carbon::today()->toDateString();
        $display = "Report for ".streamline_date($today);

        if(is_incoming_prescriptions_feature_enabled()){
            $pending_unpaid_prescriptions = Treatment::where(['confirmation_status' => 1,'dispense_status' => 0, 'payment_status'=> 0])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $pending_paid_prescriptions = Treatment::where(['confirmation_status' => 1,'dispense_status' => 0, 'payment_status'=> 1])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $confirmed_unpaid_prescriptions = Treatment::where(['confirmation_status' => 1,'dispense_status' => 1, 'payment_status'=> 0])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $confirmed_paid_prescriptions = Treatment::where(['confirmation_status' => 1,'dispense_status' => 1, 'payment_status'=> 1])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
        } else{
            $pending_unpaid_prescriptions = Treatment::where(['dispense_status' => 0, 'payment_status'=> 0])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $pending_paid_prescriptions = Treatment::where(['dispense_status' => 0, 'payment_status'=> 1])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $confirmed_unpaid_prescriptions = Treatment::where(['dispense_status' => 1, 'payment_status'=> 0])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
            $confirmed_paid_prescriptions = Treatment::where(['dispense_status' => 1, 'payment_status'=> 1])->whereDate('created_at', $today)->orderBy('created_at', 'desc')->get();
        }

        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");

        return view('pharmacy::pharmacy.index', compact('pending_paid_prescriptions', 'pending_unpaid_prescriptions','confirmed_paid_prescriptions',
            'confirmed_unpaid_prescriptions', 'categories', 'display'));
    }

    public function search(Request $request){

        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
        $display = dateLabelSetter2($request);
        $filters = [];

        if(is_incoming_prescriptions_feature_enabled()){
            $filters[] = ['confirmation_status', '=', 1];
        }

        if (isset($request->patient_id) && $request->patient_id != 0) {
            $filters[] = ['patient_id', '=', $request->patient_id];
            $pending_unpaid_prescriptions = Treatment::where(['patient_id' => $request->patient_id,'dispense_status' => 0, 'payment_status'=> 0])
                ->where($filters)->orderBy('created_at', 'desc')->get();
            $pending_paid_prescriptions = Treatment::where(['patient_id' => $request->patient_id,'dispense_status' => 0, 'payment_status'=> 1])
                ->where($filters)->orderBy('created_at', 'desc')->get();
            $confirmed_unpaid_prescriptions = Treatment::where(['patient_id' => $request->patient_id,'dispense_status' => 1, 'payment_status'=> 0])
                ->where($filters)->orderBy('created_at', 'desc')->get();
            $confirmed_paid_prescriptions = Treatment::where(['patient_id' => $request->patient_id,'dispense_status' => 1, 'payment_status'=> 1])
                ->where($filters)->orderBy('created_at', 'desc')->get();
        } else {
            switch ($request->dates){
                case 'today':
                    $end = Carbon::today()->endOfDay();
                    $start = Carbon::today()->startOfDay();
                    break;
                case 'yesterday':
                    $end = Carbon::yesterday()->endOfDay();
                    $start = Carbon::yesterday()->startOfDay();
                    break;
                case 'custom_date':
                    $end = Carbon::parse($request->start_date)->endOfDay();
                    $start = Carbon::parse($request->start_date)->startOfDay();
                    break;
                case 'custom_date_range':
                    $end = Carbon::parse($request->end_date)->endOfDay();
                    $start = Carbon::parse($request->start_date)->startOfDay();
            }

            $pending_unpaid_prescriptions = Treatment::where(['dispense_status' => 0, 'payment_status'=> 0])
                ->whereBetween('created_at',[$start, $end])->where($filters)->orderBy('created_at', 'desc')->get();
            $pending_paid_prescriptions = Treatment::where(['dispense_status' => 0, 'payment_status'=> 1])
                ->whereBetween('created_at',[$start, $end])->where($filters)->orderBy('created_at', 'desc')->get();
            $confirmed_unpaid_prescriptions = Treatment::where(['dispense_status' => 1, 'payment_status'=> 0])
                ->whereBetween('created_at',[$start, $end])->where($filters)->orderBy('created_at', 'desc')->get();
            $confirmed_paid_prescriptions = Treatment::where(['dispense_status' => 1, 'payment_status'=> 1])
                ->whereBetween('created_at',[$start, $end])->where($filters)->orderBy('created_at', 'desc')->get();
        }

        return view('pharmacy::pharmacy.index', compact('pending_paid_prescriptions', 'pending_unpaid_prescriptions','confirmed_paid_prescriptions',
            'confirmed_unpaid_prescriptions', 'categories', 'display'));
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create() {
        //
    }

    /**
     * Store a new ward dispensing
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request) {
        // check if any drug has been selected
        if(is_array($request->drug_id)){
            $ward_id = $request->ward;
            $dispensation_date = Carbon::createFromFormat('d/m/Y', $request->dispensation_date)->toDateString();
            $drug_id_array = $request->drug_id;
            $quantity_returned_array = $request->quantity_returned;
            $quantity_dispensed_array = $request->quantity_dispensed;
            $total_array = $request->total;
            $stock_array = $request->stock;
            $pharmacy_comment_array = $request->pharmacy_comment;

            for ($x = 0; $x < count($drug_id_array); $x++) {
                //Incrementing the quantity in the drugs table with quantity returned every time the query runs
                $drug = Drug::find($drug_id_array[$x]);
                $new_stock_after_return = $drug->pharmacy_stock + $quantity_returned_array[$x];
                $drug->pharmacy_stock = $new_stock_after_return;
                $drug->updated_by = Auth::id();
                $drug->updated_at = Carbon::now();
                $drug->update();

                //Decrementing the quantity in the drugs table with the quantity dispensed every time the query runs
                $new_stock_after_dispensing = $drug->pharmacy_stock - $quantity_dispensed_array[$x];
                $drug->pharmacy_stock = $new_stock_after_dispensing;
                $drug->updated_by = Auth::id();
                $drug->updated_at = Carbon::now();
                $drug->update();
            }

            //Run the query to insert the ward dispensing into the ward dispensing table
            $ward_dispensing = new WardDispensing;
            $ward_dispensing->ward_id = $ward_id;
            $ward_dispensing->drug_id = implode(',', $drug_id_array);
            $ward_dispensing->quantity_returned = implode(',', $quantity_returned_array);
            $ward_dispensing->quantity_dispensed = implode(',', $quantity_dispensed_array);
            $ward_dispensing->stock = implode(',', $stock_array);
            $ward_dispensing->total = implode(',', $total_array);
            $ward_dispensing->dispensation_date = $dispensation_date;
            $ward_dispensing->comment = implode(',', $pharmacy_comment_array);
            $ward_dispensing->received_by = $request->received_by;
            $ward_dispensing->created_by = Auth::id();
            if ($ward_dispensing->save()) {
                flash('Drugs have been successfully dispensed')->success();
                return redirect('ward_dispensing');
            }
            flash('Error in dispensing. Kindly contact the system admin ')->error();
            return redirect()->back();
        } else {
            flash('Error in dispensing. Kindly contact the system admin ')->error();
            return redirect()->back();
        }
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id) {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id) {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id) {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id) {
        //
    }

    /* view dispensing details */

    public function view_dispensing_details(Request $request) {
        $treatment_id = $request->treatment_id;
        $patient_id = $request->patient_id;
        $episode_id = $request->episode_id;

        $patient = Patient::where(['id' => $patient_id])->first();
        $treatment = Treatment::find($treatment_id);

        $previous_treatments = Treatment::where('patient_id',$patient_id)->where('episode_id', '!=', $episode_id)->take(5)->get();

        return view('pharmacy::pharmacy.view_dispensing_details', compact('patient_id', 'treatment_id', 'patient', 'treatment', 'previous_treatments'));
    }

    /**
     * Return to dispensing view with errors
     *
     * @param $treatment_id
     * @param $patient_id
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
     */
    public function view_dispensing_details_error($treatment_id, $patient_id) {

        $patient = Patient::where(['id' => $patient_id])->first();
        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
        $marital_statuses = DB::table('marital_statuses')->pluck("name", "id");
        $drug_categories = DB::table('drug_categories')->get();
        $treatment = Treatment::find($treatment_id);

        //allergies and alerts
        $known_patient_allergies = Allergy::where('patient_id', $patient_id)->orderBy('created_at', 'desc')->take(2)->get();
        $known_patient_alerts = Alert::where('patient_id', $patient_id)->orderBy('created_at', 'desc')->take(2)->get();
        $drug_categories_array = DB::table('drug_categories')->pluck('name', 'id');

        return view('pharmacy::pharmacy.view_dispensing_details', compact('patient_id', 'treatment_id', 'patient', 'categories', 'marital_statuses', 'drug_categories', 'treatment', 'known_patient_alerts', 'known_patient_allergies', 'drug_categories_array'));
    }

    /* dispense prescriptions */

    public function dispense_prescription(Request $request) {
        $patient_id = $request->patient_id;
        $treatment_id = $request->treatment_id;

        $drug_ids_array = $request->drug_id;
        $quantity_to_dispense_array = $request->quantity_to_dispense;

        $dose_array = $request->dose;
        $dose_2_array = isset($request->dose2) ? $request->dose2 : [];
        $frequency_array = $request->frequency;
        $duration_array = $request->duration;
        $instructions_to_patient_array = $request->instructions;
        $to_take_away = $request->tta;
        $comment = $request->comment;
        $purchased_elsewhere = $request->purchased_elsewhere;
        $purchased_elsewhere_array = [];
        /*
          1.reduce pharmacy_stock of that drug that's been dispensed
          2.insert into patient_dispensing
          3.insert into prescription error if there is one
          4.update treatment and set dispense status to 1 where id = treatment_id.
          5.issue patient dispensed receipt
        */
        for ($x = 0; $x < count($drug_ids_array); $x++) {
            if (isset($purchased_elsewhere) && count($purchased_elsewhere) > 0 && in_array($drug_ids_array[$x], $purchased_elsewhere)) {
                $purchased_elsewhere_array[] = 1;
            } else {
                $drug = Drug::find($drug_ids_array[$x]);

                if ($drug) {
                    if (get_inventory_reduction_point() == 1) {
                        $current_stock = $drug->pharmacy_stock;
                        $new_stock = $current_stock - $quantity_to_dispense_array[$x];
                        $drug->pharmacy_stock = $new_stock;
                        $drug->update();
                    }
                } else {
                    $quantity_to_dispense_array[$x] = 0;
                }

                $purchased_elsewhere_array[] = 0;
            }
        }

        /* ========= batch calculations =========== */
        $batch_drug_ids_array = $request->batch_drug_id;
        $batched_dispensed_array = $request->batch_dispensed_from?? [];
        $batch_quantity_dispensed_array = $request->batch_quantity_to_dispense;
        for ($x = 0; $x < count($batched_dispensed_array); $x++) {
            if (isset($purchased_elsewhere) && count($purchased_elsewhere) > 0 && in_array($batch_drug_ids_array[$x] ?? 0, $purchased_elsewhere)){
                //in purchased elsewhere so do not reduce
            } else{
                if (get_inventory_reduction_point() == 1) {
                    reduce_batch_item_stock($item_type = 1,$batch_drug_ids_array[$x],$batched_dispensed_array[$x]??0, 'drugs', 'pharmacy_stock',$batch_quantity_dispensed_array[$x] ?? 0, 'treatments','Dispensing', $treatment_id, $patient_id);

                    // reduce_batch_item_from_pharmacy($item_type = 1, $batch_drug_ids_array[$x] ?? 0, $batched_dispensed_array[$x] ?? 0, $batch_quantity_dispensed_array[$x] ?? 0, "treatments", $treatment_id, $patient_id);
                }
            }
        }
        /* ========= end of batch calculations ==== */

        //Inserting patient dispensing
        $patient_dispensing = new PatientDispensing;
        $patient_dispensing->patient_id = $patient_id;
        $patient_dispensing->treatment_id = $treatment_id;
        $patient_dispensing->drugs = implode(',', $drug_ids_array);
        $patient_dispensing->dose = implode(',', $dose_array);
        $patient_dispensing->dose2 = implode(',', $dose_2_array);
        $patient_dispensing->drug_frequency = implode(',', $frequency_array);
        $patient_dispensing->duration = implode(',', $duration_array);
        $patient_dispensing->quantity_dispensed = implode(',', $quantity_to_dispense_array);
        $patient_dispensing->dispensed = 1;
        $patient_dispensing->instructions = implode(',', $instructions_to_patient_array);
        $patient_dispensing->tta = $to_take_away;
        $patient_dispensing->prescription_date = Carbon::now();
        $patient_dispensing->pharmacy_comment = $comment;
        $patient_dispensing->purchased_elsewhere = implode(",", $purchased_elsewhere_array);
        $patient_dispensing->created_by = Auth::id();
        $patient_dispensing->save();

        $dispensing_id = $patient_dispensing->id; // get the last inserted ID

        //Updating the treatment table to show that the previous prescription was altered
        $treatment_model = Treatment::find($treatment_id);
        $treatment_model->dispense_status = 1;
        $treatment_model->purchased_elsewhere = implode(",", $purchased_elsewhere_array);
        /*====== save the current selling price now for those patients that will pay later when price has changed ====*/
        $unit_selling_prices_array = [];
        $price_list_id = is_patient_category_attached_to_price_list($patient_id);
        for ($i=0; $i < count($drug_ids_array) ; $i++) {
            $drug_insurance_status = get_name($drug_ids_array[$i], "id", "insurance_coverage", "drugs");
            if ($price_list_id) {
                $treatment_amount = get_price_list_category_price($price_list_id, 3, $drug_ids_array[$i]);
                if($drug_insurance_status == 1 && patient_insurance_status($patient_id) == 1){
                    $treatment_amount = get_chi_price_list_category_price($price_list_id, 3, $drug_ids_array[$i]);
                }
            } else {
                // check if drug and patient is eligible for insurance
                if($drug_insurance_status == 1 && patient_insurance_status($patient_id) == 1){
                    $treatment_amount = get_name($drug_ids_array[$i], "id", "insured_price", "drugs");
                } else {
                    $treatment_amount = get_name($drug_ids_array[$i], "id", "non_insured_price", "drugs");
                }
            }
            $unit_selling_prices_array[] = $treatment_amount;
        }
        /* =============================================== */
        $treatment_model->unit_selling_prices = implode(",", $unit_selling_prices_array);
        $treatment_model->save();

        flash('Treatment dispensed successfully')->success();
        return redirect('patient_dispensing_receipt/' . $dispensing_id);
    }

    public function edit_dispensing_details($patient_id, $treatment_id){
        $treatment = Treatment::find($treatment_id);
        session()->put('alter_episode_id', $treatment->episode_id);
        session()->put('alter_patient_id', $patient_id);
        return redirect('/prescriptions/create');
    }

    public function save_altered_prescription(Request $request){
        $patient_id = $request->patient_id;
        $treatment_id = $request->treatment_id;

        $drug_ids_array = $request->drug_id;
        $quantity_to_dispense_array = $request->quantity_to_dispense;

        $dose_array = $request->dose;
        $dose_2_array = isset($request->dose2) ? $request->dose2 : [];
        $frequency_array = $request->frequency;
        $duration_array = $request->duration;
        $instructions_to_patient_array = $request->instructions;
        $prescribed_by = $request->prescribed_by;
        $to_take_away = $request->tta;
        $pharmacist = Auth::id();
        $comment = $request->comment;
        $type_of_error = [];
        isset($request->wrong_dosage) ? $type_of_error[] = "Wrong dosage" : "";
        isset($request->wrong_frequency) ? $type_of_error[] = "Wrong frequency" : "";
        isset($request->inadequate_funds) ? $type_of_error[] = "Inadequate Funds" : "";
        isset($request->other_error) ? $type_of_error[] = "Other error" : "";
        $type_of_error = implode(',', $type_of_error);
        $severity_of_error = $request->severity_of_error;

        // update the drug stock levels
        for ($x = 0; $x < count($drug_ids_array); $x++) {
            $drug = Drug::find($drug_ids_array[$x]);
            $current_stock = $drug->pharmacy_stock;
            $new_stock = $current_stock - $quantity_to_dispense_array[$x];
            $drug->pharmacy_stock = $new_stock;
            $drug->update();
        }

        // inserting patient dispensing
        $patient_dispensing = new PatientDispensing;
        $patient_dispensing->patient_id = $patient_id;
        $patient_dispensing->treatment_id = $treatment_id;
        $patient_dispensing->drugs = implode(',', $drug_ids_array);
        $patient_dispensing->dose = implode(',', $dose_array);
        $patient_dispensing->dose2 = implode(',', $dose_2_array);
        $patient_dispensing->drug_frequency = implode(',', $frequency_array);
        $patient_dispensing->duration = implode(',', $duration_array);
        $patient_dispensing->quantity_dispensed = implode(',', $quantity_to_dispense_array);
        $patient_dispensing->dispensed = 1;
        $patient_dispensing->instructions = implode(',', $instructions_to_patient_array);
        $patient_dispensing->tta = $to_take_away;
        $patient_dispensing->prescription_date = Carbon::now();
        $patient_dispensing->pharmacy_comment = $comment;
        $patient_dispensing->created_by = Auth::id();
        $patient_dispensing->save();
        $dispensing_id = $patient_dispensing->id;

        // updating the treatment table to show that the previous prescription was altered
        $treatment_model = Treatment::find($treatment_id);
        $treatment_model->altered = $patient_dispensing->id;
        $treatment_model->dispense_status = 1;
        $treatment_model->update();

        // inserting the prescription errors
        $prescription_error = new PrescriptionError;
        $prescription_error->patient_id = $patient_id;
        $prescription_error->patient_dispensings_id = $dispensing_id;
        $prescription_error->type_of_error = $type_of_error;
        $prescription_error->severity_of_error = $severity_of_error;
        $prescription_error->prescriber = $prescribed_by;
        $prescription_error->pharmacist = Auth::id();
        $prescription_error->created_by = Auth::id();
        $prescription_error->comment = $comment;
        $prescription_error->save();

        flash('Treatment altered and dispensed successfully')->success();

        return redirect('patient_dispensing_receipt/' . $dispensing_id);
    }

    /* function for ward dispensing */

    public function ward_dispensing(Request $request) {
        $drugs = DB::table('drugs')->where('available', 1)->whereNull('deleted_at')->orderBy('name')->pluck('name', 'id');
        $wards = DB::table('wards')->where('available', 1)->whereNull('deleted_at')->orderBy('name')->pluck('name', 'id')->toArray();
        $wards = ['' => '- select -'] + $wards;

        $staff_array = $this->userService->pluckUserFullName();

        if (isset($request->drugs_to_dispense)) {
            $selected_drugs_array = $request->drugs_to_dispense;
            $drugs_to_dispense_collection = Drug::whereIn('id', $selected_drugs_array)->get();
            return view('pharmacy::pharmacy.ward_dispensing', compact('drugs', 'wards', 'drugs_to_dispense_collection', 'staff_array'));
        }

        return view('pharmacy::pharmacy.ward_dispensing', compact('drugs', 'wards', 'staff_array'));
    }

    // view past ward dispensing details
    public function view_ward_dispensing(Request $request){
        $wards = Ward::orderBy('name')->pluck('name', 'id')->toArray();
        $wards = ['' => '- select -'] + $wards;

        if (isset($request->ward)){
            $search_complete = true;
            $ward_id = $request->ward;
            $start_date = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::parse($request->end_date)->endOfDay()->toDateTimeString();

            $ward_dispensing = WardDispensing::where('ward_id', $ward_id)
                ->whereBetween('created_at', [$start_date, $end_date])
                ->paginate(50);

            return view('pharmacy::pharmacy.view_ward_dispensing', compact('wards', 'search_complete', 'ward_id', 'start_date', 'end_date', 'ward_dispensing'));
        } else {
            $search_complete = false;
            return view('pharmacy::pharmacy.view_ward_dispensing', compact('wards', 'search_complete'));
        }
    }

    /* view pharmacy stock sheet */

    public function stock_sheet() {
        $drugs = DB::table('drugs')->where('available', 1)->whereNull('deleted_at')->orderBy('name', 'asc')->get();

        if (count($drugs) < 1) {
            flash()->error("There is out of stock of drugs");
            return redirect('/drugs/');
        } else {
            return view('pharmacy::pharmacy.stock_sheet', compact('drugs'));
        }
    }


    /* patient dispensing receipt */
    public function patient_dispensing_receipt($dispensing_id) {
        $patient_dispensing = PatientDispensing::find($dispensing_id);
        session()->put('patient_id', $patient_dispensing->patient_id);
        $episode_id = PatientEpisode::where([['patient_id', $patient_dispensing->patient_id],['treatment_id', $patient_dispensing->treatment_id]])->first(['id']);
        $hospital_details = HospitalInformation::find(1);
        return view('pharmacy::pharmacy.patient_dispensing_receipt', compact('patient_dispensing', 'hospital_details', 'episode_id'));
    }

    /* requisition for drugs */
    public function requisition_for_drugs(Request $request) {
        $quotation_type_options = DB::table('quotation_types')->pluck('name', 'id')->toArray();
        $quotation_type_options = ['' => '- Select Requistion Type -'] + $quotation_type_options;
        $results = [];
        $item_type = 0;
        $names_array = [];
        if (isset($request->quotation_type)) {
            $item_type = $request->quotation_type; //1-drug 2-sundry 3-dental 4-radiology 5-Lab
            if ($item_type == 1) {
                $names_array = DB::table('drugs')->where('available', 1)->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Drugs', 'all_items');
            } elseif ($item_type == 2) {
                $names_array = DB::table('sundries')->where('available', 1)->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Sundries', 'all_items');
            } elseif ($item_type == 3) {
                $names_array = DB::table('dentals')->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Dentals', 'all_items');
            } elseif ($item_type == 4) {
                $names_array = DB::table('radiologies')->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Radiology Items', 'all_items');
            } elseif ($item_type == 5) {
                $names_array = DB::table('labs')->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Labs', 'all_items');
            } elseif ($item_type == 6) {
                $names_array = DB::table('general_items')->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All General Items', 'all_items');
            } elseif ($item_type == 7) {
                $names_array = DB::table('eye_glasses')->orderBy('name')->whereNull('deleted_at')->pluck('name','id')->prepend('All Optical Items', 'all_items');
            }
        }

        return view('pharmacy::pharmacy.requisition_for_drugs', compact('quotation_type_options', 'results', 'item_type','names_array'));
    }

    /* handle the search from drug requisitions */
    public function drug_requisition_search(Request $request) {
        $quotation_type_options = DB::table('quotation_types')->pluck('name', 'id')->toArray();
        $quotation_type_options = ['' => '- Select Requistion Type -'] + $quotation_type_options;
        $results = null;
        $item_type = $request->item_type;
        $item_ids_array = $request->drug_name;
        $names_array = [];
        if (isset($request->item_type)) {
            if ($item_type == 1) {
                $results = (in_array("all_items", $item_ids_array))? Drug::where('available', 1)->orderby('name', 'asc')->get() :Drug::whereIn('id', $item_ids_array)->where('available', 1)->orderBy('name','asc')->get();
                $names_array = Drug::where('available', 1)->orderby('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 2) {
                $results = (in_array("all_items", $item_ids_array))? Sundry::where('available', 1)->orderBy('name','asc')->get() :Sundry::whereIn('id', $item_ids_array)->where('available', 1)->orderBy('name','asc')->get();
                $names_array = Sundry::where('available', 1)->orderby('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 3) {
                $results = (in_array("all_items", $item_ids_array))? Dental::orderBy('name','asc')->get() :Dental::whereIn('id', $item_ids_array)->orderBy('name','asc')->get();
                $names_array = Dental::orderBy('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 4) {
                $results = (in_array("all_items", $item_ids_array))? Radiology::orderBy('name','asc')->get():Radiology::whereIn('id', $item_ids_array)->orderBy('name','asc')->get();
                $names_array = Radiology::orderBy('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 5) {
                $results = (in_array("all_items", $item_ids_array))? Lab::orderBy('name','asc')->get() : Lab::whereIn('id', $item_ids_array)->orderBy('name','asc')->get();
                $names_array = Lab::orderBy('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 6) {
                $results = (in_array("all_items", $item_ids_array))? GeneralItem::orderBy('name','asc')->get() : GeneralItem::whereIn('id', $item_ids_array)->orderBy('name','asc')->get();
                $names_array = GeneralItem::orderBy('name')->distinct()->pluck('name','id');
            } elseif ($item_type == 7) {
                $results =(in_array("all_items", $item_ids_array))? EyeGlasses::orderBy('name','asc')->get(): EyeGlasses::whereIn('id', $item_ids_array)->orderBy('name','asc')->get();
                $names_array = EyeGlasses::orderBy('name')->distinct()->pluck('name','id');
            }
        }

        return view('pharmacy::pharmacy.requisition_for_drugs', compact('quotation_type_options', 'results', 'item_type','names_array'));
    }

    /* store requisitions */

    public function store_requisition(Request $request) {
        $drug_id_array = $request->drug_id;
        $quantity_array = $request->quantity;
        $item_type = $request->item_type;
        $user_id = Auth::id();

        /* return back  if no quantity has been filled */
        if (array_sum($quantity_array) < 1) {
            flash('Please insert some values!')->error();
            return redirect()->back();
        }

        if (isset($request->save_for_later)) {
            // insert into temporary requisitions table
            $temporary_requisition = new TemporaryRequisition;
            $temporary_requisition->quotation_type_id = $item_type;
            $temporary_requisition->drug_id = implode(',', $drug_id_array);
            $temporary_requisition->quantity_requested = implode(',', $quantity_array);
            $temporary_requisition->created_by = $user_id;
            if ($temporary_requisition->save()) {
                flash('Requisition has been saved for later')->success();
                return redirect('select_temporary_requisition');
            }
            return redirect()->back();
        } elseif (isset($request->complete_request)) {
            /*
              1.insert into the requisitions table
              2.if it was a previously temporary requisition, do step 1(insert into requisitions) and update completion_status in the temporary table to 1
            */

            $filtered_drugs_array = [];
            $filtered_quantities_array = [];
            $associative_requested_drugs_array = [];
            for ($i=0; $i < count($drug_id_array) ; $i++) {
                if ($quantity_array[$i] != "") {
                    $associative_requested_drugs_array[$drug_id_array[$i]] = $quantity_array[$i];
                    $filtered_drugs_array[] = $drug_id_array[$i];
                    $filtered_quantities_array[] = $quantity_array[$i];
                }
            }
            $new_requisition = new Requisition;
            $new_requisition->quotation_type_id = $item_type;
            $new_requisition->drug_id = implode(',', $filtered_drugs_array);
            $new_requisition->quantity_requested = implode(',', $filtered_quantities_array);
            $new_requisition->created_by = $user_id;
            $new_requisition->save();

            flash('Requisition number ' . $new_requisition->id . ' made successfully')->success();
            return redirect('/print_requisition_receipt/' . $new_requisition->id);
        } elseif (isset($request->complete_previously_temporary_requisition)) {
            $temporary_requisition_model = TemporaryRequisition::find($request->temporary_requisition_id);
            $temporary_requisition_model->completion_status = 1;
            $temporary_requisition_model->updated_by = $user_id;
            $temporary_requisition_model->update();

            $requisition_model = new Requisition;
            $requisition_model->quotation_type_id = $temporary_requisition_model->quotation_type_id;
            $requisition_model->drug_id = implode(',', $drug_id_array);
            $requisition_model->quantity_requested = implode(',', $quantity_array);
            $requisition_model->created_by = $user_id;
            $requisition_model->save();

            return redirect('/print_requisition_receipt/' . $requisition_model->id);
        } elseif (isset($request->update_temporary_requisition)) {
            $temporary_requisition_model = TemporaryRequisition::find($request->temporary_requisition_id);
            $temporary_requisition_model->drug_id = implode(',', $drug_id_array);
            $temporary_requisition_model->quantity_requested = implode(',', $quantity_array);
            $temporary_requisition_model->updated_by = $user_id;
            $temporary_requisition_model->update();
            flash('Requisition updated successfully')->success();
            return redirect('previous_drug_requisitions');
        } else {
            flash('Please search for items')->error();
            return redirect()->back();
        }
    }

    /* select and view temporary requisitions */

    public function select_temporary_requisition(Request $request) {
        $quotation_type_options = DB::table('quotation_types')->pluck('name', 'id')->toArray();
        $quotation_type_options = ['' => '- Select Requisition type -'] + $quotation_type_options;
        $results = 0;
        $quotation_type = 0;
        if (isset($request->quotation_type)) {
            $quotation_type = $request->quotation_type;
            //1-drug 2-sundry 3-dental 4-radiology 5-Lab
            $results = TemporaryRequisition::where(['quotation_type_id' => $quotation_type, 'completion_status' => 0])->orderBy('id', 'desc')->get();
        }
        return view('pharmacy::pharmacy.select_temporary_requisitions', compact('quotation_type_options', 'results', 'quotation_type'));
    }

    /* edit temporary requisition */

    public function edit_temporary_requisition(Request $request) {
        $quotation_type = $request->item_type;
        $requisition_id = $request->requisition_id;
        $suppliers = DB::table('suppliers')->where('available', 1)->whereNull('deleted_at')->orderBy('name')->pluck('name', 'id')->toArray();
        $suppliers = ['' => '- select -'] + $suppliers;
        $requisition_results = TemporaryRequisition::where(['id' => $requisition_id, 'completion_status' => 0])->orderBy('id', 'desc')->get();
        //1-drug 2-sundry 3-dental 4-radiology 5-Lab
        if ($quotation_type == 1) {
            $items = Drug::where('available', 1)->orderby('name', 'asc')->get();
        } elseif ($quotation_type == 2) {
            $items = Sundry::where('available', 1)->orderby('name', 'asc')->get();
        } elseif ($quotation_type == 3) {
            $items = Dental::orderBy('name', 'asc')->get();
        } elseif ($quotation_type == 4) {
            $items = Radiology::orderBy('name', 'asc')->get();
        } elseif ($quotation_type == 5) {
            $items = Lab::orderBy('name', 'asc')->get();
        }
        return view('pharmacy::pharmacy.edit_temporary_requisition', compact('items', 'quotation_type', 'suppliers', 'requisition_id', 'requisition_results'));
    }

    /* view previous drug quotations */
    public function previous_drug_requisitions(Request $request) {

        $quotation_type_options = DB::table('quotation_types')->pluck('name', 'id')->toArray();
        $quotation_type_options = ['' => '- Select Requisition type -'] + $quotation_type_options;
        $results = [];
        $item_type = "";
        $display = "";

        if(isset($request->start_date) && isset($request->end_date)){

            if (isset($request->quotation_type)) {
                $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->toDateString();
                $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->toDateString();
                $start_date = Carbon::parse($start_date)->startOfDay()->toDateTimeString();
                $end_date = Carbon::parse($end_date)->endOfDay()->toDateTimeString();
                $results = Requisition::whereBetween('created_at',[$start_date, $end_date])->where('quotation_type_id',$request->quotation_type)->orderBy('id','desc')->get();
            }

        }
        return view('pharmacy::pharmacy.previous_requisitions', compact('quotation_type_options','results','item_type','display'));
    }

    /* edit a previous requisition */

    public function edit_previous_requisition(Request $request) {
        $requisition_id = $request->requisition_id;
        $item_type = $request->item_type;
        $results =  DB::select("SELECT * FROM requisitions where id = {$requisition_id}");
        if ($item_type == 4 ||$item_type == 5 ) {
            $results = get_requisition_all_batches($results,['store_stock','lab_stock'],['store_batches','lab_batches'],['total_store_stock','total_lab_stock'],$item_type);
        }else{
            //if source is from labs for sundries
            if ($item_type==2 && $results[0]->requisition_origin == 2){
                $results = get_all_batch_details($results,['store_stock','lab_stock'],['store_batches','lab_batches'],['total_store_stock','total_lab_stock'],$item_type);
            }
            // if source is from imaging for sundries
            elseif ($item_type==2 && $results[0]->requisition_origin == 3){
                $results = get_all_batch_details($results,['store_stock','radiology_stock'],['store_batches','imaging_batches'],['total_store_stock','total_imaging_stock'],$item_type);
            }
            else $results = get_all_batch_details($results,['store_stock','pharmacy_stock'],['store_batches','pharmacy_batches'],['total_store_stock','total_pharmacy_stock'],$item_type);
        }
        return view('pharmacy::pharmacy.edit_previous_requisition', compact('requisition_id', 'item_type', 'results'));
    }

    /* function to update edited previous requisition */
    public function update_previous_requisition(Request $request) {
        $requisition_id = $request->requisition_id;
        $quantity_requested_string = implode(',', $request->quantity_requested);
        $drugs_string = implode(',', $request->drug_id);
        $units_string = implode(',', $request->units);
        
        $requisition_model = Requisition::find(intval($requisition_id));
        if($requisition_model != null){
            //$requisition_model->drug_id = $drugs_string;
            $requisition_model->quantity_requested = $quantity_requested_string;
            if ($requisition_model->update()) {
                flash('Requisition has been updated')->success();
                return redirect('/print_requisition_receipt/' . $requisition_id);
            }
        }
        flash('Error occured while trying to update')->error();
        return redirect()->back();
    }

    /* pharmacy sundries stock sheet */
    public function sundries_stock_sheet()
    {
        $sundries = DB::table('sundries')->whereNull('deleted_at')->orderBy('name', 'asc')->get();

        if (empty($sundries)) {
            flash()->error("There is out of stock of sundries");
            return redirect('/sundries/');
        } else {
            return view('pharmacy::pharmacy.sundries_stock_sheet', compact('sundries'));
        }
    }

    /* update the sundries stock sheet */
    public function update_sundries_stock_sheet(Request $request)
    {
        $sundry_ids = $request->sundry_id;
        $quantity = $request->quantity;

        for ($x = 0; $x < count($sundry_ids); $x++):
            $sundry = Sundry::find($sundry_ids[$x]);
            $sundry->pharmacy_stock = $quantity[$x];
            $update_store_stock = $sundry->update();
        endfor;

        if ($update_store_stock):
            flash('Pharmacy Stock Levels Updated')->success();
            return redirect('pharmacy_sundries_stock_sheet');
        endif;

        flash('Sorry, unable to update stock')->error();
        return redirect()->back();
    }

    public function print_requisition_receipt($id) {
        $requisition_model = Requisition::find($id);
        $hospital_details = HospitalInformation::find(1);
        $requisition_id = $id;
        return view('pharmacy::pharmacy.requisition_receipt', compact('hospital_details', 'requisition_id', 'requisition_model'));
    }

    /* list all unconfirmed prescriptions */
    public function confirm_prescriptions(Request $request) {
        $search_text = "";
        $filters = [];

        if (isset($request->patient_id) && $request->patient_id != 0) {
            array_push($filters, ['patient_id', '=', $request->patient_id]);

            $search_text = "Showing results for " . get_full_name($request->patient_id, 'id', 'first_name', 'last_name', 'patients') . " (" . get_name($request->patient_id, 'id', 'number', 'patients') . ")";
        } elseif($request->search_by == 0){
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing prescriptions in the past 24 hours";
        } elseif($request->search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing prescriptions made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } elseif($request->search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing prescriptions made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } else {
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing prescriptions in the past 24 hours";
        }

        $unconfirmed_prescriptions = Treatment::where(['dispense_status' => 0])
            ->where(['confirmation_status' => 0])
            ->where($filters)
            ->orderBy('created_at', 'desc')
            ->get();

        $confirmed_prescriptions = Treatment::where(['dispense_status' => 0])
            ->where(['confirmation_status' => 1])
            ->where(['payment_status' => 0])
            ->where($filters)
            ->orderBy('created_at', 'desc')
            ->get();

        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");

        return view('pharmacy::pharmacy.incoming_unconfirmed_prescriptions', compact('confirmed_prescriptions','unconfirmed_prescriptions', 'categories'));
    }

    public function confirm_dispensing_details(Request $request) {
        $treatment_id = $request->treatment_id;
        $patient_id = $request->patient_id;
        $episode_id = $request->episode_id;

        $patient = Patient::where(['id' => $patient_id])->first();
        $treatment = Treatment::find($treatment_id);
        $previous_treatments = Treatment::where('patient_id',$patient_id)->where('episode_id', '!=', $episode_id)->take(5)->get();

        return view('pharmacy::pharmacy.confirm_dispensation_details', compact('patient_id', 'treatment_id', 'patient', 'treatment', 'previous_treatments'));
    }

    public function store_prescription_confirmation(Request $request) {
        $purchased_elsewhere = $request->purchased_elsewhere;

        $treatment = Treatment::find($request->treatment_id);

        $purchased_elsewhere_array = [];

        $drugs = explode(",", $treatment->drugs);

        if (!is_null($purchased_elsewhere) && count($purchased_elsewhere) > 0) {
            foreach ($drugs as $drug) {
                if (in_array($drug, $purchased_elsewhere)) {
                    $purchased_elsewhere_array[] = 1;
                } else {
                    $purchased_elsewhere_array[] = 0;
                }
            }
        } else {
            $purchased_elsewhere_array = array_fill(0, count($drugs), 0);
        }

        $treatment->confirmation_status = 1;
        $treatment->purchased_elsewhere = implode(",", $purchased_elsewhere_array);
        $treatment->update();

        flash('Treatment has been confirmed')->success();
        return redirect('confirm_prescriptions');
    }

    public function alter_dispensing_details(Request $request){
        $treatment_id = $request->treatment_id;
        $patient_id = $request->patient_id;

        if (isset($request->alter)) {
            $patient = Patient::where(['id' => $patient_id])->first();
            $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
            $marital_statuses = DB::table('marital_statuses')->pluck("name", "id");
            $drug_categories = DB::table('drug_categories')->get();
            $treatment = Treatment::find($treatment_id);
            $patient_dispensings = PatientDispensing::where(['treatment_id' => $treatment_id])->get();
            $dispensed_drugs_array = [];
            //This is to handle altering a treatment where some of the drugs have been dispensed
            if (count($patient_dispensings) > 0) {
                foreach ($patient_dispensings as $patient_dispensing) {
                    $dispensed_drugs_array_exploded = explode(",", $patient_dispensing->drugs);
                    $dispensed_drugs_array = array_merge($dispensed_drugs_array, $dispensed_drugs_array_exploded);
                }
            }
            $dosage_frequencies = DB::table('dosage_frequencies')->pluck("name", "id")->toArray();
            $drug_options = DB::table('drugs')->where('available', 1)->pluck("name", "id")->toArray();

            /* make frequencies drop down that will be used by ajax to dynamically add another prescription */
            $frequencyDropDown = '';
            $frequencyDropDown .= '<option value="" selected="selected">-- select --</option>';
            $frequencies = DosageFrequency::orderBy('name', 'asc')->get();
            foreach ($frequencies as $frequency) {
                $frequencyDropDown .= '<option value="' . $frequency->id . '">' . $frequency->name . '</option>';
            }

            /* make drugs drop down that will be used by ajax to dynamically add another prescription */
            $drugsDropDown = '';
            $drugsDropDown .= '<option value="" selected="selected">-- select --</option>';
            $drugs_drop_down = Drug::where('available', 1)->orderby('name', 'asc')->get();
            foreach ($drugs_drop_down as $drop_down) {
                if ($drop_down->insurance_coverage == 1) {
                    $drugsDropDown .= '<option value="' . $drop_down->id . '" style="color: green">' . $drop_down->name . '</option>';
                } else {
                    $drugsDropDown .= '<option value="' . $drop_down->id . '" style="color: orange">' . $drop_down->name . '</option>';
                }
            }
            $known_patient_allergies = Allergy::where('patient_id', $patient_id)->orderBy('created_at', 'desc')->take(2)->get();
            $known_patient_alerts = Alert::where('patient_id',$patient_id)->orderBy('created_at', 'desc')->take(2)->get();
            $drug_categories_array = DB::table('drug_categories')->pluck('name', 'id');
            return view('pharmacy::pharmacy.edit_dispensing_details', compact('patient_id', 'treatment_id', 'patient', 'categories', 'marital_statuses', 'drug_categories', 'treatment', 'dosage_frequencies', 'drug_options', 'frequencyDropDown', 'drugsDropDown', 'known_patient_alerts', 'known_patient_allergies','dispensed_drugs_array', 'drug_categories_array'));
        }

        $drug_ids_array = $request->drug_id;
        $quantity_to_dispense_array = $request->quantity_to_dispense;

        $dose_array = $request->dose;
        $dose_2_array = isset($request->dose2) ? $request->dose2 : [];
        $frequency_array = $request->frequency;
        $duration_array = $request->duration;
        $instructions_to_patient_array = $request->instructions;
        $prescribed_by = $request->prescribed_by;
        $to_take_away = $request->tta;
        $pharmacist = Auth::id();
        $comment = $request->comment;
        $type_of_error = [];
        isset($request->wrong_dosage) ? $type_of_error[] = "Wrong dosage" : "";
        isset($request->wrong_frequency) ? $type_of_error[] = "Wrong frequency" : "";
        isset($request->inadequate_funds) ? $type_of_error[] = "Inadequate Funds" : "";
        isset($request->other_error) ? $type_of_error[] = "Other error" : "";
        $type_of_error = implode(',', $type_of_error);
        $severity_of_error = $request->severity_of_error;
        /*
          1.reduce pharmacy_stock of that drug that's been dispensed
          2.insert into patient_dispensing
          3.insert into prescription error if there is one
          4.update treatment and set dispense status to 1 where id = treatment_id.
          5.issue patient dispensed receipt
         */

        //$dispensing_id = $patient_dispensing->id; // get the last inserted ID
        //inserting the prescription errors
        $treatment_record = Treatment::find($treatment_id);
        if (isset($request->severity_of_error) && !is_null($request->severity_of_error)) {
            $prescription_error = new PrescriptionError;
            $prescription_error->patient_id = $patient_id;
            $prescription_error->patient_dispensings_id = 0; //$dispensing_id; update the dispensing id when dispensed
            $prescription_error->type_of_error = $type_of_error;
            $prescription_error->severity_of_error = $severity_of_error;
            $prescription_error->prescriber = $prescribed_by;
            $prescription_error->pharmacist = Auth::id();
            $prescription_error->created_by = Auth::id();
            $prescription_error->comment = $comment;
            $prescription_error->episode_id = $treatment_record->episode_id;
            $prescription_error->save();

            //update the treatments table if anything has been added or subtracted
            $treatment_record->drugs = implode(",", $request->drug_id);
            $treatment_record->doses = implode(",", $request->dose);
            $treatment_record->dose2 = implode(",", $request->dose_two);
            $treatment_record->frequencies = implode(",", $request->frequency);
            $treatment_record->durations = implode(",", $request->duration);
            $treatment_record->quantities_dispensed = implode(",", $request->quantity_to_dispense);
            $treatment_record->instruction = implode(",", $request->instructions);
            $treatment_record->update();
        }

        //Updating the treatment table to show that the previous prescription was altered
        $treatment_model = Treatment::find($treatment_id);
        $treatment_model->altered = 0; //$dispensing_id; update with the dispensing id when dispensed
        $treatment_model->confirmation_status = 1;
        $update_treatment_alter = $treatment_model->update();

        flash('Treatment has been Updated')->success();
        return redirect('confirm_prescriptions');
    }

    public function check_if_prescription_had_error($patient_id, $episode_id)
    {
        $prescription_errors = PrescriptionError::where(['patient_id' => $patient_id, 'episode_id' => $episode_id])->get();
        $status = null;
        if (count($prescription_errors) > 0) {
            foreach ($prescription_errors as $error_record) {
                $status = $error_record->id;
            }
        }

        return $status;
    }

    /* ward dispensing per chart */
    public function ward_dispensing_per_chart(Request $request)
    {

        $wards = DB::table('wards')->where('available', 1)->orderBy('name')->pluck("name", "id")->toArray();
        $wards = ['0' => 'All wards'] + $wards;
        $search_by = $request->search_by;
        $drugs = Drug::where('available', 1)->orderBy('name')->pluck('name', 'id')->prepend('-- Select Drug --', '')->toArray();

        $drugs_dropdown = "";

        foreach ($drugs as $id => $name) {
            $this_drug_name = str_replace("'", '', $name);
            $this_drug_name = str_replace("\"", '', $this_drug_name);
            $drugs_dropdown .= '<option value="' . $id . '">' . $this_drug_name . '</option>';
        }

        $cancer_protocols = CancerProtocol::pluck('name', 'id');

        $search_text = 0;

        if (isset($request->patient_id) && $request->patient_id != 0) {
            $inpatients = InpatientInfo::where(['discharged' => 0])
                ->where('patient_id', $request->patient_id)
                ->orderBy('created_at', 'desc')
                ->get();

            $search_text = "Showing results for " . get_full_name($request->patient_id, 'id', 'first_name', 'last_name', 'patients') . " (" . get_name($request->patient_id, 'id', 'number', 'patients') . ")";

            $ward_id = 0;

        } elseif (isset($request->ward_id)) {
            $ward_id = $request->ward_id;
            $inpatients = [];
            $filters = [];
            $start_date = "";
            $end_date = "";

            if($request->search_by == 0){
                // last 24 hours
                $last_day = Carbon::now()->subDay();

                array_push($filters, ['created_at', '>', $last_day]);
            } elseif($request->search_by == 1){
                // custom date
                $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
                $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

                array_push($filters, ['created_at', '>', $start_date]);
                array_push($filters, ['created_at', '<', $end_date]);
            } elseif($request->search_by == 2){
                // custom date range
                $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
                $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

                array_push($filters, ['created_at', '>', $start_date]);
                array_push($filters, ['created_at', '<', $end_date]);
            } elseif($request->search_by == 3){
                //
            }

            if (!empty($ward_id) && $ward_id != 0) {
                if($request->search_by == 0){
                    $search_text = "Showing patients admitted to " . get_name($ward_id, 'id', 'name', 'wards') . "in last 24 hours";
                } else {
                    $search_text = "Showing patients admitted to " . get_name($ward_id, 'id', 'name', 'wards') . " between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
                }
                $inpatients = InpatientInfo::where(['ward_id' => $ward_id, 'discharged' => 0])->where($filters)->orderBy('created_at', 'desc')->get();
            } else {
                if($request->search_by == 0){
                    $search_text = "Showing patients admitted in the past 24 hours";
                } else {
                    $search_text = "Showing patients admitted between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
                }
                $inpatients = InpatientInfo::where(['discharged' => 0])->where($filters)->orderBy('created_at', 'desc')->get();
            }
        } else {
            $inpatients = [];
            $ward_id = 0;
        }

        return view('pharmacy::pharmacy.ward_dispensing_per_chart', compact('inpatients', 'wards', 'ward_id', 'search_by', 'drugs', 'search_text', 'drugs_dropdown', 'cancer_protocols'));
    }

    public function store_ward_dispensing_per_chart(Request $request)
    {
        //store in the ward_dipensings_per_charts table but also store in the ward_treatment_dispensations table so that they are billable on individual patient inpatient sheet/bill

        $dipensed_drugs_array = $request->dispensed_drugs ?? [];
        $quantity_dispensed_array = $request->quantity_dispensed;
        $patient_ids_array = $request->patient_id;
        $episode_ids_array = $request->episode_id;
        $inpatient_info_ids_array = $request->inpatient_info_id;
        $ward_ids_array = $request->ward_id;

        $clean_patient_id_array = [];
        $clean_episode_id_array = [];
        $clean_inpatient_info_id_array = [];
        $clean_ward_id_array = [];
        $clean_drug_id_array = [];
        $clean_quantity_given_array = [];
        $cancer_protocol_ids = [];
        $cancer_protocol_ward_charts = [];

        if (isset($request->request_comment_patient_id)) {

            // logic for the cancer protocol
            $request_comment_patient_id_arr = $request->request_comment_patient_id;
            $request_comment_episode_id_arr = $request->request_comment_episode_id;
            $request_comment_protocol_id_arr = $request->request_comment_protocol_id;
            $protocol_weight_arr = $request->protocol_weight;
            $protocol_height_arr = $request->protocol_height;
            $protocol_vitals_date_taken_arr = $request->protocol_vitals_date_taken;
            $protocol_ward_id_arr = $request->protocol_ward_id;
            $protocol_id_arr = $request->protocol_id;
            $request_comment_arr = $request->request_comment;

            for ($i = 0; $i < count($request_comment_arr); $i++) {
                $cancer_protocol_ward_charts[$request_comment_patient_id_arr[$i] . '_' . $request_comment_episode_id_arr[$i] . '_' . $request_comment_protocol_id_arr[$i]]['request_comment'] = $request_comment_arr[$i];
                $cancer_protocol_ward_charts[$request_comment_patient_id_arr[$i] . '_' . $request_comment_episode_id_arr[$i] . '_' . $request_comment_protocol_id_arr[$i]]['protocol_weight'] = $protocol_weight_arr[$i];
                $cancer_protocol_ward_charts[$request_comment_patient_id_arr[$i] . '_' . $request_comment_episode_id_arr[$i] . '_' . $request_comment_protocol_id_arr[$i]]['protocol_height'] = $protocol_height_arr[$i];
                $cancer_protocol_ward_charts[$request_comment_patient_id_arr[$i] . '_' . $request_comment_episode_id_arr[$i] . '_' . $request_comment_protocol_id_arr[$i]]['protocol_vitals_date_taken'] = $protocol_vitals_date_taken_arr[$i];
                $cancer_protocol_ward_charts[$request_comment_patient_id_arr[$i] . '_' . $request_comment_episode_id_arr[$i] . '_' . $request_comment_protocol_id_arr[$i]]['protocol_ward_id'] = $protocol_ward_id_arr[$i];
            }

            $protocol_drug_id_arr = $request->protocol_drug_id;
            $protocol_section_arr = $request->protocol_section;
            $protocol_drug_factor_arr = $request->protocol_drug_factor;
            $protocol_drug_factor_value_arr = $request->protocol_drug_factor_value;
            $protocol_drug_dose_arr = $request->protocol_drug_dose;
            $protocol_drug_dosage_label_arr = $request->protocol_drug_dosage_label;
            $protocol_drug_unit_value_arr = $request->protocol_drug_unit_value;
            $protocol_dosage_to_dispense_arr = $request->protocol_dosage_to_dispense;
            $protocol_quantity_to_dispense_arr = $request->protocol_quantity_to_dispense;
            $protocol_is_drug_selected_arr = $request->protocol_is_drug_selected;
            $protocol_instruction_arr = $request->protocol_instruction;
            $protocol_patient_id_arr = $request->protocol_patient_id;
            $protocol_episode_id_arr = $request->protocol_episode_id;

            for ($i = 0; $i < count($protocol_drug_id_arr); $i++) {
                if ($protocol_is_drug_selected_arr[$i] == 1) {
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_section"][] = $protocol_section_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_id"][] = $protocol_drug_id_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_factor"][] = $protocol_drug_factor_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_factor_value"][] = $protocol_drug_factor_value_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_dose"][] = $protocol_drug_dose_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_dosage_label"][] = $protocol_drug_dosage_label_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_drug_unit_value"][] = $protocol_drug_unit_value_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_dosage_to_dispense"][] = $protocol_dosage_to_dispense_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_quantity_to_dispense"][] = $protocol_quantity_to_dispense_arr[$i];
                    $cancer_protocol_ward_charts[$protocol_patient_id_arr[$i] . '_' . $protocol_episode_id_arr[$i] . '_' . $protocol_id_arr[$i]]["protocol_instruction"][] = $protocol_instruction_arr[$i];
                }
            }

            foreach ($cancer_protocol_ward_charts as $key => $values) {
                $exploded_key = explode("_", $key);

                if (count($values) == 5) {
                    // none of the drugs were ticked
                    continue;
                }

                $cancer_protocol_ward_chart = new CancerProtocolWardChart();
                $cancer_protocol_ward_chart->patient_id = $exploded_key[0];
                $cancer_protocol_ward_chart->episode_id = $exploded_key[1];
                $cancer_protocol_ward_chart->ward_id = $values['protocol_ward_id'];
                $cancer_protocol_ward_chart->height = $values['protocol_height'];
                $cancer_protocol_ward_chart->weight = $values['protocol_weight'];
                $cancer_protocol_ward_chart->vitals_date_taken = $values['protocol_vitals_date_taken'];
                $cancer_protocol_ward_chart->request_comment = $values['request_comment'];
                $cancer_protocol_ward_chart->protocol_id = $exploded_key[2];
                $cancer_protocol_ward_chart->protocol_drug_id = implode(',', $values['protocol_drug_id']);
                $cancer_protocol_ward_chart->protocol_section = implode(',', $values['protocol_section']);
                $cancer_protocol_ward_chart->protocol_drug_factor = implode(',', $values['protocol_drug_factor']);
                $cancer_protocol_ward_chart->protocol_drug_factor_value = implode(',', $values['protocol_drug_factor_value']);
                $cancer_protocol_ward_chart->protocol_drug_dose = implode(',', $values['protocol_drug_dose']);
                $cancer_protocol_ward_chart->protocol_drug_dosage_label = implode(',', $values['protocol_drug_dosage_label']);
                $cancer_protocol_ward_chart->protocol_drug_unit_value = implode(',', $values['protocol_drug_unit_value']);
                $cancer_protocol_ward_chart->protocol_dosage_to_dispense = implode(',', $values['protocol_dosage_to_dispense']);
                $cancer_protocol_ward_chart->protocol_quantity_to_dispense = implode(',', $values['protocol_quantity_to_dispense']);
                $cancer_protocol_ward_chart->protocol_instruction = json_encode($values['protocol_instruction']);
                $cancer_protocol_ward_chart->created_by = Auth::id();
                $cancer_protocol_ward_chart->save();

                $cancer_protocol_ids[] = $cancer_protocol_ward_chart->id;
            }
        }

        for ($i=0; $i < count($dipensed_drugs_array) ; $i++) {
            if (!is_null($dipensed_drugs_array[$i]) && !is_null($quantity_dispensed_array[$i])) {
                $clean_patient_id_array[] = $patient_ids_array[$i];
                $clean_episode_id_array[] = $episode_ids_array[$i];
                $clean_inpatient_info_id_array[] = $inpatient_info_ids_array[$i];
                $clean_ward_id_array[] = $ward_ids_array[$i];
                $clean_drug_id_array[] = $dipensed_drugs_array[$i];
                $clean_quantity_given_array[] = $quantity_dispensed_array[$i];
            }
        }

        $incoming_ward_chart = new IncomingWardChart;
        $incoming_ward_chart->patient_ids = implode(",", $clean_patient_id_array);
        $incoming_ward_chart->episode_ids = implode(",", $clean_episode_id_array);
        $incoming_ward_chart->inpatient_info_ids = implode(",", $clean_inpatient_info_id_array);
        $incoming_ward_chart->drug_ids = implode(",", $clean_drug_id_array);
        $incoming_ward_chart->quantity_given = implode(",", $clean_quantity_given_array);
        $incoming_ward_chart->ward_ids = implode(",", $clean_ward_id_array);
        $incoming_ward_chart->chart_ward_id = $request->chart_ward_id;
        $incoming_ward_chart->created_by = Auth::id();
        $incoming_ward_chart->has_cancer_protocol = (count($cancer_protocol_ids) > 0) ? implode(",", $cancer_protocol_ids) : NULL;
        $incoming_ward_chart->save();

        flash('Patient charts have been saved')->success();
        return redirect('incoming_ward_charts');
    }

    public function incoming_ward_charts(Request $request)
    {
        $ward_id = $request->ward_id;
        $filters = [];
        $start_date = null; $end_date = null;

        if($request->search_by == 0){
            // last 24 hours
            $last_day = Carbon::now()->subDay();

            $filters[] = ['created_at', '>', $last_day];
        } elseif($request->search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

            $filters[] = ['created_at', '>', $start_date];
            $filters[] = ['created_at', '<', $end_date];
        } elseif($request->search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

            $filters[] = ['created_at', '>', $start_date];
            $filters[] = ['created_at', '<', $end_date];
        }

        $search_by = $request->search_by;

        if (!empty($ward_id) && $ward_id != 0) {
            $incoming_charts = IncomingWardChart::where(['chart_ward_id' => $ward_id, 'completion_status' => 0])->where($filters)->get();
        } else {
            $incoming_charts = IncomingWardChart::where(['completion_status' => 0])->where($filters)->get();
        }

        $staff_array = $this->userService->pluckUserFullName();

        $wards = DB::table('wards')->where('available', 1)->orderBy('name')->pluck("name", "id")->toArray();
        $wards = ['0' => 'All wards'] + $wards;
        return view('pharmacy::pharmacy.incoming_ward_chart',compact('staff_array', 'wards', 'ward_id', 'search_by','start_date','end_date', 'incoming_charts'));
    }

    public function approve_ward_dispensing_per_chart($incoming_ward_chart_id)
    {
        $search_by = null;
        $cancer_protocol_orders = false;

        $incoming_chart_record = IncomingWardChart::find($incoming_ward_chart_id);
        $ward_id = $incoming_chart_record->chart_ward_id;

        if (!is_null($incoming_chart_record)) {
            $drug_ids_array = explode(",", $incoming_chart_record->drug_ids);
            $quantity_given_array = explode(",", $incoming_chart_record->quantity_given);

            if (!is_null($incoming_chart_record->has_cancer_protocol)) {
                $cancer_protocol_ids = explode(",", $incoming_chart_record->has_cancer_protocol);

                $cancer_protocol_orders = CancerProtocolWardChart::whereIn('id', $cancer_protocol_ids)->get();
            }
        }

        $drugs_to_dispense_array = [];
        $quantities_to_dispense_array = [];
        for ($i = 0; $i < count($drug_ids_array); $i++) {
            // check if a drug id already exists in the drugs array
            if (in_array($drug_ids_array[$i], $drugs_to_dispense_array)) {
                //get key of that drug which exists
                $key = array_search($drug_ids_array[$i], $drugs_to_dispense_array);
                //increment the "to_dispense_qty" value of drug
                $quantities_to_dispense_array[$key] += $quantity_given_array[$i];
            } else {
                //drugs does not exist, create new entry
                $drugs_to_dispense_array[] = $drug_ids_array[$i];
                $quantities_to_dispense_array[] = $quantity_given_array[$i];
            }
        }

        $wards = DB::table('wards')->where('available', 1)->orderBy('name')->pluck("name", "id")->toArray();
        $wards = ['0' => 'All wards'] + $wards;
        $drugs = DB::table('drugs')->whereNull('deleted_at')->where('available', 1)->pluck('name', 'id')->toArray();
        $staff_array = $this->userService->pluckUserFullName();
        $drug_forms = DB::table('drug_forms')->whereNull('deleted_at')->pluck('name', 'id')->toArray();

        $batches_array = DB::table('item_batch_watcher')->where('pharmacy_stock', '>', 0)->orWhere('store_stock', '>', 0)->get();

        return view('pharmacy::pharmacy.approve_ward_dispensing_per_chart',compact('drug_forms','staff_array', 'wards', 'ward_id', 'search_by', 'drugs', 'drugs_to_dispense_array', 'quantities_to_dispense_array', 'incoming_chart_record', 'batches_array', 'cancer_protocol_orders'));
    }

    public function cancel_ward_dispensing_per_chart($incoming_ward_chart_id)
    {
        $incoming_chart_record = IncomingWardChart::find($incoming_ward_chart_id);

        if ($incoming_chart_record) {
            if (!is_null($incoming_chart_record->has_cancer_protocol)) {
                $cancer_protocol_ids = explode(",", $incoming_chart_record->has_cancer_protocol);
                $delete_cancer_protocol_orders = CancerProtocolWardChart::whereIn('id', $cancer_protocol_ids)->delete();
            }

            $incoming_chart_record->delete();
            flash("Ward chart deleted successfully")->success();
        } else {
            flash("Could not cancel ward chart")->error();
        }

        return redirect('incoming_ward_charts');
    }

    public function store_approved_dispensings_per_chart(Request $request) {
        /*
        *update the completion_status to 1 in ward_dispensation_per_chart table
        *record the records in the ward treatment dispensations table, created_by shd be equal to received_by
        *store details in the ward_chart_approvals table and update the records with the approval_id
        */
        
        $protocol_drug_ids_arr =$batch_id= [];
       
       

        if (isset($request->protocol_ward_charts_id)) {
            $protocol_ward_charts_id_arr = $request->protocol_ward_charts_id;

            $protocol_ward_id_arr = $request->protocol_ward_id;
            $protocol_patient_id_arr = $request->protocol_patient_id;
            $protocol_episode_id_arr = $request->protocol_episode_id;
            $protocol_quantity_to_dispense_arr = $request->protocol_quantity_to_dispense;
            $protocol_instruction_arr = $request->protocol_instruction;
            $protocol_drug_ids_arr = $request->protocol_drug_ids;

            $protocol_orders = CancerProtocolWardChart::whereIn('id', $protocol_ward_charts_id_arr)->get();

            if (count($protocol_orders) > 0) {
                 // check if the drug is consuming from more than one batch 
                 foreach ($request->cancer_batch_item_ids as $key => $id ){
                    $batch_id[$id][] = $request->cancer_batch_dispensed_from[$key];
                }
                foreach ($protocol_orders as $protocol_order) {
                    $protocol_order->approved_by = Auth::id();
                    $protocol_order->completion_status = 1;
                    $protocol_order->update();
                }

                /* create a new entry for the approval that has been done */
                $chart_approval = new WardChartApproval;
                $chart_approval->drug_ids = implode(",", $protocol_drug_ids_arr);
                $chart_approval->quantity_dispensed = implode(",", $protocol_quantity_to_dispense_arr);
                $chart_approval->comments = implode(",", $protocol_instruction_arr);
                $chart_approval->received_by = $request->received_by;
                $chart_approval->approval_date = is_null($request->approval_date) ? Carbon::now() : Carbon::createFromFormat('d/m/Y',$request->approval_date)->toDateString();
                $chart_approval->incoming_ward_charts_id = $request->incoming_chart_id;
                $chart_approval->cancer_protocol_order_id = implode(",", $protocol_ward_charts_id_arr);
                $chart_approval->created_by = Auth::id();
                $chart_approval->ward_id = $protocol_ward_id_arr[0] ?? 0;
                $chart_approval->save();

                // Loop through each entry and group by drug ID
                foreach ($protocol_drug_ids_arr as $index => $drugId) {
                    $patientId = $protocol_patient_id_arr[$index];
                    $quantity = $protocol_quantity_to_dispense_arr[$index];   
                    $esp = $protocol_episode_id_arr[$index];                 
                    // Initialize the drug group if not already created
                    if (!isset($groupedData[$drugId])) {
                        $groupedData[$drugId] = [];
                    }
                    // Append the patient and quantity data
                    $groupedData[$drugId][] = [
                        'patient_id' => $patientId,
                        'episode_id'=>$esp,
                        'quantity' => $quantity,
                        'batch_id' => null,
                    ];
                }
                foreach($batch_id as $ind => $batch){
                    foreach ($batch as $key => $value) {
                        foreach($groupedData[$ind] as $key => $data){
                            $groupedData[$ind][$key]['batch_id'][] = $value;
                        }
                    }
                  
                }
                foreach($groupedData as $ind => $data){
                    foreach($data as $d){
                        WardTreatmentBatchDispensation::create([
                            "patient_id"=>$d['patient_id'],
                            "episode_id"=>$d['episode_id'],
                            "item_id"=>$ind,
                            "incoming_ward_chart_id"=>$request->incoming_chart_id,
                            "item_batch_id"=>implode(",", $d['batch_id']??[]),
                        ]);
                    }
                }
                /* update the ward_treatment_dispensations table to show the drugs on the respective inpatient sheet */
                for ($i=0; $i < count($protocol_patient_id_arr) ; $i++) {
                    $ward_treatment_id = $this->dispensationService->saveDispensation((int)$protocol_patient_id_arr[$i], (int)$protocol_episode_id_arr[$i],
                        $protocol_drug_ids_arr[$i], (int)$protocol_quantity_to_dispense_arr[$i], 0, $protocol_ward_id_arr[$i] ?? 0, $request->incoming_chart_id);

                    /*====== reduce the pharmacy stock if some quantity has been given.========*/
                    if ($protocol_quantity_to_dispense_arr[$i] > 0) {
                        $ward_drug_details = Drug::find($protocol_drug_ids_arr[$i]);
                        $current_stock = $ward_drug_details->pharmacy_stock;
                        $new_stock = $current_stock - $protocol_quantity_to_dispense_arr[$i];
                        $ward_drug_details->pharmacy_stock = $new_stock;
                        $ward_drug_details->update();
                    }
                }

                /* ==== reduction according to batches selected ==== */
                $cancer_batch_item_ids_array = $request->cancer_batch_item_ids ?? [];
                $cancer_items_batches_array = $request->cancer_batch_dispensed_from ?? [];
                $cancer_items_quantities_array = $request->cancer_batch_quantity_dispensed ?? [];

                for ($i=0; $i < count($cancer_batch_item_ids_array) ; $i++) {
                    reduce_batch_item_stock(1,$cancer_batch_item_ids_array[$i],$cancer_items_batches_array[$i],'drugs','pharmacy_stock',$cancer_items_quantities_array[$i],'incoming_ward_charts','Drug',$request->incoming_chart_id,null);

                    // reduce_batch_item_from_pharmacy(1, $cancer_batch_item_ids_array[$i], $cancer_items_batches_array[$i], $cancer_items_quantities_array[$i], "incoming_ward_charts", $request->incoming_chart_id, null);
                }
                /* ==== end of batch === */
            }
        }

        $incoming_chart_to_update = IncomingWardChart::find($request->incoming_chart_id);
        if ($incoming_chart_to_update) {
            $incoming_chart_to_update->approved_by = Auth::id();
            $incoming_chart_to_update->completion_status = 1;
            $incoming_chart_to_update->update();
            
            // check if there are normal drugs to process
            if (isset($request->drug_id) && is_array($request->drug_id)) {
                 // check if the drug is consuming from more than one batch 
                    foreach ($request->batch_item_ids as $key => $id ){
                        $batch_id[$id][] = $request->batch_dispensed_from[$key];
                    }
                    /* get some patient details from the incoming_ward_charts table*/

                $patient_ids_array = explode(",", $incoming_chart_to_update->patient_ids);
                $episode_ids_array = explode(",", $incoming_chart_to_update->episode_ids);
                $drug_ids_array = explode(",", $incoming_chart_to_update->drug_ids);
                $quantities_given_array = explode(",", $incoming_chart_to_update->quantity_given);
                $wards_array = explode(",", $incoming_chart_to_update->ward_ids);
                /* create a new entry for the approval that has been done */
                $chart_approval = new WardChartApproval;
                $chart_approval->drug_ids = implode(",", $request->drug_id);
                $chart_approval->quantity_dispensed = implode(",", $request->quantity_dispensed);
                $chart_approval->comments = implode(",", $request->comments);
                $chart_approval->received_by = $request->received_by;
                $chart_approval->approval_date = is_null($request->approval_date) ? Carbon::now() : Carbon::createFromFormat('d/m/Y',$request->approval_date)->toDateString();
                $chart_approval->incoming_ward_charts_id = $request->incoming_chart_id;
                $chart_approval->created_by = Auth::id();
                $chart_approval->ward_id = is_null($incoming_chart_to_update) ? 0 : $incoming_chart_to_update->chart_ward_id;
                $chart_approval->save();
                $groupedData = [];

                // Loop through each entry and group by drug ID
                foreach ($drug_ids_array as $index => $drugId) {
                    $patientId = $patient_ids_array[$index];
                    $quantity = $quantities_given_array[$index];   
                    $esp = $episode_ids_array[$index];                 
                    // Initialize the drug group if not already created
                    if (!isset($groupedData[$drugId])) {
                        $groupedData[$drugId] = [];
                    }
                    // Append the patient and quantity data
                    $groupedData[$drugId][] = [
                        'patient_id' => $patientId,
                        'episode_id'=>$esp,
                        'quantity' => $quantity,
                        'batch_id' => null,
                    ];
                }
                foreach($batch_id as $ind => $batch){
                    foreach ($batch as $key => $value) {
                        foreach($groupedData[$ind] as $key => $data){
                            $groupedData[$ind][$key]['batch_id'][] = $value;
                        }
                    }
                  
                }
                foreach($groupedData as $ind => $data){
                    foreach($data as $d){
                        WardTreatmentBatchDispensation::create([
                            "patient_id"=>$d['patient_id'],
                            "episode_id"=>$d['episode_id'],
                            "item_id"=>$ind,
                            "incoming_ward_chart_id"=>$incoming_chart_to_update->id,
                            "item_batch_id"=>implode(",", $d['batch_id']??[]),
                        ]);
                    }
                }
                /* update the ward_treatment_dispensations table to show the drugs on the respective inpatient sheet */
                for ($i=0; $i < count($patient_ids_array) ; $i++) {
                    $ward_treatment_id = $this->dispensationService->saveDispensation((int)$patient_ids_array[$i], (int)$episode_ids_array[$i],
                        $drug_ids_array[$i], (int)$quantities_given_array[$i], 0, $wards_array[$i] ?? 0, $incoming_chart_to_update->id);

                    /*====== reduce the pharmacy stock if some quantity has been given.========*/
                    if ($drug_ids_array[$i] != "" && $quantities_given_array[$i] != "") {
                        $drug = Drug::find($drug_ids_array[$i]);
                        if ($drug) {
                            $current_stock = $drug->pharmacy_stock;
                            $new_stock = $current_stock - $quantities_given_array[$i];
                            $drug->pharmacy_stock = $new_stock;
                            $drug->update();
                        }
                    }
                }

                /* ==== reduction according to batches selected ==== */
                $items_ids_array = $request->batch_item_ids ?? [];
                $items_batches_array = $request->batch_dispensed_from ?? [];
                $items_quantities_array = $request->batch_quantity_dispensed ?? [];

                for ($i=0; $i < count($items_batches_array) ; $i++) {
                    reduce_batch_item_stock(1,$items_ids_array[$i],$items_batches_array[$i],'drugs','pharmacy_stock',$items_quantities_array[$i],'incoming_ward_charts','Drug',$request->incoming_chart_id,null);
                    // reduce_batch_item_from_pharmacy(1, $items_ids_array[$i], $items_batches_array[$i], $items_quantities_array[$i], "incoming_ward_charts", $request->incoming_chart_id, null);
                }
                /* ==== end of batch === */
            }

            flash("Ward chart has been approved")->success();

            if (count($protocol_drug_ids_arr) > 0) {
                session()->put('request_array', $request->all());
                return redirect('print_protocol_ward_chart');
            }
            return redirect('incoming_ward_charts');
        } else {
            flash("Ward Chart not found")->error();
            return redirect()->back()->withInput();
        }
    }

    /* put patient_id and episode_id in session. Done when one clicks the "view inpatient sheet" on ward_dispensing page */
    public function set_inpatient_sheet($patient_id, $episode_id)
    {
        session()->put('patient_id', $patient_id);
        session()->put('episode_id', $episode_id);

        return redirect('in_patient_sheet');
    }

    public function drug_chart_details(Request $request)
    {
        $drug_id = $request->drug_id;
        $incoming_chart_id = $request->chart_id;

        $incoming_chart_record = IncomingWardChart::find($incoming_chart_id);

        if (!is_null($incoming_chart_record)) {
            $patient_ids_array = explode(",", $incoming_chart_record->patient_ids);
            $episode_ids_array = explode(",", $incoming_chart_record->episode_ids);
            $inpatient_info_ids_array = explode(",", $incoming_chart_record->inpatient_info_ids);
            $drug_ids_array = explode(",", $incoming_chart_record->drug_ids);
            $ward_ids_array = explode(",", $incoming_chart_record->ward_ids);
            $quantity_given_array = explode(",", $incoming_chart_record->quantity_given);
        }

        $code = "";
        $counter = 1;

        for ($i=0; $i < count($drug_ids_array) ; $i++) {
            if ($drug_ids_array[$i] == $drug_id) {
                $code .= "<tr>";
                $code .= "<td>";
                $code .= $counter;
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_full_name($patient_ids_array[$i], 'id', 'first_name', 'last_name', 'patients') . " (" . get_name($patient_ids_array[$i], 'id', 'number', 'patients') . ")";
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_name($ward_ids_array[$i], 'id', 'name', 'wards');
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_name($drug_ids_array[$i], 'id', 'name', 'drugs');
                $code .= "</td>";
                $code .= "<td>";
                $code .= $quantity_given_array[$i];
                $code .= "</td>";
                $code .= "</tr>";
                $counter++;
            }
        }

        /*if ($ward_dipensings_per_chart->count() > 0){
            foreach ($ward_dipensings_per_chart as $record){
                $code .= "<tr>";
                $code .= "<td>";
                $code .= $counter;
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_full_name($record->patient_id, 'id', 'first_name', 'last_name', 'patients') . " (" . get_name($record->patient_id, 'id', 'number', 'patients') . ")";
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_name($record->ward_id, 'id', 'name', 'wards');
                $code .= "</td>";
                $code .= "<td>";
                $code .= get_name($record->drug_id, 'id', 'name', 'drugs');
                $code .= "</td>";
                $code .= "<td>";
                $code .= $record->quantity_given;
                $code .= "</td>";
                $code .= "</tr>";
                $counter++;
            }
        } else {
            $code .= "<tr><td colspan='4'><h4 class='text-center'>No records</h4></td></tr>";
        }*/

        // check if the code is empty for when clinics selected are not available
        if ($code == ''){
            $code .= "<tr><td colspan='4'><h4 class='text-center'>No record</h4></td></tr>";
        }

        return $code;
    }

    public function view_ward_patient_prescriptions(Request $request)
    {
        $patient_id = $request->patient_id;
        $episode_id = $request->episode_id;

        $ward_prescriptions = WardTreatment::where(['patient_id' => $patient_id, 'episode_id' => $episode_id])->get();

        $code = "";

        if(count($ward_prescriptions) > 0){
            foreach($ward_prescriptions as $treatment){
                $drug_explode = explode(",", $treatment->drugs);
                $dose_explode = explode(",", $treatment->doses);
                $dose2_explode = explode(",", $treatment->dose2);
                $drug_frequency_explode = explode(",", $treatment->frequencies);
                $instruction_explode = explode(",", $treatment->instruction);
                $duration_explode = explode(",", $treatment->durations);
                //$long_term_explode = explode(",", $treatment_row['Long_Term']);
                $dispense_explode = explode(",", $treatment->dispensed);
                //$form_explode = explode(",", $treatment_row['Form']);
                $quantity_to_dispense = explode(",", $treatment->quantities_dispensed);

                for ($x = 0; $x < count($drug_explode); $x++){
                    $code .= "<tr>";
                    $code .= "<td>";
                    $code .= $x+1;
                    $code .= "</td>";
                    $code .= "<td>";
                    if(get_name($drug_explode[$x], 'id', 'insurance_coverage', 'drugs') == 1){
                        $code .= "<span style='color: green'>".get_name($drug_explode[$x], 'id', 'name', 'drugs')."</span>";
                    } else{
                        $code .= "<span style='color: orange'>".get_name($drug_explode[$x], 'id', 'name', 'drugs')."</span>";
                    }
                    $code .= "</td>";
                    $code .= "<td>";

                    $form_id = isset($drug_explode[$x]) ? get_name($drug_explode[$x], 'id', 'form_id', 'drugs') : "";
                    $unit_id = isset($drug_explode[$x]) ? get_name($drug_explode[$x], 'id', 'unit_id', 'drugs') : "";
                    $form_name = isset($form_id) ? get_name($form_id, 'id', 'name', 'drug_forms') : "";
                    $unit_name = isset($unit_id) ? get_name($unit_id, 'id', 'name', 'drug_units') : "";

                    $code .= isset($dose_explode[$x]) ? $dose_explode[$x] : "" . $unit_name;
                    $code .= "</td>";
                    $code .= "<td>";
                    $code .= get_name( isset($drug_frequency_explode[$x]) ? $drug_frequency_explode[$x] : "", 'id', 'name', 'dosage_frequencies');
                    $code .= "</td>";
                    $code .= "<td>";
                    $code .= isset($duration_explode[$x]) ? $duration_explode[$x] : "";
                    $code .= "</td>";
                    $code .= "<td>";
                    $code .= isset($quantity_to_dispense[$x]) ? $quantity_to_dispense[$x] : "";
                    $code .= "</td>";
                    $code .= "<td>";
                    $code .= isset($instruction_explode[$x]) ? $instruction_explode[$x] : "";
                    $code .= "</td>";
                    $code .= "</tr>";
                }
                $code .= "<tr><td colspan='8'><strong>Prescribed by <font color='blue'>".get_full_name($treatment->created_by, "id", "first_name", "last_name", "users")."</font> on <font color='blue'>".streamline_date($treatment->created_at)."</font></strong></td></tr>";
            }
        } else {
            $code .= "<tr><td colspan='8'><h4>No prescriptions recorded in the system</h4></td></tr>";
        }

        return $code;
    }

    public function edit_ward_dispensing_chart(Request $request, $id)
    {
        $incoming_chart = IncomingWardChart::find($id);
        $patient_ass_array = []; //holding the associative array we will loop through
        $patient_episodes_array = [];
        $patient_inpatient_info_array = [];

        if (!is_null($incoming_chart)) {
            $patient_ids_array = explode(",", $incoming_chart->patient_ids);
            $episode_ids_array = explode(",", $incoming_chart->episode_ids);
            $inpatient_info_ids_array = explode(",", $incoming_chart->inpatient_info_ids);
            $drug_ids_array = explode(",", $incoming_chart->drug_ids);
            $quantity_given_array = explode(",", $incoming_chart->quantity_given);

            for ($i=0; $i < count($patient_ids_array) ; $i++) {
                $inner_array = [];
                if (array_key_exists($patient_ids_array[$i], $patient_ass_array)) {
                    /* check just in case the same drug appears for the same patient twice then ++ quantity */
                    if (array_key_exists($drug_ids_array[$i], $patient_ass_array[$patient_ids_array[$i]])) {
                        $previous_qty = $patient_ass_array[$patient_ids_array[$i]][$drug_ids_array[$i]];
                        $patient_ass_array[$patient_ids_array[$i]][$drug_ids_array[$i]] = $previous_qty + $quantity_given_array[$i];
                    } else{
                        $patient_ass_array[$patient_ids_array[$i]][$drug_ids_array[$i]] = $quantity_given_array[$i];
                    }
                } else{
                    $inner_array[$drug_ids_array[$i]] = $quantity_given_array[$i];
                    $patient_ass_array[$patient_ids_array[$i]] = $inner_array;
                }

                //we need these 2 array below
                $patient_episodes_array[$patient_ids_array[$i]] = $episode_ids_array[$i];
                $patient_inpatient_info_array[$patient_ids_array[$i]] = $inpatient_info_ids_array[$i];
            }
        }

        $drugs = Drug::where('available', 1)->orderby('name')->pluck('name', 'id')->prepend('-- Select Drug --', '')->toArray();

        return view('pharmacy::pharmacy.edit_ward_chart', compact('drugs', 'incoming_chart', 'patient_ass_array', 'patient_episodes_array', 'patient_inpatient_info_array'));
    }

    public function update_ward_dispensing_per_chart(Request $request)
    {
        $incoming_chart_to_update = IncomingWardChart::find($request->incoming_chart_id);

        $dipensed_drugs_array = $request->dispensed_drugs;
        $quantity_dispensed_array = $request->quantity_dispensed;
        $patient_ids_array = $request->patient_id;
        $episode_ids_array = $request->episode_id;
        $inpatient_info_ids_array = $request->inpatient_info_id;
        $ward_ids_array = $request->ward_id;
        $chart_ward_id = $request->chart_ward_id; //if it is 0, then it is a chart from all wards

        $clean_patient_id_array = [];
        $clean_episode_id_array = [];
        $clean_inpatient_info_id_array = [];
        $clean_ward_id_array = [];
        $clean_drug_id_array = [];
        $clean_quantity_given_array = [];

        for ($i=0; $i < count($dipensed_drugs_array) ; $i++) {
            if (!is_null($dipensed_drugs_array[$i]) && !is_null($quantity_dispensed_array[$i])) {
                $clean_patient_id_array[] = $patient_ids_array[$i];
                $clean_episode_id_array[] = $episode_ids_array[$i];
                $clean_inpatient_info_id_array[] = $inpatient_info_ids_array[$i];
                $clean_ward_id_array[] = $ward_ids_array[$i];
                $clean_drug_id_array[] = $dipensed_drugs_array[$i];
                $clean_quantity_given_array[] = $quantity_dispensed_array[$i];
            }
        }

        $incoming_chart_to_update->patient_ids = implode(",", $clean_patient_id_array);
        $incoming_chart_to_update->episode_ids = implode(",", $clean_episode_id_array);
        $incoming_chart_to_update->inpatient_info_ids = implode(",", $clean_inpatient_info_id_array);
        $incoming_chart_to_update->drug_ids = implode(",", $clean_drug_id_array);
        $incoming_chart_to_update->quantity_given = implode(",", $clean_quantity_given_array);
        $incoming_chart_to_update->ward_ids = implode(",", $clean_ward_id_array);
        $incoming_chart_to_update->chart_ward_id = $request->chart_ward_id;
        $incoming_chart_to_update->updated_by = Auth::id();
        $incoming_chart_to_update->update();

        flash('Patient charts have been updated')->success();
        return redirect('incoming_ward_charts');
    }

    public function return_drugs_per_chart(Request $request) {
        $wards = DB::table('wards')->where('available', 1)->orderBy('name')->pluck("name", "id")->toArray();
        $wards = ['0' => 'All wards'] + $wards;
        $filters = [];
        if (isset($request->patient_id) && $request->patient_id != 0) {
            $filters[] = ['patient_id', '=', $request->patient_id];
        }
        //get all inpatients that are not discharged 
        $ipatients = InpatientInfo::where(['discharged' => 0])->orderBy('created_at', 'desc')->get();
        foreach($ipatients as $patient){
            $patients[]= Patient::find($patient->patient_id);
        }
        if (isset($request->ward_id)) {
            $ward_id = $request->ward_id;
            $drugs = Drug::where('available', 1)->orderby('name')->pluck('name', 'id')->prepend('-- Select Drug --', '')->toArray();

            if($request->search_by == 0){
                // last 24 hours
                $last_day = Carbon::now()->subDay();

                array_push($filters, ['created_at', '>', $last_day]);
            } elseif($request->search_by == 1){
                // custom date
                $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
                $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

                array_push($filters, ['created_at', '>', $start_date]);
                array_push($filters, ['created_at', '<', $end_date]);
            } elseif($request->search_by == 2){
                // custom date range
                $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
                $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

                array_push($filters, ['created_at', '>', $start_date]);
                array_push($filters, ['created_at', '<', $end_date]);
            } elseif($request->search_by == 3){
                //
            }

            $search_by = $request->search_by;

            if (!empty($ward_id) && $ward_id != 0) {
                $inpatients = InpatientInfo::where(['ward_id' => $ward_id, 'discharged' => 0])->where($filters)->orderBy('created_at', 'desc')->get();
            } else {
                $inpatients = InpatientInfo::where(['discharged' => 0])->where($filters)->orderBy('created_at', 'desc')->get();
            }
            foreach($inpatients as $patient){
                $patient->ward_treatment =WardTreatmentDispensation::where(['patient_id' => $patient->patient_id, 'episode_id' => $patient->episode_id])->get();
                $batches_items =WardTreatmentBatchDispensation::where(['patient_id' => $patient->patient_id, 'episode_id' => $patient->episode_id])->get();
                if (count($batches_items) > 0) {
                    $batch_id_records=[];
                    foreach ($batches_items as $batches) {
                        $batch_id_records[] = ($batches->item_batch_id!=null)? explode(',',$batches->item_batch_id):[];
                    }
                    //check the count of ward_treatment 
                    if (count($patient->ward_treatment) > count($batch_id_records)){
                        //add the difference to as the start of the array 
                        for ($i=count($batch_id_records); $i < count($patient->ward_treatment); $i++) {
                            array_unshift($batch_id_records, []);
                        }
                    }
                    $patient->batch_items = $batch_id_records;
                }else{
                    $patient->batch_items = [];
                }
            }
        } else {
            $inpatients = [];
            $drugs = [];
            $search_by = "";
            $ward_id = 0;
            // $patients=[];
        }
        return view('pharmacy::pharmacy.return_drugs_per_chart', compact('inpatients','patients', 'wards', 'ward_id', 'search_by', 'drugs'));
    }


    public function store_returned_drugs_per_chart(Request $request) {
        $drug_ids_array = $request->drug_id;
        $ward_treatment_dispensations_id_array = $request->ward_treatment_dispensations_id;
        $quantity_dispensed_array = $request->quantity_dispensed;
        $quantity_to_return_array = $request->quantity_to_return;
        $patient_ids_array = $request->patient_id;
        $episode_ids_array = $request->episode_id;
        $inpatient_info_ids_array = $request->inpatient_info_id;
        $selected_batch_id_array = $request->batch_id;
        $batch_id_array = $request->ward_treatment_batch_id;
        for ($i = 0; $i < count($drug_ids_array); $i++) {
            if (!isset($quantity_to_return_array[$i]) || !isset($quantity_dispensed_array[$i]) || !isset($ward_treatment_dispensations_id_array[$i])) { continue; }

            if ($quantity_to_return_array[$i] > 0 && !($quantity_dispensed_array[$i] < $quantity_to_return_array[$i])) {
                $difference_in_drugs = $quantity_dispensed_array[$i] - $quantity_to_return_array[$i];
                $returned_drugs = new ReturnedDrugsPerWardChart;
                $returned_drugs->ward_treatment_dispensation_id = $ward_treatment_dispensations_id_array[$i];
                $returned_drugs->quantity_before = $quantity_dispensed_array[$i];
                $returned_drugs->quantity_returned = $quantity_to_return_array[$i];
                $returned_drugs->created_by = Auth::id();
                $returned_drugs->save();

                $ward_treatments_dispensation = WardTreatmentDispensation::find($ward_treatment_dispensations_id_array[$i]);
                $ward_treatments_dispensation->quantity_given = $difference_in_drugs;
                $ward_treatments_dispensation->save();
                //check if selected batch id is 
                if (isset($request->batch_id)){$selected_batch_id= $selected_batch_id_array[$i];}else{$selected_batch_id=null;}
                $drug = Drug::find($drug_ids_array[$i]);
                if ($drug) {
                    $drug->pharmacy_stock = $drug->pharmacy_stock + $quantity_to_return_array[$i];
                    $drug->update();
                    //return quantity to batch
                    $this->itemService->returnStockToAnySection($item_type=1,$drug_ids_array[$i],$ward_treatments_dispensation,$patient_ids_array[$i],$episode_ids_array[$i], $quantity_to_return_array[$i],'pharmacy_stock',$selected_batch_id);
                }
            }
        }

        flash("Drugs have been returned from ward per chart")->success();
        return redirect('return_drugs_per_chart');
    }

    public function ward_dispensing_per_chart_report(Request $request)
    {
        $ward_id = $request->ward_id;
        $filters = [];

        if($request->search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);
        } elseif($request->search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);
        } else {
            // last 24 hours
            $last_day = Carbon::now()->subDay();

            array_push($filters, ['created_at', '>', $last_day]);
        }

        $search_by = $request->search_by;

        if (!empty($ward_id) && $ward_id != 0) {
            $ward_chart_approvals = WardChartApproval::where(['ward_id' => $ward_id])->where($filters)->orderBy('created_at', 'desc')->get();
        } else {
            $ward_chart_approvals = WardChartApproval::where($filters)->orderBy('created_at', 'desc')->get();
        }

        $staff_array = $this->userService->pluckUserFullName();
        $wards = DB::table('wards')->where('available', 1)->orderBy('name')->pluck("name", "id")->toArray();
        $wards = ['0' => 'All wards'] + $wards;

        return view('pharmacy::pharmacy.ward_dispensing_per_chart_report', compact('ward_chart_approvals', 'wards', 'staff_array', 'ward_id', 'search_by'));
    }

    public function ward_chart_report_details(Request $request): View
    {
        $chart_approval_record = WardChartApproval::find($request->approval_id);

        return view('pharmacy::pharmacy.ward_chart_report_details', compact('chart_approval_record'));
    }

    public function print_ward_chart_report_details($approval_id): RedirectResponse
    {
        $chart_record = WardChartApproval::find($approval_id);

        if (!$chart_record || is_null($chart_record->cancer_protocol_order_id)) {
            return redirect()->back();
        }

        $cancer_records = CancerProtocolWardChart::whereIn('id', explode(",", $chart_record->cancer_protocol_order_id))
            ->get();

        if (count($cancer_records) === 0) {
            return redirect()->back();
        }

        $request_array = ["protocol_instruction" => explode(",", $chart_record->comments)];

        foreach ($cancer_records as $cancer_record) {
            $protocol_drug_ids = explode(",", $cancer_record->protocol_drug_id);
            $request_array = array_merge_recursive(
                $request_array,
                [
                    "protocol_ward_id" => array_fill(0, count($protocol_drug_ids), $cancer_record->ward_id),
                    "protocol_patient_id" => array_fill(0, count($protocol_drug_ids), $cancer_record->patient_id),
                    "protocol_episode_id" => array_fill(0, count($protocol_drug_ids), $cancer_record->episode_id),
                    "protocol_drug_dose" => explode(",", $cancer_record->protocol_drug_dose),
                    "protocol_dosage_to_dispense" => explode(",", $cancer_record->protocol_dosage_to_dispense),
                    "protocol_quantity_to_dispense" => explode(",", $cancer_record->protocol_quantity_to_dispense),
                    "protocol_drug_ids" => $protocol_drug_ids,
                    "protocol_drug_dose_label" => explode(",", $cancer_record->protocol_drug_dosage_label),
                ]
            );
        }

        session()->put('request_array', $request_array);
        return redirect('print_protocol_ward_chart');
    }

    public function drugs_stock_reconciliation(Request $request) {
        $drugs = [];
        $item_ids_array = $request->search_items_ids;

        if ($item_ids_array) {
            $is_all_items = in_array("all_items", $item_ids_array);

            if ($is_all_items) {
                $drugs = Drug::where('available', 1)->orderby('name', 'asc')->get();
            } else{
                $drugs = Drug::whereIn('id', $item_ids_array)->orderBy('name', 'asc')->get();
            }
        }

        $chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')->pluck('name', 'id')->toArray();
        $chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;

        $drugs_dropdown = DB::table('drugs')->where('available', 1)->whereNull('deleted_at')->orderBy('name', 'asc')->pluck('name','id')->prepend('All drugs', 'all_items')->toArray();

        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();

        return view('pharmacy::pharmacy.drugs_stock_reconciliation', compact('drugs', 'chart_of_accounts', 'drugs_dropdown', 'stock_adjustment_chart_of_account'));
    }

    public function store_pharmacy_drugs_stock_count(Request $request)
    {
        $drugs_ids_array = $request->drug_id;
        $cost_price_array = $request->cost_price;
        $system_stock_array = $request->system_stock;
        $physical_stock_array = $request->physical_stock;
        $difference_array = $request->difference;
        $expiry_date_array = $request->expiry_date;
        $reason_for_difference_array = $request->reason_for_difference;

        $batch_drug_ids_array = $request->batch_drug_id;
        $unique_drug_ids_with_batches_array = array_unique($batch_drug_ids_array);
        $batch_numbers_array = $request->batch_number;
        $batch_quantity_balances_array = $request->batch_quantity_balance;
        $batch_expiry_dates_array = $request->expiry_date;
        $batch_unit_cost = $request->batch_unit_cost;
        $batch_db_record_ids_array = $request->item_batch_watcher_id;
        $batch_unit_cost = $request->batch_unit_cost;

        $drugs_with_initial_stock_array = is_null($request->is_initial_stock) ? [] : $request->is_initial_stock;
        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();
        $affected_account_id = $stock_adjustment_chart_of_account->id;
        $opening_inventory_chart_of_account = ChartOfAccount::where('slug', 'opening_inventory')->first();
        //$affected_account_id = $request->account_id;
        //get the max identifier
        $max_stock_count_identifier = DB::table('pharmacy_stock_reconciliations')->max('stock_count_identifier');
        $reconcile_drug_pharmacy_stock = true;

        //update batch tracking tables with reconciliations
        for ($i=0; $i < count($batch_numbers_array) ; $i++) {
            if (!is_null($batch_numbers_array[$i]) && !is_null($batch_quantity_balances_array[$i])) {
                //enforce double entry per batch
                if (in_array($batch_drug_ids_array[$i], $drugs_with_initial_stock_array)) {
                    $affected_account_id = $opening_inventory_chart_of_account->id;//override adjustment a/c to be opening_inv
                } else{
                    $affected_account_id = $stock_adjustment_chart_of_account->id;
                }
                account_for_batch_reconciliations_difference(1, $batch_drug_ids_array[$i], $affected_account_id, $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $request->reconciliation_date, "pharmacy", null);

                reconcile_batches(1, $batch_drug_ids_array[$i], $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $batch_expiry_dates_array[$i], "pharmacy",$batch_unit_cost[$i]??0, $batch_db_record_ids_array[$i]??0, null);
            }
        }

        if (isset($request->reconcile_stock)) {
            for ($x = 0; $x < count($drugs_ids_array); $x++):
                /* check if the difference value is not null and then update the drug */
                if (!is_null($difference_array[$x])) {
                    $physical_stock = new PharmacyStockReconciliation;
                    $physical_stock->drug_id = $drugs_ids_array[$x];
                    $physical_stock->system_stock = $system_stock_array[$x];
                    $physical_stock->physical_stock = $physical_stock_array[$x];
                    $physical_stock->difference = $difference_array[$x];
                    $physical_stock->reason_for_difference = $reason_for_difference_array[$x];
                    $physical_stock->completion_status = 1;
                    $physical_stock->affected_account_id = $affected_account_id;
                    $physical_stock->reconciliation_date = $request->reconciliation_date;
                    $physical_stock->general_comment = $request->general_comment;
                    $physical_stock->created_by = Auth::id();
                    $physical_stock->save();
                    //add the stock_count_identifier of the newly counted stock
                    $physical_stock_record_to_update = PharmacyStockReconciliation::find($physical_stock->id);
                    $physical_stock_record_to_update->stock_count_identifier = $max_stock_count_identifier+1;//increase ID by 1 for new
                    $physical_stock_record_to_update->update();

                    //update the system stock levels with the newly counted physical stock
                    //update only those with new physical value
                    $drugs = Drug::find($drugs_ids_array[$x]);
                    $drugs->pharmacy_stock = $physical_stock_array[$x];
                    $drugs->expiry_date = $expiry_date_array[$x];
                    if (in_array($drugs->id, $drugs_with_initial_stock_array)) {
                        $existing_opening_stock = is_null($drugs->opening_stock) ? 0 : $drugs->opening_stock;
                        $drugs->opening_stock = $existing_opening_stock + $physical_stock_array[$x];
                        $drugs->opening_cost_price = $cost_price_array[$x];
                        $drugs->opening_stock_date = $request->reconciliation_date;
                        $drugs->pharmacy_opening_stock = $physical_stock_array[$x];
                        $affected_account_id = $opening_inventory_chart_of_account->id;//overide adjustment a/c to be opening_inv
                    } else{
                        $affected_account_id = $stock_adjustment_chart_of_account->id;
                    }
                    $drugs->updated_by = Auth::id();

                    //enforce double entry
                    //account_for_stock_reconciliations_difference($item_type = 1, $drugs_ids_array[$x], $affected_account_id, $difference_array[$x], $cost_price_array[$x], $request->reconciliation_date);

                    $reconcile_drug_pharmacy_stock = $drugs->update();
                }else $reconcile_drug_pharmacy_stock = true;
            endfor;

            if ($reconcile_drug_pharmacy_stock):
                flash('Stock levels have been reconciled')->success();
                return redirect('pharmacy_stock_sheet');
            endif;
        } else if(isset($request->save_stock)){
            //save these for editing later on
            for ($x = 0; $x < count($drugs_ids_array); $x++):
                $physical_stock = new PharmacyStockReconciliation;
                $physical_stock->drug_id = $drugs_ids_array[$x];
                $physical_stock->system_stock = $system_stock_array[$x];
                $physical_stock->physical_stock = $physical_stock_array[$x];
                $physical_stock->difference = $difference_array[$x];
                $physical_stock->reason_for_difference = $reason_for_difference_array[$x];
                $physical_stock->completion_status = 0;
                $physical_stock->created_by = Auth::id();
                $saved_physical_stock = $physical_stock->save();
                //add stock_count_identifier that will be used in resuming edit
                $physical_stock_record_to_that_will_be_updated = PharmacyStockReconciliation::find($physical_stock->id);
                $physical_stock_record_to_that_will_be_updated->stock_count_identifier = $max_stock_count_identifier+1;//increase ID by 1 for new
                $physical_stock_record_to_that_will_be_updated->update();
            endfor;

            if ($saved_physical_stock):
                flash('Physical stock has been saved. You can resume later')->success();
                return redirect('pharmacy_stock_sheet');
            endif;
        }

        flash('Sorry, unable to update stock')->error();
        return redirect()->back();
    }

    public function drugs_stock_reconciliation_report()
    {
        $reconciled_stocks = PharmacyStockReconciliation::groupBy("stock_count_identifier")->get();
        return view('pharmacy::pharmacy.drugs_stock_reconciliation_report',compact('reconciled_stocks'));
    }

    /* stock reconciliation report details */
    public function drugs_stock_reconciliation_report_details(Request $request)
    {
        $drugs_reconciled = PharmacyStockReconciliation::where(['stock_count_identifier' => $request->stock_count_identifier])->get();
        return view('pharmacy::pharmacy.drugs_stock_reconciliation_report_details',compact('drugs_reconciled'));
    }

    public function alter_prescriptions($treatment_id, $patient_id) {
        $treatment = Treatment::find($treatment_id);
        session()->put('alter_episode_id', $treatment->episode_id);
        session()->put('alter_patient_id', $patient_id);
        return redirect('/prescriptions/create');
    }

    public function patient_drugs_given_so_far($patient_id, $episode_id) {
        $ward_quantities_given_option = DB::table('ward_treatment_dispensations')->where(['patient_id' => $patient_id, 'episode_id' => $episode_id])->groupBy('drug_id')->selectRaw('*, sum(quantity_given) as quantity_given')->get();

        $original_ward_presc = WardTreatment::where(['patient_id' => $patient_id, 'episode_id' => $episode_id])->get();
        $stopped_ward_drugs_array = [];

        foreach ($original_ward_presc as $presc_record) {
            $stopped_drugs_array = is_null($presc_record->stopped_drugs) ? [] : explode(",", $presc_record->stopped_drugs);
            $stopped_ward_drugs_array = array_merge($stopped_ward_drugs_array, $stopped_drugs_array);
        }

        $html_text = "<table class='table table-bordered table-striped'>";

        $html_text .= "<tr>";
        $html_text .= "<th style='color: black' class='text-center'> Drug Name </th>";
        $html_text .= "<th style='color: black' class='text-center'> Date </th>";
        $html_text .= "<th style='color: black' class='text-center'> Quantity </th>";
        $html_text .= "</tr>";

        foreach($ward_quantities_given_option as $record){
            $html_text .= "<tr>";

            $dispensation_details = WardTreatmentDispensation::where(['patient_id' => $patient_id, 'episode_id' => $episode_id, 'drug_id' => $record->drug_id])->get();

            $html_text .= "<td rowspan='" . count($dispensation_details) . "'>";
            $html_text .= get_name($record->drug_id, "id", "name", "drugs");

            if (in_array($record->drug_id, $stopped_ward_drugs_array)) {
                $html_text .= "<br><br><button type='button' class='btn btn-outline-danger btn-sm btn-rounded'>Drug has been stopped</button>";
            } else {
                $html_text .= "<br><br><button type='button' class='btn btn-outline-success btn-sm btn-rounded' onclick='add_to_current_order(\"" . $record->drug_id . "\")'>Add to current order</button>";
            }

            $html_text .= "</td><td>" . streamline_date_time($dispensation_details[0]->created_at) . " by " . get_full_name($dispensation_details[0]->created_by, "id", "first_name", "last_name", "users") . "</td>";
            $html_text .= "<td>" . $dispensation_details[0]->quantity_given . "</td>";
            $html_text .= "</tr>";

            for($i = 1; $i < count($dispensation_details); $i++) {
                $html_text .= "<tr>";
                $html_text .= "<td>" . streamline_date_time($dispensation_details[$i]->created_at) . " by " . get_full_name($dispensation_details[$i]->created_by, "id", "first_name", "last_name", "users") . "</td>";
                $html_text .= "<td>" . $dispensation_details[$i]->quantity_given . "</td>";
                $html_text .= "</tr>";
            }

            $html_text .= "<tr> <td colspan='2' class='text-center'><b>Total</b></td> <td>" . $record->quantity_given . "</td> </tr>";
        }

        $html_text .= '</table>';

        return json_encode([
            "html" => $html_text
        ]);
    }

    public function pharmacy_dispensation_report_patients(Request $request) {
        $filters = [];

        if($request->search_by == 0){
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        } elseif($request->search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } elseif($request->search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } else {
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        }

        $dispensations = PatientDispensing::where($filters)->get();

        return view('pharmacy::pharmacy.pharmacy_dispensation_report_patients', compact('dispensations', 'search_text'));
    }

    public function cancel_dispensation($id) {
        $dispensation = PatientDispensing::find($id);

        $cancelled_dispensation = new CancelledPatientOpdDispensation();
        $cancelled_dispensation->patient_id = $dispensation->patient_id;
        $cancelled_dispensation->treatment_id = $dispensation->treatment_id;
        $cancelled_dispensation->drugs = $dispensation->drugs;
        $cancelled_dispensation->dose = $dispensation->dose;
        $cancelled_dispensation->dose2 = $dispensation->dose2;
        $cancelled_dispensation->drug_frequency = $dispensation->drug_frequency;
        $cancelled_dispensation->instructions = $dispensation->instructions;
        $cancelled_dispensation->duration = $dispensation->duration;
        $cancelled_dispensation->quantity_dispensed = $dispensation->quantity_dispensed;
        $cancelled_dispensation->tta = $dispensation->tta;
        $cancelled_dispensation->previous_created_by = $dispensation->created_by;
        $cancelled_dispensation->previous_created_at = $dispensation->created_at;
        $cancelled_dispensation->created_by = Auth::id();
        $cancelled_dispensation->save();

        $treatment = Treatment::find($dispensation->treatment_id);
        $treatment->dispense_status = 0;
        $treatment->update();

        // fill back the drug quantities
        $drug_ids_array = explode(",", $dispensation->drugs);
        $quantity_to_dispense_array = explode(",", $dispensation->quantity_dispensed);

        if ($dispensation->purchased_elsewhere) {
            $purchased_elsewhere_array = explode(",", $dispensation->purchased_elsewhere);
        } else {
            $purchased_elsewhere_array = array_fill(0, count($drug_ids_array), 0);
        }

        for ($x = 0; $x < count($drug_ids_array); $x++) {
            $drug = Drug::find($drug_ids_array[$x]);

            if ($drug && $purchased_elsewhere_array[$x] == 0) {
                $current_stock = $drug->pharmacy_stock;
                $new_stock = $current_stock + $quantity_to_dispense_array[$x];
                $drug->pharmacy_stock = $new_stock;
                $drug->update();
                //reverse the used batches too
                reverse_dispensed_item_batches(1, $drug_ids_array[$x], $quantity_to_dispense_array[$x], $dispensation->patient_id, 'treatments', $treatment->id);
            }
        }

        $dispensation->forceDelete();
        flash('Patient dispensation has been cancelled!')->success();
        return redirect('pharmacy_dispensation_report_patients');
    }

    public function pharmacy_dispensation_report_drugs(Request $request)
    {
        $search_text = "";
        $filters = [];

        $selected_drug_id = $request->drug_id;
        /* create associative array of drugs with their quantities */
        $drugs_qty_associative_array = [];

        if($request->search_by == 0){
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        } elseif($request->search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->reg_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } elseif($request->search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->end_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } else {
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        }

        $drugs_selection_array = Drug::where('available', 1)->pluck("name","id")->toArray();
        $drugs_selection_array = ['' => '- select -'] + $drugs_selection_array;

        $drugs_dispensed_with_qty_array = [];
        $opd_drugs_dispensed_with_qty_array = [];
        $ipd_drugs_dispensed_with_qty_array = [];
        $drugs_dispensed = [];
        $quantity_dispensed = [];

        $opd_dispensations = PatientDispensing::where($filters)->get();
        if (count($opd_dispensations) > 0) {
            foreach ($opd_dispensations as $opd_record) {
                $drugs_array = explode(",", $opd_record->drugs);
                $quantities_array = explode(",", $opd_record->quantity_dispensed);
                $purchased_elsewhere_array = explode(",", $opd_record->purchased_elsewhere);

                for ($i=0; $i < count($drugs_array); $i++) {
                    if (isset($purchased_elsewhere_array[$i]) && $purchased_elsewhere_array[$i] == 0) {
                        if (!is_null($selected_drug_id)) {
                            if ($selected_drug_id == $drugs_array[$i]) {
                                /* ============ meet Ms.Elegant for the first date with opd stuff ==========*/
                                if (array_key_exists($drugs_array[$i], $drugs_qty_associative_array)){
                                    //echo "Found the Key";
                                    $drugs_qty_associative_array[$drugs_array[$i]] += $quantities_array[$i];
                                }
                                else{
                                    //echo "Key not Found";
                                    $drugs_qty_associative_array[$drugs_array[$i]] = $quantities_array[$i];
                                }
                                /*============ bye bye Ms.Elegant ========*/


                                /* ============ meet Ms.Elegant's little sister ==========*/
                                if (array_key_exists($drugs_array[$i], $opd_drugs_dispensed_with_qty_array)){
                                    //echo "Found the Key";
                                    $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] += $quantities_array[$i];
                                }
                                else{
                                    //echo "Key not Found";
                                    $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] = $quantities_array[$i];
                                }
                                /*============ bye bye Ms.Elegant's little sister ========*/
                            }
                        } else{
                            /* ============ meet Ms.Elegant for the first date with opd stuff ==========*/
                            if (array_key_exists($drugs_array[$i], $drugs_qty_associative_array)){
                                //echo "Found the Key";
                                $drugs_qty_associative_array[$drugs_array[$i]] += $quantities_array[$i];
                            }
                            else{
                                //echo "Key not Found";
                                $drugs_qty_associative_array[$drugs_array[$i]] = $quantities_array[$i];
                            }
                            /*============ bye bye Ms.Elegant ========*/


                            /* ============ meet Ms.Elegant's little sister ==========*/
                            if (array_key_exists($drugs_array[$i], $opd_drugs_dispensed_with_qty_array)){
                                //echo "Found the Key";
                                $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] += $quantities_array[$i];
                            }
                            else{
                                //echo "Key not Found";
                                $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] = $quantities_array[$i];
                            }
                            /*============ bye bye Ms.Elegant's little sister ========*/
                        }
                    }
                }
            }
        }

        $ward_quantities = [];
        $ward_dispensed_drugs = [];

        if (!is_null($selected_drug_id)) {
            $ward_dispensations = WardTreatmentDispensation::where($filters)->where('drug_id', $selected_drug_id)->get();
        } else {
            //selected_drug_id
            $ward_dispensations = WardTreatmentDispensation::where($filters)->get();
        }

        if (count($ward_dispensations) > 0) {
            foreach ($ward_dispensations as $ward_record) {

                /* ============ meet Ms.Elegant for the second date with ward stuff ==========*/
                if (array_key_exists($ward_record->drug_id, $drugs_qty_associative_array)){
                    //echo "Found the Key";
                    $drugs_qty_associative_array[$ward_record->drug_id] += $ward_record->quantity_given;
                }
                else{
                    //echo "Key not Found";
                    $drugs_qty_associative_array[$ward_record->drug_id] = $ward_record->quantity_given;
                }
                /*============ bye bye Ms.Elegant ========*/


                /* ============ meet Ms.Elegant's other little sister ==========*/
                if (array_key_exists($ward_record->drug_id, $ipd_drugs_dispensed_with_qty_array)){
                    //echo "Found the Key";
                    $ipd_drugs_dispensed_with_qty_array[$ward_record->drug_id] += $ward_record->quantity_given;
                }
                else{
                    //echo "Key not Found";
                    $ipd_drugs_dispensed_with_qty_array[$ward_record->drug_id] = $ward_record->quantity_given;
                }
                /*============ bye bye Ms.Elegant's other little sister ========*/
            }
        }

        return view('pharmacy::pharmacy.pharmacy_dispensation_report_drugs', compact('drugs_selection_array', 'drugs_dispensed', 'quantity_dispensed', 'ward_quantities', 'ward_dispensed_drugs', 'drugs_qty_associative_array', 'search_text', 'opd_drugs_dispensed_with_qty_array', 'ipd_drugs_dispensed_with_qty_array', 'request'));
    }

    public function dispensation_report_details(Request $request)
    {
        $search_text = "";
        $filters = [];
        /* create associative array of drugs with their quantities */
        $drugs_qty_associative_array = [];
        $selected_drug_id = $request->details_drug_id;

        if($request->details_search_by == 0){
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        } elseif($request->details_search_by == 1){
            // custom date
            $start_date = Carbon::createFromFormat('d/m/Y', $request->details_reg_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->details_reg_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } elseif($request->details_search_by == 2){
            // custom date range
            $start_date = Carbon::createFromFormat('d/m/Y', $request->details_start_date)->startOfDay()->toDateTimeString();
            $end_date = Carbon::createFromFormat('d/m/Y', $request->details_end_date)->endOfDay()->toDateTimeString();

            array_push($filters, ['created_at', '>', $start_date]);
            array_push($filters, ['created_at', '<', $end_date]);

            $search_text = "Showing dispensations made between " . streamline_date_plain($start_date) . " and " . streamline_date_plain($end_date);
        } else {
            // last 24 hours
            array_push($filters, ['created_at', '>', Carbon::now()->subDay()]);
            $search_text = "Showing dispensations in the past 24 hours";
        }

        $drugs_array = Drug::pluck("name","id")->toArray();
        $drugs_array = ['' => '- select -'] + $drugs_array;

        $drugs_dispensed_with_qty_array = [];
        $opd_drugs_dispensed_with_qty_array = [];
        $ipd_drugs_dispensed_with_qty_array = [];
        $drugs_dispensed = [];
        $quantity_dispensed = [];

        $opd_dispensations = PatientDispensing::where($filters)->get();
        if (count($opd_dispensations) > 0) {
            foreach ($opd_dispensations as $opd_record) {
                $drugs_array = explode(",", $opd_record->drugs);
                $quantities_array = explode(",", $opd_record->quantity_dispensed);
                $purchased_elsewhere_array = explode(",", $opd_record->purchased_elsewhere);

                for ($i=0; $i < count($drugs_array); $i++) {
                    if (isset($purchased_elsewhere_array[$i]) && $purchased_elsewhere_array[$i] == 0) {
                        /* ============ meet Ms.Elegant for the first date with opd stuff ==========*/
                        if (array_key_exists($drugs_array[$i], $drugs_qty_associative_array)){
                            //echo "Found the Key";
                            $drugs_qty_associative_array[$drugs_array[$i]] += $quantities_array[$i];
                        }
                        else{
                            //echo "Key not Found";
                            $drugs_qty_associative_array[$drugs_array[$i]] = $quantities_array[$i];
                        }
                        /*============ bye bye Ms.Elegant ========*/


                        /* ============ meet Ms.Elegant's little sister ==========*/
                        if (array_key_exists($drugs_array[$i], $opd_drugs_dispensed_with_qty_array)){
                            //echo "Found the Key";
                            $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] += $quantities_array[$i];
                        }
                        else{
                            //echo "Key not Found";
                            $opd_drugs_dispensed_with_qty_array[$drugs_array[$i]] = $quantities_array[$i];
                        }
                        /*============ bye bye Ms.Elegant's little sister ========*/
                    }
                }
            }
        }

        $ward_dispensations = WardTreatmentDispensation::where($filters)->where('drug_id', $selected_drug_id)->get();

        return view('pharmacy::pharmacy.dispensation_report_details', compact('search_text', 'ward_dispensations', 'selected_drug_id', 'opd_dispensations'));
    }

    public function dispensed_details_review(Request $request) {
        $treatment_id = $request->treatment_id;
        $patient_id = $request->patient_id;
        $episode_id = $request->episode_id;

        $patient = Patient::where(['id' => $patient_id])->first();
        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
        $marital_statuses = DB::table('marital_statuses')->pluck("name", "id");
        $drug_categories = DB::table('drug_categories')->get();
        $treatment = Treatment::find($treatment_id);
        //$treatments = Treatment::where(['episode_id' => $episode_id, 'dispense_status' => 0])->get();
        $dosage_frequencies = DB::table('dosage_frequencies')->pluck("name", "id")->toArray();

        //allergies and alerts
        $known_patient_allergies = Allergy::where('patient_id', $patient_id)->orderBy('created_at', 'desc')->take(2)->get();
        $known_patient_alerts = Alert::where('patient_id', $patient_id)->orderBy('created_at', 'desc')->take(2)->get();
        $drug_categories_array = DB::table('drug_categories')->pluck('name', 'id');

        return view('pharmacy::pharmacy.dispensed_details_review', compact('patient_id', 'treatment_id', 'patient', 'categories', 'marital_statuses', 'drug_categories', 'treatment', 'known_patient_alerts', 'known_patient_allergies', 'drug_categories_array','dosage_frequencies'));
    }

    public function view_prescriptions_to_cancel(Request $request) {
        $search_by = $request->search_by;
        $reg_date = $request->reg_date;
        $start_date = $request->start_date;
        $end_date = $request->end_date;
        $filters = [];

        if($search_by == 0){
            // last 24 hours
            $start_date_search = Carbon::now()->subDay();
            $end_date_search = Carbon::now();
            $date_search = "Today";
        } elseif($search_by == 1){
            // custom date
            $start_date_search = Carbon::parse($reg_date)->startOfDay();
            $end_date_search = Carbon::parse($reg_date)->endOfDay();
            $date_search = streamline_date($start_date_search);
        } elseif($search_by == 2){
            // custom date range
            $start_date_search = Carbon::parse($start_date)->startOfDay();
            $end_date_search = Carbon::parse($end_date)->endOfDay();
            $date_search = streamline_date($start_date_search) . " to " . streamline_date($end_date_search);
        }

        $prescriptions = Treatment::where('dispense_status', 0)
            ->where('payment_status', 0)
            ->whereBetween('created_at', [$start_date_search, $end_date_search])
            ->orderBy('id','desc')
            ->get();

        return view('pharmacy::pharmacy.view_prescriptions_to_cancel',compact('prescriptions', 'date_search'));
    }

    public function cancel_prescriptions($treatment_id) {
        $treatment = Treatment::find($treatment_id);

        try {
            $treatment->delete();

            // check if there are any insurance claims available
            $claim = InsuranceClaim::where('order_id', $treatment_id)->where('item_type', 4)->first();

            if ($claim) {
                $claim->delete();
            }

            flash("Treatment order has been cancelled.")->success();
        } catch (\Exception $exception) {
            flash("Treatment order has not been cancelled.")->error();
        }

        return redirect('/pharmacy/view_prescriptions_to_cancel');
    }

    public function view_cancelled_prescriptions(Request $request) {
        $search_by = $request->search_by;
        $reg_date = $request->reg_date;
        $start_date = $request->start_date;
        $end_date = $request->end_date;
        $filters = [];

        if($search_by == 0){
            // last 24 hours
            $start_date_search = Carbon::now()->subDay();
            $end_date_search = Carbon::now();
            $date_search = "Today";
        } elseif($search_by == 1){
            // custom date
            $start_date_search = Carbon::parse($reg_date)->startOfDay();
            $end_date_search = Carbon::parse($reg_date)->endOfDay();
            $date_search = streamline_date($start_date_search);
        } elseif($search_by == 2){
            // custom date range
            $start_date_search = Carbon::parse($start_date)->startOfDay();
            $end_date_search = Carbon::parse($end_date)->endOfDay();
            $date_search = streamline_date($start_date_search) . " to " . streamline_date($end_date_search);
        }

        $prescriptions = DB::table('treatments')
            ->whereNotNull('deleted_at')
            ->whereBetween('deleted_at', [$start_date_search, $end_date_search])
            ->orderBy('id','desc')
            ->get();

        return view('pharmacy::pharmacy.view_cancelled_prescriptions',compact('prescriptions', 'date_search'));
    }

    public function restore_deleted_ordered_treatments($id) {
        $treatment = Treatment::withTrashed()->find($id);

        try {
            $treatment->restore();

            // check if there are any insurance claims available
            $claim = InsuranceClaim::onlyTrashed()->where('order_id', $id)->where('service_type', 4)->first();

            if ($claim) {
                $claim->restore();
            }

            flash("Treatment order has been activated")->success();
        } catch (\Exception $exception) {
            flash("Treatment order has not been activated")->error();
        }

        return redirect('/pharmacy/view_cancelled_prescriptions');
    }

    public function dispense_treatment_progressively($treatment_id) {
        $treatment = Treatment::find($treatment_id);

        $treatment_opd = new TreatmentOpdProgressive();
        $treatment_opd->patient_id = $treatment->patient_id;
        $treatment_opd->episode_id = $treatment->episode_id;
        $treatment_opd->initial_treatment_id = $treatment->id;
        $treatment_opd->treatment_ids = $treatment->id;
        $treatment_opd->is_first_treatment_given = 0;
        $treatment_opd->drugs = $treatment->drugs;
        $treatment_opd->dose = $treatment->doses;
        $treatment_opd->drug_frequency = $treatment->frequencies;
        $treatment_opd->durations = $treatment->durations;
        $treatment_opd->quantities_to_dispense = $treatment->quantities_dispensed;
        $treatment_opd->instruction = $treatment->instruction;
        $treatment_opd->created_by = Auth::id();
        $treatment_opd->prescribed_by = $treatment->created_by;
        $treatment_opd->order_comments = $treatment->order_comments;
        $treatment_opd->save();

        $treatment->confirmation_status = 1;
        $treatment->is_treatment_progressive = $treatment_opd->id;
        $treatment->save();

        flash('Treatment has been confirmed and progressive dispensation started')->success();
        return redirect('confirm_prescriptions');
    }

    public function confirm_progressive_prescriptions(Request $request) {
        $today = Carbon::today();
        $yesterday = Carbon::yesterday();
        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
        $display = dateLabelSetter2($request);
        $filters = [];

        if (isset($request->patient_id) && $request->patient_id != 0) {
            array_push($filters, ['patient_id', '=', $request->patient_id]);
        }

        switch ($request->dates){
            case 'today':
            default:
                $end = Carbon::parse($today)->endOfDay();
                $start = Carbon::parse($today)->startOfDay();
                break;
            case 'yesterday':
                $end = Carbon::parse($yesterday)->endOfDay();
                $start = Carbon::parse($yesterday)->startOfDay();
                break;
            case 'custom_date':
                $end = Carbon::parse($request->start)->endOfDay();
                $start = Carbon::parse($request->start_date)->startOfDay();
                break;
            case 'custom_date_range':
                $end = Carbon::parse($request->end_date)->endOfDay();
                $start = Carbon::parse($request->start_date)->startOfDay();

        }

        $prescriptions = TreatmentOpdProgressive::where('is_dispensation_complete', 0)
            ->whereBetween('created_at',[$start, $end])
            ->where($filters)
            ->orderBy('created_at', 'desc')
            ->get();

        return view('pharmacy::pharmacy.confirm_progressive_prescriptions', compact('prescriptions', 'categories', 'display'));
    }

    public function confirm_progressive_prescriptions_details($treatment_id) {
        $original_prescription = TreatmentOpdProgressive::find($treatment_id);
        $patient_id = $original_prescription->patient_id;

        if ($original_prescription->is_first_treatment_given != 0) {
            $previous_progressive_treatments = Treatment::whereIn('id', explode(",", $original_prescription->treatment_ids))->get();
        } else {
            $previous_progressive_treatments = [];
        }

        $patient = Patient::find($patient_id);

        return view('pharmacy::pharmacy.confirm_progressive_prescriptions_details', compact('previous_progressive_treatments', 'original_prescription', 'patient', 'patient_id'));
    }

    public function save_progressive_prescriptions(Request $request) {
        $duration_array = $request->duration;
        $patient_id = $request->patient_id;
        $episode_id = $request->episode_id;
        $time_duration = [];
        $is_first_treatment = false;
        $quantity_given_so_far = $request->quantity_given_so_far;
        $quantity_prescribed = $request->quantity_prescribed;
        $quantity_dispensed = $request->quantity_dispensed;
        $is_treatment_done = array_fill(0, count($duration_array), false);

        $original_prescription = TreatmentOpdProgressive::find($request->progressive_id);

        // check if this is the first time a progressive prescription is made to update it
        if ($original_prescription->is_first_treatment_given == 0) {
            $treatment = Treatment::find($original_prescription->initial_treatment_id);

            if ($treatment->dispense_status == 1) {
                // if the treatment has been dispensed then lock the record
                $original_prescription->is_dispensation_complete = 1;
                $original_prescription->save();
                flash("The treatment order for " . get_patient_name($patient_id) . " has already been dispensed!")->error();
                return redirect("/confirm_progressive_prescriptions");
            }

            $treatment->updated_by = Auth::id();
            $original_prescription->is_first_treatment_given = 1;
            $original_prescription->payment_status = $treatment->payment_status;
            $is_first_treatment = true;
        } else {
            $treatment = new Treatment;
            $treatment->created_by = Auth::id();
            $treatment->payment_status = $original_prescription->payment_status;
        }

        // sort the durations by adding days string
        for ($i = 0; $i < count($duration_array); $i++) {
            $time_duration[] = $duration_array[$i] . " Days";

            $is_treatment_done[$i] = (($quantity_given_so_far[$i] + $quantity_dispensed[$i]) > ($quantity_prescribed[$i] - 1));
        }

        // insert treatment details with confirmation and progressive
        $treatment->patient_id = $patient_id;
        $treatment->episode_id = $episode_id;
        $treatment->drugs = implode(',', $request->drug_id);
        $treatment->doses = implode(',', $request->dose);
        $treatment->frequencies = implode(',', $request->frequency);
        $treatment->durations = implode(',', $time_duration);
        $treatment->quantities_dispensed = implode(',', $request->quantity_dispensed);
        $treatment->instruction = implode(',', $request->instructions);
        $treatment->confirmation_status = 1;
        $treatment->is_treatment_progressive = $request->progressive_id;

        if ($treatment->save()) {
            // redo the insurance claim for treatment if it exists
            if ($request->patient_insurance_status == 1) {
                generate_insurance_claim($treatment->id, 4);
            }

            // group the treatment ids
            $current_treatment_ids = explode(",", $original_prescription->treatment_ids);

            // avoid repeating the first id
            if (!$is_first_treatment) {
                $current_treatment_ids[] = $treatment->id;
            }

            // check if all medicine in the original prescription has been dispensed and close this record
            if (!in_array(false, $is_treatment_done)) {
                $original_prescription->is_dispensation_complete = 1;
            }

            $original_prescription->treatment_ids = implode(",", $current_treatment_ids);
            $original_prescription->save();

            flash("New treatment record has been created")->success();
        } else {
            flash("Failed to create a new treatment record")->error();
        }
        return redirect("/confirm_progressive_prescriptions");
    }

    public function cancel_progressive_prescriptions($treatment_id) {
        $treatment = TreatmentOpdProgressive::find($treatment_id);

        if ($treatment->delete()) {
            flash("Progressive treatment order has been cancelled.")->success();
            return redirect('/confirm_progressive_prescriptions');
        }
    }

    public function view_cancelled_progressive_prescriptions(Request $request) {
        $search_by = $request->search_by;
        $reg_date = $request->reg_date;
        $start_date = $request->start_date;
        $end_date = $request->end_date;
        $filters = [];

        if($search_by == 0){
            // last 24 hours
            $start_date_search = Carbon::now()->subDay();
            $end_date_search = Carbon::now();
            $date_search = "Today";
        } elseif($search_by == 1){
            // custom date
            $start_date_search = Carbon::parse($reg_date)->startOfDay();
            $end_date_search = Carbon::parse($reg_date)->endOfDay();
            $date_search = streamline_date($start_date_search);
        } elseif($search_by == 2){
            // custom date range
            $start_date_search = Carbon::parse($start_date)->startOfDay();
            $end_date_search = Carbon::parse($end_date)->endOfDay();
            $date_search = streamline_date($start_date_search) . " to " . streamline_date($end_date_search);
        }

        $prescriptions = DB::table('treatments_opd_progressive')
            ->whereNotNull('deleted_at')
            ->whereBetween('deleted_at', [$start_date_search, $end_date_search])
            ->orderBy('id','desc')
            ->get();

        return view('pharmacy::pharmacy.view_cancelled_progressive_prescriptions',compact('prescriptions', 'date_search'));
    }

    public function restore_deleted_progressive_prescriptions($id) {
        $treatment = TreatmentOpdProgressive::withTrashed()->find($id);

        if ($treatment->restore()){
            flash("Progressive treatment order has been activated.")->success();
            return redirect('/pharmacy/view_cancelled_progressive_prescriptions');
        }
    }

    public function delete_requisition($id) {
        $requisition = Requisition::find($id);

        if ($requisition && $requisition->delete()) {
            flash("Requisition has been deleted")->success();
        } else {
            flash("Unable to delete requisition. Please contact the Stre@mline Support team")->error();
        }

        return redirect()->back();
    }

    public function delete_temporary_requisition($id) {
        $temporary_requisition = TemporaryRequisition::find($id);

        // confirm the temp exists
        if ($temporary_requisition && $temporary_requisition->delete()) {
            flash("Requisition has been deleted")->success();
        } else {
            flash("Unable to delete requisition. Please contact the Stre@mline Support team")->error();
        }

        return redirect()->back();
    }

    public function item_requisition_print($requisition_id, $item_type)
    {
        $hospital_details = HospitalInformation::first();
        $requisition_model = Requisition::withTrashed()->find($requisition_id);

        $data = [
            'hospitalInfo' => $hospital_details,
            'requisition_model' => $requisition_model,
            'requisition_id' => $requisition_id,
            'item_type' => $item_type
        ];

        $pdf = SnappyPDF::loadView('pharmacy::pharmacy/item_requisition_print', $data)
            ->setOrientation('portrait')
            ->setOption('margin-bottom', 10)
            ->setOption('margin-top', 5)
            ->setOption('margin-left', 2)
            ->setOption('margin-right', 2)
            ->setOption('footer-font-size', 10)
            ->setOption('footer-html', '<i>- Stre@mline -</i> '. get_full_name(Auth::id(), "id", "first_name", "last_name", "users") .' '.streamline_date_time(date('Y-m-d')).'');

        return $pdf->inline('ITEMS BILL' . date(" d-m-y h:ia") . '.pdf');
    }

    public function sundries_stock_reconciliation(Request $request) {
        $sundries = [];
        $item_ids_array = $request->search_items_ids;

        if ($item_ids_array) {
            $is_all_items = in_array("all_items", $item_ids_array);

            if ($is_all_items) {
                $sundries = Sundry::where('available', 1)->orderby('name', 'asc')->get();
            } else{
                $sundries = Sundry::whereIn('id', $item_ids_array)->orderBy('name', 'asc')->get();
            }
        }

        $chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')->pluck('name', 'id')->toArray();
        $chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;

        $sundries_dropdown = DB::table('sundries')->whereNull('deleted_at')->orderBy('name', 'asc')->pluck('name','id')->prepend('All sundries', 'all_items')->toArray();

        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();

        return view('pharmacy::pharmacy.sundries_stock_reconciliation', compact('sundries', 'chart_of_accounts', 'sundries_dropdown', 'stock_adjustment_chart_of_account'));
    }

    public function store_pharmacy_sundries_stock_count(Request $request)
    {
        $sundries_ids_array = $request->sundry_id;
        $cost_price_array = $request->cost_price;
        $system_stock_array = $request->system_stock;
        $physical_stock_array = $request->physical_stock;
        $difference_array = $request->difference;
        $expiry_date_array = $request->expiry_date;
        $reason_for_difference_array = $request->reason_for_difference;

        $batch_sundry_ids_array = $request->batch_sundry_id;
        $unique_sundry_ids_with_batches_array = array_unique($batch_sundry_ids_array);
        $batch_numbers_array = $request->batch_number;
        $batch_quantity_balances_array = $request->batch_quantity_balance;
        $batch_expiry_dates_array = $request->expiry_date;
        $batch_unit_cost= $request->batch_unit_cost;
        $batch_db_record_ids_array = $request->item_batch_watcher_id;
        $batch_unit_cost= $request->batch_unit_cost;
        $sundries_with_initial_stock_array = is_null($request->is_initial_stock) ? [] : $request->is_initial_stock;
        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();
        $affected_account_id = $stock_adjustment_chart_of_account->id;
        $opening_inventory_chart_of_account = ChartOfAccount::where('slug', 'opening_inventory')->first();
        //$affected_account_id = $request->account_id;
        //get the max identfier
        $max_stock_count_identifier = DB::table('pharmacy_sundry_stock_reconciliations')->max('stock_count_identifier');
        $reconcile_sundry_pharmacy_stock = true;

        //update batch tracking tables with reconciliations
        for ($i=0; $i < count($batch_numbers_array) ; $i++) {
            if (!is_null($batch_numbers_array[$i]) && !is_null($batch_quantity_balances_array[$i])) {
                //enforce double entry per batch
                if (in_array($batch_sundry_ids_array[$i], $sundries_with_initial_stock_array)) {
                    $affected_account_id = $opening_inventory_chart_of_account->id;//override adjustment a/c to be opening_inv
                } else{
                    $affected_account_id = $stock_adjustment_chart_of_account->id;
                }
                account_for_batch_reconciliations_difference($item_type = 2, $batch_sundry_ids_array[$i], $affected_account_id, $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $request->reconciliation_date, "pharmacy", $ward_id = null);

                reconcile_batches($item_type = 2, $batch_sundry_ids_array[$i], $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $batch_expiry_dates_array[$i], "pharmacy", $batch_unit_cost[$i]??0, $batch_db_record_ids_array[$i]??0, $ward_id=null);
            }
        }

        if (isset($request->reconcile_stock)) {
            for ($x = 0; $x < count($sundries_ids_array); $x++):
                /* check if the difference value is not null and then update the sundry */
                if (!is_null($difference_array[$x])) {
                    $physical_stock = new PharmacySundryStockReconciliation;
                    $physical_stock->sundry_id = $sundries_ids_array[$x];
                    $physical_stock->system_stock = $system_stock_array[$x];
                    $physical_stock->physical_stock = $physical_stock_array[$x];
                    $physical_stock->difference = $difference_array[$x];
                    $physical_stock->reason_for_difference = $reason_for_difference_array[$x];
                    $physical_stock->completion_status = 1;
                    $physical_stock->affected_account_id = $affected_account_id;
                    $physical_stock->reconciliation_date = $request->reconciliation_date;
                    $physical_stock->general_comment = $request->general_comment;
                    $physical_stock->created_by = Auth::id();
                    $physical_stock->save();
                    //add the stock_count_identifier of the newly counted stock
                    $physical_stock_record_to_update = PharmacySundryStockReconciliation::find($physical_stock->id);
                    $physical_stock_record_to_update->stock_count_identifier = $max_stock_count_identifier+1;//increase ID by 1 for new
                    $physical_stock_record_to_update->update();

                    //update the system stock levels with the newly counted physical stock
                    //update only those with new physical value
                    $sundry = Sundry::find($sundries_ids_array[$x]);
                    $sundry->pharmacy_stock = $physical_stock_array[$x];
                    $sundry->expiry_date = $expiry_date_array[$x];
                    if (in_array($sundry->id, $sundries_with_initial_stock_array)) {
                        $existing_opening_stock = is_null($sundry->opening_stock) ? 0 : $sundry->opening_stock;
                        $sundry->opening_stock = $existing_opening_stock + $physical_stock_array[$x];
                        $sundry->opening_cost_price = $cost_price_array[$x];
                        $sundry->opening_stock_date = $request->reconciliation_date;
                        $sundry->pharmacy_opening_stock = $physical_stock_array[$x];
                        $affected_account_id = $opening_inventory_chart_of_account->id;//overide adjustment a/c to be opening_inv
                    } else{
                        $affected_account_id = $stock_adjustment_chart_of_account->id;
                    }
                    $sundry->updated_by = Auth::id();

                    //enforce double entry
                    account_for_stock_reconciliations_difference($item_type = 2, $sundries_ids_array[$x], $affected_account_id, $difference_array[$x], $cost_price_array[$x], $request->reconciliation_date);

                    $reconcile_drug_pharmacy_stock = $sundry->update();
                }else $reconcile_drug_pharmacy_stock = true;
            endfor;

            if ($reconcile_drug_pharmacy_stock):
                flash('Stock levels have been reconciled')->success();
                return redirect('pharmacy_sundries_stock_sheet');
            endif;
        } else if(isset($request->save_stock)){
            //save these for editing later on
            for ($x = 0; $x < count($sundries_ids_array); $x++):
                $physical_stock = new PharmacySundryStockReconciliation;
                $physical_stock->sundry_id = $sundries_ids_array[$x];
                $physical_stock->system_stock = $system_stock_array[$x];
                $physical_stock->physical_stock = $physical_stock_array[$x];
                $physical_stock->difference = $difference_array[$x];
                $physical_stock->reason_for_difference = $reason_for_difference_array[$x];
                $physical_stock->completion_status = 0;
                $physical_stock->created_by = Auth::id();
                $saved_physical_stock = $physical_stock->save();
                //add stock_count_identifier that will be used in resuming edit
                $physical_stock_record_to_that_will_be_updated = PharmacySundryStockReconciliation::find($physical_stock->id);
                $physical_stock_record_to_that_will_be_updated->stock_count_identifier = $max_stock_count_identifier+1;//increase ID by 1 for new
                $physical_stock_record_to_that_will_be_updated->update();
            endfor;

            if ($saved_physical_stock):
                flash('Physical stock has been saved. You can resume later')->success();
                return redirect('pharmacy_sundries_stock_sheet');
            endif;
        }

        flash('Sorry, unable to update stock')->error();
        return redirect()->back();
    }

    public function sundries_stock_reconciliation_report(Request $request)
    {
        if (!empty($request->dates)) {

            if ($request->dates == "today") {

                $today = Carbon::today()->startOfDay()->toDateTimeString();
                $end = Carbon::parse($today)->endOfDay()->toDateTimeString();
                $reconciled_stocks = PharmacySundryStockReconciliation::groupBy("stock_count_identifier")->whereBetween('created_at', [$today, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "yesterday") {

                $yesterday = Carbon::yesterday()->startOfDay()->toDateTimeString();
                $end = Carbon::parse($yesterday)->endOfDay()->toDateTimeString();
                $reconciled_stocks = PharmacySundryStockReconciliation::groupBy("stock_count_identifier")->whereBetween('created_at', [$yesterday, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "custom_date") {

                $start = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
                $end = Carbon::parse($request->start_date)->endOfDay()->toDateTimeString();
                $reconciled_stocks = PharmacySundryStockReconciliation::groupBy("stock_count_identifier")->whereBetween('created_at', [$start, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "custom_date_range") {

                $start = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
                $end = Carbon::parse($request->end_date)->endOfDay()->toDateTimeString();
                $reconciled_stocks = PharmacySundryStockReconciliation::groupBy("stock_count_identifier")->whereBetween('created_at', [$start, $end])->orderBy('stock_count_identifier', 'desc')->get();
            }
        } else $reconciled_stocks = PharmacySundryStockReconciliation::groupBy("stock_count_identifier")->orderBy('stock_count_identifier', 'desc')->get();
        
        return view('pharmacy::pharmacy.sundries_stock_reconciliation_report',compact('reconciled_stocks'));
    }
    public function opticals_stock_reconciliation_report(Request $request)
    {
        if (!empty($request->dates)) {

            if ($request->dates == "today") {

                $today = Carbon::today()->startOfDay()->toDateTimeString();
                $end = Carbon::parse($today)->endOfDay()->toDateTimeString();
                $reconciled_stocks = OpticalStockReconciliation::select('stock_count_identifier', 'created_by', 'created_at', 'general_comment', DB::raw('SUM(variance) as total'))->groupBy('stock_count_identifier', 'created_by', 'created_at', 'general_comment')->where('type',1)->whereBetween('created_at', [$today, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "yesterday") {

                $yesterday = Carbon::yesterday()->startOfDay()->toDateTimeString();
                $end = Carbon::parse($yesterday)->endOfDay()->toDateTimeString();
                $reconciled_stocks = OpticalStockReconciliation::select('stock_count_identifier', 'created_by', 'created_at', 'general_comment', DB::raw('SUM(variance) as total'))->groupBy('stock_count_identifier', 'created_by', 'created_at', 'general_comment')->where('type',1)->whereBetween('created_at', [$yesterday, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "custom_date") {

                $start = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
                $end = Carbon::parse($request->start_date)->endOfDay()->toDateTimeString();
                $reconciled_stocks = OpticalStockReconciliation::select('stock_count_identifier', 'created_by', 'created_at', 'general_comment', DB::raw('SUM(variance) as total'))->groupBy('stock_count_identifier', 'created_by', 'created_at', 'general_comment')->where('type',1)->whereBetween('created_at', [$start, $end])->orderBy('stock_count_identifier', 'desc')->get();
            } else if ($request->dates == "custom_date_range") {

                $start = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
                $end = Carbon::parse($request->end_date)->endOfDay()->toDateTimeString();
                $reconciled_stocks = OpticalStockReconciliation::select('stock_count_identifier', 'created_by', 'created_at', 'general_comment', DB::raw('SUM(variance) as total'))->groupBy('stock_count_identifier', 'created_by', 'created_at', 'general_comment')->where('type',1)->whereBetween('created_at', [$start, $end])->orderBy('stock_count_identifier', 'desc')->get();
            }
        } else $reconciled_stocks = OpticalStockReconciliation::select('stock_count_identifier', 'created_by', 'created_at', 'general_comment', DB::raw('SUM(variance) as total'))->where('type',1)->groupBy('stock_count_identifier', 'created_by', 'created_at', 'general_comment')->orderBy('stock_count_identifier', 'desc')->get();
        
        
        return view('pharmacy::pharmacy.opticals_stock_reconciliation_report',compact('reconciled_stocks'));
    }
    public function opticals_stock_reconciliation_report_details(Request $request)
    {
        $opticals_reconciled = OpticalStockReconciliation::where(['stock_count_identifier' => $request->stock_count_identifier])->get();
        $opticals_reconciled = $this->itemService->processReconcileItems($opticals_reconciled);
        return view('pharmacy::pharmacy.opticals_stock_reconciliation_report_print', compact('opticals_reconciled'));
    }

    /* stock reconciliation report details */
    public function sundries_stock_reconciliation_report_details(Request $request)
    {
        $sundries_reconciled = PharmacySundryStockReconciliation::where(['stock_count_identifier' => $request->stock_count_identifier])->get();
        return view('pharmacy::pharmacy.sundries_stock_reconciliation_report_details',compact('sundries_reconciled'));
    }

    public function print_protocol_ward_chart()
    {
        $request_array = session()->get('request_array');

        $protocol_ward_id_arr = $request_array['protocol_ward_id'];
        $protocol_patient_id_arr = $request_array['protocol_patient_id'];
        $protocol_episode_id_arr = $request_array['protocol_episode_id'];
        $protocol_drug_dose_arr = $request_array['protocol_drug_dose'];
        $protocol_dosage_to_dispense_arr = $request_array['protocol_dosage_to_dispense'];
        $protocol_quantity_to_dispense_arr = $request_array['protocol_quantity_to_dispense'];
        $protocol_instruction_arr = $request_array['protocol_instruction'];
        $protocol_drug_ids_arr = $request_array['protocol_drug_ids'];
        $protocol_drug_dose_label_arr = $request_array['protocol_drug_dose_label'];

        session()->forget('request_array');

        $hospital_details = HospitalInformation::find(1);
        $wards = DB::table('wards')->whereNull('deleted_at')->pluck('name', 'id')->toArray();

        return view('pharmacy::pharmacy.print_protocol_ward_chart', compact('protocol_ward_id_arr', 'protocol_patient_id_arr', 'protocol_episode_id_arr', 'protocol_drug_dose_arr',
            'protocol_dosage_to_dispense_arr', 'wards', 'protocol_quantity_to_dispense_arr', 'protocol_instruction_arr', 'protocol_drug_ids_arr', 'hospital_details', 'protocol_drug_dose_label_arr'));
    }

    public function optical_stock_reconciliation(Request $request) {
        $optics = [];
        $item_ids_array = $request->search_items_ids;

        if ($item_ids_array) {
            $is_all_items = in_array("all_items", $item_ids_array);

            if ($is_all_items) {
                $optics = EyeGlasses::orderBy('name', 'asc')->get();
            } else{
                $optics = EyeGlasses::whereIn('id', $item_ids_array)->orderBy('name', 'asc')->get();
            }
        }

        $chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')->pluck('name', 'id')->toArray();
        $chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;

        $optic_dropdown = DB::table('eye_glasses')->whereNull('deleted_at')->orderBy('name', 'asc')->pluck('name','id')->prepend('All Optical Items', 'all_items')->toArray();
        $reasons = $this->itemService->getAllReconciliationReasonsArray();

        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();

        return view('pharmacy::pharmacy.optical_stock_reconciliation', compact('optics','reasons', 'chart_of_accounts', 'optic_dropdown', 'stock_adjustment_chart_of_account'));
    }

    public function store_pharmacy_optical_stock_count(Request $request) {
        
        $item_ids_array = $request->drug_id;
        $cost_price_array = $request->cost_price;
        $system_stock_array = $request->system_stock;
        $physical_stock_array = $request->physical_stock;
        $difference_array = $request->difference;
        $reason_for_difference_array = $request->reason_for_difference;
        $difference_in_cost_value_array=$request->difference_in_cost_value;

        $batch_sundry_ids_array = $request->batch_drug_id;
        $unique_sundry_ids_with_batches_array = array_unique($batch_sundry_ids_array);
        $batch_numbers_array = $request->batch_number;
        $batch_quantity_balances_array = $request->batch_quantity_balance;
        $batch_expiry_dates_array = $request->expiry_date;
        $batch_unit_cost= $request->batch_unit_cost;
        $batch_db_record_ids_array = $request->item_batch_watcher_id;
        $reconciliation_date=Carbon::createFromFormat('d/m/Y', $request->reconciliation_date)->toDateString();
        $batch_reason_array = $request->reconcile_reason;
        $sundries_with_initial_stock_array = is_null($request->is_initial_stock) ? [] : $request->is_initial_stock;
        $stock_adjustment_chart_of_account = ChartOfAccount::where('slug', 'stock_adjustment')->first();
        $affected_account_id = $stock_adjustment_chart_of_account->id;
        $opening_inventory_chart_of_account = ChartOfAccount::where('slug', 'opening_inventory')->first();
        $batches =[];
        
        //get the max identfier
        $max_stock_count_identifier = OpticalStockReconciliation::max('stock_count_identifier');
        $reconcile_optical_pharmacy_stock = true;
        //update batch tracking tables with reconciliations
        for ($i=0; $i < count($batch_numbers_array) ; $i++) {
            if (!is_null($batch_numbers_array[$i]) && !is_null($batch_quantity_balances_array[$i])) {
                //enforce double entry per batch
                if (in_array($batch_sundry_ids_array[$i], $sundries_with_initial_stock_array)) {
                    $affected_account_id = $opening_inventory_chart_of_account->id;//override adjustment a/c to be opening_inv
                } else{
                    $affected_account_id = $stock_adjustment_chart_of_account->id;
                }
                account_for_batch_reconciliations_difference($item_type = 7, $batch_sundry_ids_array[$i], $affected_account_id, $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $request->reconciliation_date, "pharmacy", $ward_id = null);
                $batches=$this->itemService->reconcileBatches($batches,$batch_reason_array[$i],1,$item_type = 7, $batch_sundry_ids_array[$i], $batch_numbers_array[$i], $batch_quantity_balances_array[$i], $batch_expiry_dates_array[$i], "pharmacy", $batch_unit_cost[$i]??0, $batch_db_record_ids_array[$i]??0, $ward_id=null);
            }
        }

        if (isset($request->reconcile_stock)) {
            for ($x = 0; $x < count($item_ids_array); $x++):
                /* check if the difference value is not null and then update the optical */
                if (!is_null($difference_array[$x])) {
                    $this->itemService->createOpticalReconciliation(1,$batches,$difference_in_cost_value_array[$x],$item_ids_array[$x],$physical_stock_array[$x],$difference_array[$x],$system_stock_array[$x],1,$affected_account_id,$reconciliation_date,$request->general_comment,$max_stock_count_identifier);

                    //update the system stock levels with the newly counted physical stock
                    //update only those with new physical value
                    $eye_glass = EyeGlasses::find($item_ids_array[$x]);
                    $eye_glass->pharmacy_stock = $physical_stock_array[$x];
                    if (in_array($eye_glass->id, $sundries_with_initial_stock_array)) {
                        $existing_opening_stock = is_null($eye_glass->opening_stock) ? 0 : $eye_glass->opening_stock;
                        $eye_glass->opening_stock = $existing_opening_stock + $physical_stock_array[$x];
                        $eye_glass->opening_cost_price = $cost_price_array[$x];
                        $eye_glass->opening_stock_date = $request->reconciliation_date;
                        $eye_glass->pharmacy_opening_stock = $physical_stock_array[$x];
                    }

                    $eye_glass->updated_by = Auth::id();
                    $reconcile_optical_pharmacy_stock = $eye_glass->update();
                }else $reconcile_optical_pharmacy_stock = true;
            endfor;

            if ($reconcile_optical_pharmacy_stock):
                flash('Stock levels have been reconciled')->success();
                return redirect('pharmacy_optical_stock_sheet');
            endif;
            flash('Sorry, unable to update stock')->error();
            return redirect()->back();
        }
        
    }
    public function pharmacy_optical_stock_sheet(){
        $opticals = EyeGlasses::orderBy('name', 'asc')->get();
        // getting the labs stock batches 
        $opticals= calculate_stock_value($opticals,7,'pharmacy_stock');
        if (count($opticals) < 1) {
            flash()->error("There are no registered opticals");
            return redirect('/opticals/');
        } else {
            return view('pharmacy::pharmacy.optical_stock_sheet', compact('opticals'));
        }
    }

}