<?php

namespace Modules\Insurance\Http\Controllers;

use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Streamline\Models\InsuranceClaim;

class InsuranceClaimsController extends Controller {

    public function view_incoming_authorisations(Request $request) {
        $search_text = "";

        // if patient id is active, get all records regardless of date; else search by date
        if (isset($request->patient_id) && $request->patient_id != 0) {
            $search_text .= "Patient: " . get_full_name($request->patient_id, 'id', 'first_name', 'last_name', 'patients');
            $search_text .= " (" . get_name($request->patient_id, 'id', 'number', 'patients') . ") ";

            $claims = DB::table('insurance_claims')->join('patients', 'patients.id', '=', 'insurance_claims.patient_id')
                ->where('insurance_claims.patient_id', $request->patient_id)
                ->where('insurance_claims.claim_status', 1)
                ->whereNull('insurance_claims.deleted_at')
                ->where(function($query) {
                    $query->where('insurance_claims.is_authorisation_required', 1)
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.is_item_authorisation_required)');
                })->groupBy('insurance_claims.patient_id')
                ->select(['insurance_claims.*', 'patients.first_name', 'patients.last_name', 'patients.number', DB::raw('SUM(insurance_claims.primary_plan_claim_total) AS primary_plan_claim_total_sum')])
                ->get();
        } else {
            switch ($request->search_date_by){
                case 'yesterday':
                    $end_date = Carbon::yesterday()->endOfDay();
                    $start_date = Carbon::yesterday()->startOfDay();
                    $search_text .= "Yesterday ";
                    break;
                case 'custom_date':
                    $end_date = Carbon::parse($request->start_date)->endOfDay();
                    $start_date = Carbon::parse($request->start_date)->startOfDay();
                    $search_text .= "From: " . streamline_date($start_date) . " ";
                    break;
                case 'custom_date_range':
                    $end_date = Carbon::parse($request->end_date)->endOfDay();
                    $start_date = Carbon::parse($request->start_date)->startOfDay();
                    $search_text .= "From: " . streamline_date($start_date) . " to " . streamline_date($end_date) . " ";
                    break;
                case 'today':
                default:
                    $end_date = Carbon::today()->endOfDay();
                    $start_date = Carbon::today()->startOfDay();
                    $search_text .= "Today ";
                    break;
            }

            $claims = DB::table('insurance_claims')->join('patients', 'patients.id', '=', 'insurance_claims.patient_id')
                ->whereBetween('insurance_claims.created_at', [$start_date, $end_date])
                ->where('insurance_claims.claim_status', 1)
                ->whereNull('insurance_claims.deleted_at')
                ->where(function($query) {
                    $query->where('insurance_claims.is_authorisation_required', 1)
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.is_item_authorisation_required)');
                })->groupBy('insurance_claims.patient_id')
                ->select(['insurance_claims.*', 'patients.first_name', 'patients.last_name', 'patients.number', DB::raw('SUM(insurance_claims.primary_plan_claim_total) AS primary_plan_claim_total_sum')])
                ->get();
        }

        $insurance_plans = DB::table('community_health_insurance_plans')->pluck('name', 'id');

        return view('insurance::insurance_claims.view_incoming_authorisations', compact('claims', 'insurance_plans', 'search_text'));
    }

    public function view_incoming_authorisation_details($id) {
        $claims = DB::table('insurance_claims')->where('patient_id', $id)
            ->where('claim_status', 1)
            ->whereNull('deleted_at')
            ->where(function($query) {
                $query->where('is_authorisation_required', 1)
                    ->orWhereRaw('FIND_IN_SET(1,is_item_authorisation_required)');
            })
            ->get();

        $patient_details = DB::table('patients')->join('insurance_members', 'patients.id', '=', 'insurance_members.patient_id')
            ->where('patients.id', $id)
            ->select(['patients.*', 'insurance_members.group_id', 'insurance_members.photo as insurance_photo', 'insurance_members.family_id',
                'insurance_members.membership_start_date', 'insurance_members.member_account_number', 'insurance_members.is_family_head'])
            ->first();

        $insurance_plans = DB::table('community_health_insurance_plans')->pluck('name', 'id');

        $benefits = DB::table('insurance_benefits')->pluck('name', 'id');
        $tariffs = DB::table('insurance_tariffs')->pluck('name', 'id');

        return view('insurance::insurance_claims.view_incoming_authorisation_details', compact('claims', 'tariffs', 'insurance_plans', 'benefits', 'patient_details'));
    }

    public function authorise_item($id, $position): int {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $authorisations = explode(",", $claim->is_item_authorisation_required);

            if (isset($authorisations[$position])) {
                $authorisations[$position] = 0;
                $json_array = ["authorised_by" => Auth::id(), "position" => $position, "timestamp" => date('Y-m-d H:i:s')];

                $claim->is_item_authorisation_required = implode(",", $authorisations);

                $item_authorisation_details = json_decode($claim->item_authorisation_details, true) ?? [];
                $item_authorisation_details = $item_authorisation_details + $json_array;

                $claim->item_authorisation_details = json_encode($item_authorisation_details);

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                    return 1;
                } catch (\ErrorException $exception) {
                    return 0;
                }
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    }

    public function authorise_claim($id) {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $claim->is_authorisation_required = 0;
            $claim->authorised_by = Auth::id();
            $claim->authorised_at = Carbon::now();

            // check if the claim needs to be cleared
            if ($claim->adjudication_required == 1) {
                $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                $plan_limit_error = explode(",", $claim->plan_limit_error);
                $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                $item_limit_error = explode(",", $claim->item_limit_error);

                if (!(in_array(1, $item_authorisations) || $claim->plan_validity_error == 1 ||
                    in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                    in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                    $claim->adjudication_required = 2;
                    $claim->claim_status = 2;
                }
            }

            try {
                $claim->save();
                flash("Claim has been authorised successfully")->success();
            } catch (\ErrorException $exception) {
                flash("An error occurred. Claim has not been authorised")->error();
            }

            return redirect('/insurance_claims/view_incoming_authorisation_details/' . $claim->patient_id);
        } else {
            flash("An error occurred. Claim has not been authorised")->error();

            return redirect('/insurance_claims/view_incoming_authorisations');
        }
    }

    public function authorise_all_claims(Request $request) {
        $claim_ids = explode(",", $request->claim_ids);

        foreach ($claim_ids as $id) {
            $claim = InsuranceClaim::find($id);

            if ($claim) {
                $claim->is_authorisation_required = 0;
                $claim->authorised_by = Auth::id();
                $claim->authorised_at = Carbon::now();

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                } catch (\ErrorException $exception) {}
            }
        }

        flash("Claim has been authorised successfully")->success();

        return redirect('/insurance_claims/view_incoming_authorisations');
    }

    public function incoming_claim_adjudication_errors(Request $request) {
        $search_text = "";

        // if patient id is active, get all records regardless of date; else search by date
        if (isset($request->patient_id) && $request->patient_id != 0) {
            $search_text .= "Patient: " . get_full_name($request->patient_id, 'id', 'first_name', 'last_name', 'patients');
            $search_text .= " (" . get_name($request->patient_id, 'id', 'number', 'patients') . ") ";

            $claims = DB::table('insurance_claims')->join('patients', 'patients.id', '=', 'insurance_claims.patient_id')
                ->where('insurance_claims.patient_id', $request->patient_id)
                ->where('insurance_claims.claim_status', 1)
                ->whereNull('insurance_claims.deleted_at')
                ->where(function($query) {
                    $query->where('insurance_claims.plan_validity_error', 1)
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_waiting_period_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.plan_limit_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_limit_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.item_limit_error)');
                })->groupBy('insurance_claims.patient_id')
                ->select(['insurance_claims.*', 'patients.first_name', 'patients.last_name', 'patients.number', DB::raw('SUM(insurance_claims.primary_plan_claim_total) AS primary_plan_claim_total_sum')])
                ->get();
        } else {
            switch ($request->search_date_by){
                case 'yesterday':
                    $end_date = Carbon::yesterday()->endOfDay();
                    $start_date = Carbon::yesterday()->startOfDay();
                    $search_text .= "Yesterday ";
                    break;
                case 'custom_date':
                    $end_date = Carbon::parse($request->start_date)->endOfDay();
                    $start_date = Carbon::parse($request->start_date)->startOfDay();
                    $search_text .= "From: " . streamline_date($start_date) . " ";
                    break;
                case 'custom_date_range':
                    $end_date = Carbon::parse($request->end_date)->endOfDay();
                    $start_date = Carbon::parse($request->start_date)->startOfDay();
                    $search_text .= "From: " . streamline_date($start_date) . " to " . streamline_date($end_date) . " ";
                    break;
                case 'today':
                default:
                    $end_date = Carbon::today()->endOfDay();
                    $start_date = Carbon::today()->startOfDay();
                    $search_text .= "Today ";
                    break;
            }

            $claims = DB::table('insurance_claims')->join('patients', 'patients.id', '=', 'insurance_claims.patient_id')
                ->whereBetween('insurance_claims.created_at', [$start_date, $end_date])
                ->where('insurance_claims.claim_status', 1)
                ->whereNull('insurance_claims.deleted_at')
                ->where(function($query) {
                    $query->where('insurance_claims.plan_validity_error', 1)
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_waiting_period_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.plan_limit_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_limit_error)')
                        ->orWhereRaw('FIND_IN_SET(1,insurance_claims.item_limit_error)');
                })->groupBy('insurance_claims.patient_id')
                ->select(['insurance_claims.*', 'patients.first_name', 'patients.last_name', 'patients.number', DB::raw('SUM(insurance_claims.primary_plan_claim_total) AS primary_plan_claim_total_sum')])
                ->get();
        }

        $insurance_plans = DB::table('community_health_insurance_plans')->pluck('name', 'id');

        return view('insurance::insurance_claims.incoming_claim_adjudication_errors', compact('claims', 'insurance_plans', 'search_text'));
    }

    public function incoming_claim_adjudication_errors_details($id) {
        $claims = DB::table('insurance_claims')->where('patient_id', $id)
            ->where('claim_status', 1)
            ->whereNull('deleted_at')
            ->where(function($query) {
                $query->where('insurance_claims.plan_validity_error', 1)
                    ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_waiting_period_error)')
                    ->orWhereRaw('FIND_IN_SET(1,insurance_claims.plan_limit_error)')
                    ->orWhereRaw('FIND_IN_SET(1,insurance_claims.benefit_limit_error)')
                    ->orWhereRaw('FIND_IN_SET(1,insurance_claims.item_limit_error)');
            })
            ->get();

        $patient_details = DB::table('patients')->join('insurance_members', 'patients.id', '=', 'insurance_members.patient_id')
            ->where('patients.id', $id)
            ->select(['patients.*', 'insurance_members.group_id', 'insurance_members.photo as insurance_photo', 'insurance_members.family_id',
                'insurance_members.membership_start_date', 'insurance_members.member_account_number', 'insurance_members.is_family_head', 'insurance_members.chi_plan'])
            ->first();

        $benefits = DB::table('insurance_benefits')->pluck('name', 'id');
        $tariffs = DB::table('insurance_tariffs')->pluck('name', 'id');

        return view('insurance::insurance_claims.incoming_claim_adjudication_errors_details', compact('claims', 'tariffs', 'benefits', 'patient_details'));
    }

    public function override_plan_validity($id) {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $claim->plan_validity_error = 0;
            $claim->plan_validity_error_details = json_encode(["overridden_by" => Auth::id(), "timestamp" => date('Y-m-d H:i:s')]);

            // check if the claim needs to be cleared
            if ($claim->adjudication_required == 1) {
                $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                $plan_limit_error = explode(",", $claim->plan_limit_error);
                $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                $item_limit_error = explode(",", $claim->item_limit_error);

                if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 ||
                    in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                    in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                    $claim->adjudication_required = 2;
                    $claim->claim_status = 2;
                }
            }

            try {
                $claim->save();
                flash("Plan validity error has been overridden")->success();
            } catch (\ErrorException $exception) {
                flash("An error occurred. Claim error has not been overridden")->error();
            }

            return redirect('/insurance_claims/incoming_claim_adjudication_errors_details/' . $claim->patient_id);
        } else {
            flash("An error occurred. Claim was not found")->error();

            return redirect('/insurance_claims/view_incoming_authorisations');
        }
    }

    public function override_benefit_period($id, $position): int {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $benefit_errors = explode(",", $claim->benefit_waiting_period_error);

            if (isset($benefit_errors[$position])) {
                $benefit_errors[$position] = 0;
                $json_array = ["overridden_by" => Auth::id(), "position" => $position, "timestamp" => date('Y-m-d H:i:s')];

                $claim->benefit_waiting_period_error = implode(",", $benefit_errors);

                $benefit_errors_details = (json_decode($claim->benefit_waiting_period_error_details, true) ?? []) + $json_array;

                $claim->benefit_waiting_period_error_details = json_encode($benefit_errors_details);

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                    return 1;
                } catch (\ErrorException $exception) {}
            }
        }

        return 0;
    }

    public function override_benefit_limit($id, $position): int {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $benefit_errors = explode(",", $claim->benefit_limit_error);

            if (isset($benefit_errors[$position])) {
                $benefit_errors[$position] = 0;
                $json_array = ["overridden_by" => Auth::id(), "position" => $position, "timestamp" => date('Y-m-d H:i:s')];

                $claim->benefit_limit_error = implode(",", $benefit_errors);

                $benefit_errors_details = (json_decode($claim->benefit_limit_error_details, true) ?? []) + $json_array;

                $claim->benefit_limit_error_details = json_encode($benefit_errors_details);

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                    return 1;
                } catch (\ErrorException $exception) {}
            }
        }

        return 0;
    }

    public function override_item_limit($id, $position): int {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $item_errors = explode(",", $claim->item_limit_error);

            if (isset($item_errors[$position])) {
                $item_errors[$position] = 0;
                $json_array = ["overridden_by" => Auth::id(), "position" => $position, "timestamp" => date('Y-m-d H:i:s')];

                $claim->item_limit_error = implode(",", $item_errors);

                $item_errors_details = (json_decode($claim->item_limit_error_details, true) ?? []) + $json_array;

                $claim->item_limit_error_details = json_encode($item_errors_details);

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                    return 1;
                } catch (\ErrorException $exception) {}
            }
        }

        return 0;
    }

    public function override_plan_limit($id, $position): int {
        $claim = InsuranceClaim::find($id);

        if ($claim) {
            $plan_errors = explode(",", $claim->plan_limit_error);

            if (isset($plan_errors[$position])) {
                $plan_errors[$position] = 0;
                $json_array = ["overridden_by" => Auth::id(), "position" => $position, "timestamp" => date('Y-m-d H:i:s')];

                $claim->plan_limit_error = implode(",", $plan_errors);
                $plan_errors_details = (json_decode($claim->plan_limit_error_details, true) ?? []) + $json_array;
                $claim->plan_limit_error_details = json_encode($plan_errors_details);

                // check if the claim needs to be cleared
                if ($claim->adjudication_required == 1) {
                    $item_authorisations = explode(",", $claim->is_item_authorisation_required);
                    $plan_limit_error = explode(",", $claim->plan_limit_error);
                    $benefit_waiting_period_error = explode(",", $claim->benefit_waiting_period_error);
                    $benefit_limit_error = explode(",", $claim->benefit_limit_error);
                    $item_limit_error = explode(",", $claim->item_limit_error);

                    if (!(in_array(1, $item_authorisations) || $claim->is_authorisation_required == 1 || $claim->plan_validity_error == 1 ||
                        in_array(1, $benefit_waiting_period_error) || in_array(1, $plan_limit_error) ||
                        in_array(1, $benefit_limit_error) || in_array(1, $item_limit_error))) {
                        $claim->adjudication_required = 2;
                        $claim->claim_status = 2;
                    }
                }

                try {
                    $claim->save();
                    return 1;
                } catch (\ErrorException $exception) {}
            }
        }

        return 0;
    }
}