<?php

namespace Modules\ClinicalData\Http\Controllers;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;
use Streamline\Http\Controllers\StreamlineSetupManager;
use Streamline\Models\Alert;
use Streamline\Models\Allergy;
use Streamline\Models\ChartOfAccount;
use Streamline\Models\InsuranceClaim;
use Streamline\Models\PatientDocument;
use Streamline\Models\PriceListCategories;
use Streamline\Models\Procedure;
use Streamline\Models\Patient;
use Streamline\Models\PatientEpisode;
use Streamline\Models\OrderedProcedure;
use Streamline\Models\ProcedureCategory;
use Streamline\Models\Consultation;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Auth;
use Illuminate\Database\QueryException;
use Illuminate\Support\Facades\Artisan;
use Streamline\Models\HmisCategory;
use Streamline\Services\StreamlineSetupServiceInterface;
class ProcedureController extends Controller {
    protected StreamlineSetupServiceInterface $setupService;
    public function __construct(StreamlineSetupServiceInterface $setupService) {
        $this->middleware('auth');
        $this->middleware('permission:procedure-list', ['only' => ['index']]);
        $this->middleware('permission:procedure-create', ['only' => ['create', 'store']]);
        $this->middleware('permission:procedure-edit', ['only' => ['edit', 'update']]);
        $this->middleware('permission:procedure-delete', ['only' => ['destroy', 'inactive', 'activate']]);
        $this->setupService = $setupService;
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index() {
        $procedures = Procedure::where('available', 1)->orderBy('name', 'asc')->get();
        $chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')->pluck('name', 'id');

        $ordered_procedures_array = [];
        $ordered_procedures = OrderedProcedure::distinct('procedure_id')->get(['procedure_id']);
        foreach ($ordered_procedures as $ordered_procedure) {
            $actual = explode(',', $ordered_procedure->procedure_id);
            foreach ($actual as $value) $ordered_procedures_array[] = $value;
        }
        $ordered_procedures_ids = array_unique($ordered_procedures_array);

        $categories = ProcedureCategory::orderBy('name', 'asc')->pluck('name', 'id');
        $hmis_categories = DB::table('hmis_categories')->orderBy('title', 'asc')->pluck('title', 'id')->toArray();

        return view('clinical_data::procedures.index', compact('procedures', 'chart_of_accounts', 'categories', 'hmis_categories', 'ordered_procedures_ids'));
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create() {
        $procedure_categories = ProcedureCategory::pluck('name', 'id')
                ->toArray();

        $procedure_categories = ['' => '- select -'] + $procedure_categories;

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

        $chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;

        $procedures = StreamlineSetupManager::get_procedures_array();

        $hmis_categories = HmisCategory::all('title', 'id','number','type', 'section_number')->toArray();

        return view('clinical_data::procedures.create', compact('procedure_categories', 'chart_of_accounts','procedures', 'hmis_categories'));
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request) {
        if (session()->has('streamline_setup')){
            //skip validation
        } else {
            request()->validate([
                'name' => 'required',
                'non_insured_price' => 'required',
                'account_id' => 'required',
                'category' => 'required',
                'procedure_type' => 'required',
                'hmis_category_inpatient'=>'nullable|required_if:procedure_type,1|required_with:hmis_category_inpatient_options',
                'hmis_category_inpatient_options'=>'nullable|required_with:hmis_category_inpatient',
                'hysterectomy_type'=>'nullable|required_if:hmis_category_inpatient_options,5'
            ]);
        }
        if (session()->has('streamline_setup')&& isset($request->skip)){
            //update the streamline setup table with the new finished step
            $this->setupService->saveStep("procedures registration", 1);
            return redirect("sundries/create");
        }

        // get all current price lists
        $price_list = PriceListCategories::withTrashed()->select('id')->get();
        $price_list_category = [];
        $price_list_price = [];

        foreach ($price_list as $record){
            array_push($price_list_category, $record->id);
            array_push($price_list_price, $request->non_insured_price);
        }

        $logged_in_user_id = Auth()->user()->id;
        $procedure = new Procedure;

        $procedure->name = $request->name;
        $procedure->code = $request->code;
        $procedure->reference_link = !empty($request->reference_link)? implode(',',$request->reference_link):null;
        $procedure->reference_text = !empty($request->reference_text)? implode(',',$request->reference_text):null;
        $procedure->non_insured_price = $request->non_insured_price;
        $procedure->insured_price = 0;
        $procedure->available = $request->available;

        if (isset($request->price_list_category_id) && isset($request->price_list_price)) {
            $procedure->price_list_category = !is_null($request->price_list_category_id) ? implode(",", $request->price_list_category_id) : null;
            $procedure->price_list_price = !is_null($request->price_list_price) ? implode(",", $request->price_list_price) : null;
        } else {
            $procedure->price_list_category = implode(",", $price_list_category);
            $procedure->price_list_price = implode(",", $price_list_price);
        }

        $procedure->account_id = $request->account_id;
        $procedure->category_id = $request->category;
        $procedure->hmis_number = $request->hmis_number;
        /*== hmis stuff =====*/
        $procedure->hmis_no_outpatient = (!empty($request->hmis_no_outpatient[0]))? implode(",", $request->hmis_no_outpatient) : null;
        $procedure->hmis_category = is_array($request->hmis_category) ? implode(",", $request->hmis_category) : "";
        $procedure->hmis_no_inpatient = ($request->hmis_category_inpatient_options != '5')? $request->hmis_category_inpatient_options:$request->hysterectomy_type;
        $procedure->hmis_category_inpatient = $request->hmis_category_inpatient;
        $procedure->hmis_inpatient_type = $request->procedure_type;
        /*===================*/
        $procedure->created_by = $logged_in_user_id;
        $procedure->updated_by = $logged_in_user_id;

        try {
            if ($procedure->name != "" && !is_null($procedure->name)) {
                $procedure->save();
            }

            flash($request->name . " Procedure has been saved")->success();

            if (session()->has('streamline_setup')) {
                if (isset($request->selected_procedures)) {
                    $selected_procedures_array = $request->selected_procedures;
                    if (!empty($selected_procedures_array)) {

                        for ($i=0; $i < count($selected_procedures_array) ; $i++) { 
                            /* try this magic to get details for the selected service */
                            $procedures_array = StreamlineSetupManager::get_procedures_array();
                            $key = array_search($selected_procedures_array[$i], array_column($procedures_array, 'Procedure_Name'));
                            $procedure_details = $procedures_array[$key];
                            /* end of magic trial */

                            $default_procedure = new Procedure;
                            $default_procedure->name = $procedure_details['Procedure_Name'];
                            $default_procedure->insured_price = 0;
                            $default_procedure->non_insured_price = 0;
                            $default_procedure->category_id = $procedure_details['Category'];
                            $default_procedure->account_id = $procedure_details['Account_Id'];
                            $default_procedure->save();
                        }
                    }
                }
                //update the streamline setup table with the new finished step
                $this->setupService->saveStep("procedures registration", 1);
                // $streamline_setup = new \Streamline\Models\StreamlineSetupStep;
                // $streamline_setup->step = "procedures registration";
                // $streamline_setup->completion_status = 1;
                // $streamline_setup->save();                  
                return redirect("sundries/create");
            }
            return redirect("/procedures/");
        } catch (QueryException $e) {
            flash("An error occurred")->error();
            return back()->withInput();
        }
    }

    /**
     * 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) {
        $procedure = Procedure::where(['id' => $id])->first();
        
        $procedure_categories = ProcedureCategory::pluck('name', 'id')
                ->toArray();
        $procedure_categories = ['' => '- select -'] + $procedure_categories;

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

        $chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;

        // $hmis_categories = DB::table('hmis_categories')->orderBy('title', 'asc')->pluck('title', 'id')->toArray();

        // $hmis_categories = ['' => '- select -'] + $hmis_categories;
        $hmis_categories_options = [];
        $hmis_categories = HmisCategory::all('title', 'id','number','type', 'section_number')->toArray();
        $categories_options = DB::table('hmis_category_options')->where('hmis_category_id', $procedure->hmis_category_inpatient)->get();
        foreach ($categories_options as $options) $hmis_categories_options[] =['id'=>$options->id, 'name'=>$options->name, 'number'=>$options->number];        
        if (!$procedure) {
            flash()->error("There is no such procedure");
            return redirect('/procedures/');
        } else {
            return view('clinical_data::procedures.edit', compact('procedure', 'procedure_categories', 'chart_of_accounts', 'hmis_categories','hmis_categories_options'));
        }
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id) {
        request()->validate([
            'name' => 'required',
            'non_insured_price' => 'required',
            'account_id' => 'required',
            'category' => 'required',
            'procedure_type' => 'required',
            'hmis_category_inpatient'=>'nullable|required_if:procedure_type,1|required_with:hmis_category_inpatient_options',
            'hmis_category_inpatient_options'=>'nullable|required_with:hmis_category_inpatient',
            'hysterectomy_type'=>'nullable|required_if:hmis_category_inpatient_options,5'
        ]);

        $logged_in_user_id = Auth()->user()->id;

        $procedure = Procedure::find($id);

        $procedure->name = $request->name;
        $procedure->code = $request->code;
        $procedure->non_insured_price = $request->non_insured_price;
        $procedure->available = $request->available;
        $procedure->reference_link = !empty($request->reference_link)? implode(',',$request->reference_link):null;
        $procedure->reference_text = !empty($request->reference_text)? implode(',',$request->reference_text):null;
        $procedure->insured_price = 0;
        $procedure->insurance = 0;
        $procedure->price_list_category = !is_null($request->price_list_category_id) ? implode(",", $request->price_list_category_id) : null;
        $procedure->price_list_price = !is_null($request->price_list_price) ? implode(",", $request->price_list_price) : null;
        $procedure->account_id = $request->account_id;
        $procedure->category_id = $request->category;
        $procedure->hmis_number = $request->hmis_number;
        /*== hmis stuff =====*/
        $procedure->hmis_no_outpatient = (!empty($request->hmis_no_outpatient[0]))? implode(",", $request->hmis_no_outpatient):null;
        // $procedure->hmis_category = implode(",", $request->hmis_category);
        /*== Hmis 108 stuff =====*/
        $procedure->hmis_no_inpatient = ($request->hmis_category_inpatient_options != '5')? $request->hmis_category_inpatient_options:$request->hysterectomy_type;
        $procedure->hmis_category_inpatient = $request->hmis_category_inpatient;
        $procedure->hmis_inpatient_type = $request->procedure_type;
        /*===================*/
        $procedure->updated_by = $logged_in_user_id;

        try {
            $procedure->save();
            flash($request->name . " Procedure has been updated")->success();
            return redirect("/procedures/");
        } catch (QueryException $e) {
            flash("An error occurred")->error();
            return back()->withInput();
        }
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id) {
        $procedure = Procedure::find($id);

        if ($procedure->delete()):
            flash("Procedure has been deleted.")->success();
            return redirect('/procedures/');
        endif;
    }

    /**
     * Display a listing of the inactive resource(s).
     *
     * @return \Illuminate\Http\Response
     */
    public function inactive() {
        $procedures = Procedure::onlyTrashed()
                ->orderBy('name', 'asc')
                ->get();

        $chart_of_accounts = DB::table('chart_of_accounts')
                ->orderBy('name', 'asc')
                ->pluck('name', 'id');

        $categories = DB::table('procedure_categories')
                ->orderBy('name', 'asc')
                ->pluck('name', 'id');

        if (count($procedures) < 1) {
            flash()->error("There is no inactive procedure");
            return redirect('/procedures/');
        } else {
            return view('clinical_data::procedures.inactive', compact('procedures', 'chart_of_accounts', 'categories'));
        }
    }

    /**
     * Activate the specified resource in storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function activate($id) {
        $procedure = Procedure::withTrashed()->find($id);

        if ($procedure->restore()):
            flash("Procedure has been activated.")->success();
            return redirect('/procedures/inactive');
        endif;
    }

    /**
     * Order procedures for the patient
     *
     * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
     */
    public function order_procedures(){
        $patient_id = session()->get('patient_id');
        $episode_id = session()->get('episode_id');
        $patient = Patient::where('id', $patient_id)->first();
        $categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
        $procedures = Procedure::where('available', 1)->orderBy('name')->pluck('name', 'id');

        $ordered_procedures = DB::table('ordered_procedures')->whereNull('deleted_at')
            ->where(['patient_id'=>$patient_id, 'episode_id'=>$episode_id, 'payment_status'=>0])
            ->first();

        $users_collection = DB::table('users')->orderBy("first_name","asc")->select("id")->get()->toArray();
        $users_array = [];
        foreach ($users_collection as $value){
            $user = \Streamline\Models\User::find($value->id);
            if (!is_null($user)) {
                $users_array[$value->id] = get_full_name($value->id, 'id', 'first_name', 'last_name', 'users');
            }
        }
        $users_array = ['' => '- select -'] + $users_array;

        $employees = DB::table('users')->whereNull('deleted_at')->orderBy('first_name', 'asc')->get();

        return view('clinical_data::procedures.order_procedures',compact('patient_id','episode_id','patient','categories','employees','procedures','ordered_procedures', 'users_array'));
    }

    /**
     * Store ordered procedures for a patient episode
     *
     * @param Request $request
     * @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
     */
    public function store_ordered_procedures(Request $request){
        if(is_null($request->procedure_id)){
            flash("No procedure has been selected")->error();
            return back()->withInput();
        } else {
            $patient_id = session()->get('patient_id');
            $episode_id = session()->get('episode_id');
            
            $procedure_ids_array = $request->procedure_id;
            $procedure_cost_array = $request->item_cost;
            $procedure_performed = [];
            $procedure_performed_id = [];

            //loop through performed procedures and update the performed column
            $performed_procedures_array = $request->performed_procedures;
            $performed_by_array = $request->procedure_performed_by;
            $procedure_performed_by_amount = $request->procedure_performed_by_amount;
            $procedure_performed_date = $request->procedure_performed_date;

            // filter to check if all entries have been filled for performed by and discard otherwise
            for ($i = 0; $i < count($procedure_ids_array); $i++) {
                if ($performed_procedures_array[$i] == 1 && ($performed_by_array[$i] != "" || $performed_by_array[$i] != null) &&
                    ($procedure_performed_by_amount[$i] != "" || $procedure_performed_by_amount[$i] != null) &&
                    ($procedure_performed_date[$i] != "" || $procedure_performed_date[$i] != null)) {
                    $procedure_performed_id[] = record_staff_that_has_performed_the_service_with_price($patient_id, $episode_id, 1, $procedure_ids_array[$i], 0,
                        $performed_by_array[$i], $procedure_performed_by_amount[$i], $procedure_performed_date[$i]);
                    $procedure_performed[] = 1;
                } else {
                    $procedure_performed[] = 0;
                    $procedure_performed_id[] = 0;
                }
            }

            if (isset($request->order_id) && get_name($request->order_id, 'id', 'payment_status', 'ordered_procedures') == 0) {
                $procedure_order = OrderedProcedure::find($request->order_id);

                // delete the previous preformed_by_ids
                try {
                    DB::table('staff_performed_services')->whereIn('id', explode(",", $procedure_order->performed_id))->delete();
                } catch (\Exception $e) {}
            } else {
                $procedure_order = new OrderedProcedure;
                $procedure_order->patient_id = $patient_id;
                $procedure_order->episode_id = $episode_id;
                $procedure_order->payment_status = 0; //0 by default to mean not paid
                $procedure_order->created_by = auth()->user()->id;
            }

            $procedure_order->procedure_id = implode(",", $procedure_ids_array);
            $procedure_order->procedure_amount = implode(",", $procedure_cost_array);
            $procedure_order->performed = implode(",", $procedure_performed);
            $procedure_order->performed_id = implode(",", $procedure_performed_id);
            $procedure_order->eye = implode(",", $request->eye);
            $procedure_order->updated_by = auth()->user()->id;
            $procedure_order->save();

            // create an insurance claim for the ordered items
            if ($request->patient_insurance_status == 1) {
                generate_insurance_claim($procedure_order->id, 2);
            }

            flash("Procedures have been saved")->success();

            // redirect to consultation or patient_episode page depending on where the user is from
            if (session()->has('redirect_to_consultation')) {
                $url = session()->get('redirect_to_consultation');
                session()->forget('redirect_to_consultation');
                return redirect($url);
            } elseif (session()->has('anc_visit_redirect')) {
                $url = session()->get('anc_visit_redirect');
                session()->forget('anc_visit_redirect');
                return redirect($url);
            } else {
                if(session()->has('previous_action') && session()->get('previous_action') == 'anc_consultation_page') {
                    return redirect("ante_natal_clinic/route");
                    session()->forget('previous_action'); 
                }
                else return redirect("/patient_episodes");
            }
        }
    }

    public function fetch_procedure_performance_fee(Request $request) {
        $patient_id = $request->patient_id;
        $patient_category_id = get_name($patient_id, 'id', 'category_id', 'patients');
        $performed_by = $request->performed_by;
        $item_id = $request->item_id;

        $price_list_category_details = \Streamline\Models\PriceListCategories::where(['patient_category_id' => $patient_category_id])->first();

        if ($price_list_category_details) {
            $price_list_category_id = $price_list_category_details->id;

            $fees_array = get_item_price_and_performance_fee_based_on_price_list_category($performed_by, $item_id, 1, $price_list_category_id);

            return ($fees_array[1] == 0) ? $fees_array[0] : $fees_array[1];
        } else {
            //do this for cases where the there are no price lists for the patient's patient_category
            $fees_array = get_item_price_and_performance_fee_array_without_price_list($item_id, $performed_by, 1);

            return ($fees_array[1] == 0) ? $fees_array[0] : $fees_array[1];
        }
    }

    public function cancel_ordered_procedures($order_id) {
        $ordered_procedure = OrderedProcedure::find($order_id);

        try {
            $ordered_procedure->delete();

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

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

            return 1;
        } catch (\Exception $exception) {
            return 0;
        }
    }

    public function get_procedure_details(Request $request) {
        $patient_id = $request->patient_id;
        $patient_insurance_status = $request->patient_insurance_status ?? 0;
        $is_inpatient = $request->is_inpatient == 1;
        $ward_id = $request->ward_id ?? 0;

        $procedure = DB::table('procedures')->find($request->procedure_id);

        if(is_numeric($patient_insurance_status) && $patient_insurance_status == 1 && $patient_id != 0 && is_numeric($patient_id)) {
            $selling_price = get_item_insurance_co_payment($patient_id, $procedure->id, 2, $is_inpatient, $ward_id);
        } else {
            // check if the patient category is attached to a price list
            $price_list_id = is_patient_category_attached_to_price_list($patient_id);
            if ($price_list_id) {
                $selling_price = get_price_list_category_price($price_list_id, 4, $procedure->id);
            } else {
                $selling_price = $procedure->non_insured_price;
            }
        }

        if (is_chi_enabled() && is_patient_item_covered($patient_id, $procedure->id, 2)) {
            $covered_by_chi = '&nbsp;&nbsp;<br><span style="color: darkgreen"><b>Covered by CHI</b></span>';
        } else {
            $covered_by_chi = "";
        }

        return json_encode([
            "selling_price" => $selling_price,
            "covered_by_chi" => $covered_by_chi,
        ]);
    }
    public function get_hmis_categories_options(Request $request) {
        $options = DB::table('hmis_category_options')->where('hmis_category_id', $request->hmis_category)->orderBy('name', 'asc')->get();
        $data ='<option value="" selected disabled>- Select HMIS category Option -</option>';
        foreach($options as $option){
            $data .= '<option value="'.$option->id.'">'.$option->name.'</option>';
        }
        return $data;
    }

    public function get_dependent_hmis_category_options(Request $request) {
        $options = DB::table('hmis_category_options')->where('parent_option', $request->parent_category)->orderBy('name', 'asc')->get();
        $data ='<option value="" selected disabled>- Select Dependent Option -</option>';
        foreach($options as $option){
            $data .= '<option value="'.$option->id.'">'.$option->name.'</option>';
        }
        return $data;
    }
}