<?php

namespace Modules\Payroll\Http\Controllers;

use Barryvdh\Snappy\Facades\SnappyPdf;
use Carbon\Carbon;
use Illuminate\Support\Facades\Auth;
use Streamline\Models\ChartOfAccount;
use Streamline\Models\Department;
use Streamline\Models\HospitalInformation;
use Streamline\Models\Payroll;
use Streamline\Models\PayrollAllowancesOrDeduction;
use Streamline\Models\PayrollCategory;
use Streamline\Models\PayrollPayments;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Database\QueryException;
use Streamline\Models\PayrollDefault;
use Streamline\Models\PayrollSalaryScale;
use Streamline\Models\StaffPositions;
use Streamline\Models\TrackReceipt;

class PayrollController extends Controller {

    public function __construct() {
        $this->middleware('auth');
        $this->middleware('permission:payroll-list');
        $this->middleware('permission:payroll-create', ['only' => ['create', 'store']]);
        $this->middleware('permission:payroll-edit', ['only' => ['edit', 'update']]);
        $this->middleware('permission:payroll-delete', ['only' => ['destroy', 'inactive', 'activate']]);
    }

    /**
     * Display a listing of the resource.
     */
    public function index() {
        $payrolls = Payroll::join('patients', 'patients.id', '=', 'payrolls.patient_id')
            ->get(['payrolls.*', 'patients.first_name', 'patients.last_name', 'patients.phone', 'patients.number']);

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        $contract_types = ['' => '-select-', 1 => 'Permanent', 2 => 'Probation', 3 => 'Contract'];
        $criteria = "";

        return view('payroll::payroll.index', compact('payrolls', 'positions', 'departments', 'banks', 'payroll_categories', 'salary_scales', 'contract_types', 'criteria'));
    }

    public function index_search(Request $request) {
        $filters = [];
        $criteria = "";

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        $contract_types = ['' => '-select-', 1 => 'Permanent', 2 => 'Probation', 3 => 'Contract'];

        if ($request->payroll_category) {
            $filters[] = ['payroll_category', '=', $request->payroll_category];
            $criteria .= 'Payroll Category (' . $payroll_categories[$request->payroll_category] . ') ';
        }

        if ($request->contract_type) {
            $filters[] = ['contract', '=', $request->contract_type];
            $criteria .= 'Contract Type (' . $contract_types[$request->contract_type] . ') ';
        }

        if ($request->payroll_scale) {
            $filters[] = ['salary_scale', '=', $request->payroll_scale];
            $criteria .= 'Payroll Scale (' . $salary_scales[$request->payroll_scale] . ') ';
        }

        if ($request->department) {
            $filters[] = ['department', '=', $request->department];
            $criteria .= 'Department (' . $departments[$request->department] . ') ';
        }

        $payrolls = Payroll::where($filters)->get();

        return view('payroll::payroll.index', compact('payrolls', 'positions', 'departments', 'banks', 'payroll_categories', 'salary_scales', 'contract_types', 'criteria'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create() {
        $positions = StaffPositions::pluck('name', 'id')->toArray();
        $positions = ['' => '- select -'] + $positions;

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id')->toArray();
        $banks = ['' => '- select -'] + $banks;

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        return view('payroll::payroll.create', compact('positions', 'departments', 'banks', 'payroll_categories', 'salary_scales'));
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request) {
        request()->validate([
            'position' => 'required',
            'department' => 'required',
            'payroll_bank_id' => 'required',
            'bank_account_number' => 'required',
            'basic_pay' => 'required',
            'payroll_category' => 'required'
        ]);

        if (is_null($request->patient_id) || $request->patient_id == 0) {
            flash('Please select a patient before submitting')->error();
            return back()->withInput();
        }

        $logged_in_user_id = Auth::user()->id;
        $payroll = new Payroll;

        $payroll->patient_id = $request->patient_id;
        $payroll->position = $request->position;

        $payroll->contract_period = json_encode([[0 => Carbon::createFromFormat('d/m/Y', $request->contract_start_date)->toDateString(), 1 => Carbon::createFromFormat('d/m/Y', $request->contract_end_date)->toDateString()]]);

        $payroll->department = $request->department;
        $payroll->payroll_category = $request->payroll_category;
        $payroll->nssf_number = $request->nssf_number;
        $payroll->tin_number = $request->tin_number;
        $payroll->salary_scale = $request->salary_scale;
        $payroll->contract = $request->contract;
        $payroll->payroll_bank_id = $request->payroll_bank_id;
        $payroll->bank_account_number = $request->bank_account_number;
        $payroll->basic_pay = $request->basic_pay;
        $payroll->social_security_amount = $request->social_security_amount;
        $payroll->tax_amount = $request->tax_amount;
        $payroll->created_by = $logged_in_user_id;
        $payroll->updated_by = $logged_in_user_id;

        try {
            $payroll->save();
            flash("Payroll has been saved")->success();
            return redirect("/payroll/");
        } catch (QueryException $e) {
            flash('An error occurred. Please try again later')->error();
            return back()->withInput();
        }
    }

    /**
     * Display the specified resource.
     */
    public function show(Payroll $payroll) {
        //
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit($id) {
        $payroll = Payroll::where(['id' => $id])->first();

        $positions = StaffPositions::pluck('name', 'id')->toArray();
        $positions = ['' => '- select -'] + $positions;

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id')->toArray();
        $banks = ['' => '- select -'] + $banks;

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        return view('payroll::payroll.edit', compact('positions', 'departments', 'banks', 'payroll_categories', 'payroll', 'salary_scales'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, $id) {
        $payroll = Payroll::find($id);

        $payroll->position = $request->position;
        $payroll->contract_period = json_encode([[0 => Carbon::createFromFormat('d/m/Y', $request->contract_start_date)->toDateString(), 1 => Carbon::createFromFormat('d/m/Y', $request->contract_end_date)->toDateString()]]);
        $payroll->department = $request->department;
        $payroll->payroll_category = $request->payroll_category;
        $payroll->nssf_number = $request->nssf_number;
        $payroll->tin_number = $request->tin_number;
        $payroll->salary_scale = $request->salary_scale;
        $payroll->contract = $request->contract;
        $payroll->payroll_bank_id = $request->payroll_bank_id;
        $payroll->bank_account_number = $request->bank_account_number;
        $payroll->basic_pay = $request->basic_pay;
        $payroll->social_security_amount = $request->social_security_amount;
        $payroll->tax_amount = $request->tax_amount;
        $payroll->updated_by = Auth::user()->id;

        try {
            $payroll->save();
            flash("Payroll has been edited")->success();
            return redirect("/payroll/view_payroll_member_details" . $id);
        } catch (QueryException $e) {
            flash('An error occurred. Please try again later')->error();
            return back()->withInput();
        }
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy($id) {
        $payroll = Payroll::find($id);

        if ($payroll->delete()) {
            flash("Payroll has been deleted.")->success();
            return redirect('/payroll/');
        }
    }

    public function deactivate($id) {
        $payroll = Payroll::find($id);

        if ($payroll->delete()) {
            flash("Payroll has been deleted.")->success();
            return redirect('/payroll/');
        }
    }

    /**
     * Display a listing of the inactive resource(s).
     */
    public function inactive() {
        $payrolls = Payroll::onlyTrashed()
            ->paginate(50);

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id');

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');

        if (count($payrolls) < 1) {
            flash()->error("There is no inactive payroll");
        }

        return view('payroll::payroll.inactive', compact('payrolls', 'positions', 'departments', 'banks'));
    }

    /**
     * Activate the specified resource in storage.
     */
    public function activate($id) {
        $payroll = Payroll::withTrashed()->find($id);

        if ($payroll->restore()) {
            flash("Payroll has been activated.")->success();
            return redirect('/payroll/inactive');
        }
    }

    /**
     * View the member details.
     */
    public function view_payroll_member_details($id) {
        $member = Payroll::where(['id' => $id])->first();

        $payments = PayrollPayments::where(['member_id' => $id])
            ->orderBy('created_at', 'desc')
            ->limit(50)->get();

        $allow_deductions = PayrollAllowancesOrDeduction::where('member_id', $id)
            ->orderBy('created_at', 'desc')
            ->limit(50)->get();

        $positions = StaffPositions::pluck('name', 'id');
        $departments = Department::pluck('name', 'id');
        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');
        $payroll_categories = PayrollCategory::pluck('name', 'id');
        $salary_scales = PayrollSalaryScale::pluck('name', 'id');

        return view('payroll::payroll.view_payroll_member_details', compact('member', 'payments', 'positions', 'departments', 'banks', 'payroll_categories', 'salary_scales',
            'allow_deductions'));
    }

    /** End Payroll Functions */

    /** Begin Payroll Payments Functions */

    /**
     * Make new payment for single staff member
     */
    public function make_payment($id) {
        // get the basic pay for the staff member
        $member = Payroll::where(['payrolls.id' => $id])->join('patients', 'patients.id', '=', 'payrolls.patient_id')
            ->select(['payrolls.*', 'patients.first_name', 'patients.last_name', 'patients.phone', 'patients.number'])->first();

        $basic_pay = $member->basic_pay;

        $months = array(
            '-select-', 'January' => 'January', 'February' => 'February', 'March' => 'March',
            'April' => 'April', 'May' => 'May', 'June' => 'June', 'July' => 'July',
            'August' => 'August', 'September' => 'September', 'October' => 'October',
            'November' => 'November', 'December' => 'December'
        );

        $years = array('-select-');

        // add years from 10 years back to now(2050? ;) )
        $end_year = date('Y') + 2;
        $start_year = $end_year - 10;

        // create array with all the years in between
        $years_range = range($start_year, $end_year);

        // add to years array to be returned to view
        foreach ($years_range as $year) {
            $years[$year] = $year;
        }

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id');

        return view('payroll::payroll.make_payment', compact('member', 'basic_pay', 'months', 'years', 'id', 'positions', 'departments'));
    }

    /**
     * Store a newly created payment in storage.
     */
    public function save_payment(Request $request) {
        $validator = Validator::make($request->all(), [
            'year' => 'required',
            'month' => 'required'
        ]);

        if ($validator->fails()) {
            $string = "";
            foreach ($validator->errors()->getMessages() as $item) {
                $string .= "{$item[0]}<br>";
            }
            return back()->withErrors($validator)->withInput();
        } else {
            $logged_in_user_id = Auth::id();
            $payroll = new PayrollPayments;

            $payroll->member_id = $request->member_id;
            $payroll->bank_id = $request->bank_id;
            $payroll->year = $request->year;
            $payroll->month = $request->month;
            $payroll->allowances = $request->allowances;
            $payroll->deductions = $request->deductions;
            $payroll->paye_payment = $request->paye_payment;
            $payroll->nssf_payment = $request->nssf_payment;
            $payroll->basic_pay = $request->basic_pay;
            $payroll->gross_pay = $request->gross_pay;
            $payroll->total_deductions = $request->total_deductions;
            $payroll->net_pay = $request->net_pay;
            $payroll->created_by = $logged_in_user_id;
            $payroll->updated_by = $logged_in_user_id;

            try {
                $payroll->save();
                flash("Payroll payment has been saved")->success();
                return redirect("/payroll/view_payslip" . $payroll->id);
            } catch (QueryException $e) {
                return back()->withInput();
            }
        }
    }

    public function add_new_department_dynamically(Request $request) {
        $department = new Department;
        $department->name = $request->name;
        $department->created_by = Auth::user()->id;
        $department->updated_by = Auth::user()->id;

        $check = Department::where('name', $request->name)->pluck('name')->first();
        if (is_null($check)) {
            try {
                $department->save();
                return $department->id;
            } catch (QueryException $e) {
                flash("An error occurred")->error();
                return back()->withInput();
            }
        } else {
            return 'false';
        }
    }

    /**
     * Display the payroll payments made
     */
    public function view_payroll_payments(Request $request) {
        if ($request->start_date) {
            $start = Carbon::parse($request->start_date)->startOfDay()->toDateTimeString();
            $end = Carbon::parse($request->end_date)->endOfDay()->toDateTimeString();
            $bank_id = $request->bank_id;
        } else {
            $start = Carbon::now()->startOfDay()->toDateTimeString();
            $end = Carbon::now()->endOfDay()->toDateTimeString();
            $bank_id = 1;
        }

        $payments = PayrollPayments::orderBy('member_id', 'asc')
            ->whereBetween('created_at', [$start, $end])
            ->where('bank_id', $bank_id)
            ->get();

        $banks = DB::table('banks')->pluck('name', 'id')->toArray();
        $banks = [0 => '- All Banks -'] + $banks;

        $member_details_first_name = Payroll::pluck('first_name', 'id');

        $member_details_last_name = Payroll::pluck('last_name', 'id');

        return view('payroll::payroll.view_payroll_payments', compact('payments', 'member_details_first_name', 'member_details_last_name', 'start', 'end', 'banks', 'bank_id'));
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy_payslip($id) {
        $payment = PayrollPayments::find($id);

        if ($payment->delete()) {
            flash("Payslip has been deleted.")->success();
            return redirect('/payroll/view_payroll_payments');
        }
    }

    /**
     * Display a listing of the inactive resource(s).
     */
    public function inactive_payslips() {
        $payments = PayrollPayments::onlyTrashed()
            ->orderBy('member_id', 'asc')
            ->paginate(50);

        $member_details_first_name = Payroll::pluck('first_name', 'id');

        $member_details_last_name = Payroll::pluck('last_name', 'id');

        if (count($payments) < 1) {
            flash()->error("There is no inactive payslip");
        }

        return view('payroll::payroll.inactive_payslips', compact('payments', 'member_details_first_name', 'member_details_last_name'));
    }

    /**
     * Activate the specified resource in storage.
     */
    public function activate_payslip($id) {
        $payslip = PayrollPayments::withTrashed()->find($id);

        if ($payslip->restore()) {
            flash("Payslip has been activated.")->success();
            return redirect('/payroll/inactive_payslips');
        }
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit_payslip($id) {
        $payslip = PayrollPayments::where(['id' => $id])->first();

        $months = array(
            '-select-', 'January' => 'January', 'February' => 'February', 'March' => 'March',
            'April' => 'April', 'May' => 'May', 'June' => 'June', 'July' => 'July',
            'August' => 'August', 'September' => 'September', 'October' => 'October',
            'November' => 'November', 'December' => 'December'
        );

        $years = array('-select-');

        // add years from 10 years back to now(2050? ;) )
        $end_year = date('Y');
        $start_year = $end_year - 10;

        // create array with all the years in between
        $years_range = range($start_year, $end_year);

        // add to years array to be returned to view
        foreach ($years_range as $year) {
            $years[$year] = $year;
        }

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id');

        $member = Payroll::where(['id' => $payslip->member_id])->first();

        return view('payroll::payroll.edit_payslip', compact('payslip', 'months', 'years', 'member', 'positions', 'departments'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update_payslip(Request $request) {
        $payroll = PayrollPayments::find($request->id);

        $payroll->year = $request->year;
        $payroll->month = $request->month;
        $payroll->headship = $request->headship;
        $payroll->calls = $request->calls;
        $payroll->other = $request->other;
        $payroll->staff_society = $request->staff_society;
        $payroll->school_fees = $request->school_fees;
        $payroll->other_debts = $request->other_debts;
        $payroll->advances = $request->advances;
        $payroll->vehicle_hire = $request->vehicle_hire;
        $payroll->patient_debts = $request->patient_debts;
        $payroll->paye_payment = $request->paye_payment;
        $payroll->nssf_payment = $request->nssf_payment;
        $payroll->basic_pay = $request->basic_pay;
        $payroll->gross_pay = $request->gross_pay;
        $payroll->total_deductions = $request->total_deductions;
        $payroll->net_pay = $request->net_pay;
        $payroll->updated_by = Auth::user()->id;

        try {
            $payroll->save();
            flash("Payslip has been edited successfully")->success();
            return redirect("/payroll/view_payroll_payments");
        } catch (QueryException $e) {
            return back()->withInput();
        }
    }

    /**
     * View payslip for specified resource.
     */
    public function view_payslip($id) {
        $payslip = PayrollPayments::where(['id' => $id])->first();

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id');

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');

        $member = Payroll::where(['id' => $payslip->member_id])->first();

        $hospital_information = HospitalInformation::first();

        return view('payroll::payroll.view_payslip', compact('payslip', 'member', 'positions', 'departments', 'banks', 'hospital_information'));
    }

    /** End Payroll Payments Functions */

    /** Begin Bulk Payroll Functions */

    public function bulk_create() {
        $contracts = ['- select -', 1 => 'Permanent', 2 => 'Probation', 3 => 'Contract'];

        $positions = StaffPositions::pluck('name', 'id')->toArray();
        $positions = ['' => '- select -'] + $positions;

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id')->toArray();
        $banks = ['' => '- select -'] + $banks;

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        return view('payroll::payroll.bulk_create', compact('positions', 'departments', 'banks', 'contracts', 'payroll_categories', 'salary_scales'));
    }

    public function bulk_store(Request $request) {
        $logged_in_user_id = Auth::user()->id;

        // actual number of records saved because those with missing fields are disregarded
        $payroll_counter = 0;

        $patients_array = $request->patient_id;
        $position_array = $request->position;
        $department_array = $request->department;
        $nssf_number_array = $request->nssf_number;
        $tin_number_array = $request->tin_number;
        $salary_scale_array = $request->salary_scale;
        $contract_array = $request->contract;
        $payroll_bank_id_array = $request->payroll_bank_id;
        $bank_account_number_array = $request->bank_account_number;
        $basic_pay_array = $request->basic_pay;
        $social_security_amount_array = $request->social_security_amount;
        $tax_amount_array = $request->tax_amount;
        $payroll_category_array = $request->payroll_category;
        $contract_start_date_array = $request->contract_start_date;
        $contract_end_date_array = $request->contract_end_date;

        for ($x = 0; $x < count($patients_array); $x++) {
            if (!is_null($patients_array[$x]) && $patients_array[$x] != 0) {
                $payroll = new Payroll;

                $payroll->patient_id = $patients_array[$x];
                $payroll->payroll_category = $payroll_category_array[$x];
                $payroll->contract_period = json_encode([[0 => Carbon::createFromFormat('d/m/Y', $contract_start_date_array[$x])->toDateString(), 1 => Carbon::createFromFormat('d/m/Y', $contract_end_date_array[$x])->toDateString()]]);
                $payroll->position = $position_array[$x];
                $payroll->department = $department_array[$x];
                $payroll->nssf_number = $nssf_number_array[$x];
                $payroll->tin_number = $tin_number_array[$x];
                $payroll->salary_scale = $salary_scale_array[$x];
                $payroll->contract = $contract_array[$x];
                $payroll->payroll_bank_id = $payroll_bank_id_array[$x];
                $payroll->bank_account_number = $bank_account_number_array[$x];
                $payroll->basic_pay = $basic_pay_array[$x];
                $payroll->social_security_amount = $social_security_amount_array[$x];
                $payroll->tax_amount = $tax_amount_array[$x];
                $payroll->created_by = $logged_in_user_id;
                $payroll->updated_by = $logged_in_user_id;

                try {
                    $payroll->save();
                    ++$payroll_counter;
                } catch (QueryException $e) {
                    flash("Unable to save employee record with patient id " . $patients_array[$x])->error();
                }
            }
        }

        flash($payroll_counter . " payroll employee records have been created")->success();
        return redirect("/payroll/");
    }

    public function bulk_edit(Request $request) {
        if (is_null($request->ids_to_edit)) {
            flash("No records have been selected for editing")->error();
            return redirect("/payroll/");
        }

        $payrolls = Payroll::whereIn('id', $request->ids_to_edit)->get();

        $contracts = ['- select -', 1 => 'Permanent', 2 => 'Probation', 3 => 'Contract'];

        $positions = StaffPositions::pluck('name', 'id')->toArray();
        $positions = ['' => '- select -'] + $positions;

        $departments = Department::pluck('name', 'id')->toArray();
        $departments = ['' => '- select -'] + $departments;

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id')->toArray();
        $banks = ['' => '- select -'] + $banks;

        $payroll_categories = PayrollCategory::pluck('name', 'id')->toArray();
        $payroll_categories = ['' => '- select -'] + $payroll_categories;

        $salary_scales = PayrollSalaryScale::pluck('name', 'id')->toArray();
        $salary_scales = ['' => '- select -'] + $salary_scales;

        if (count($payrolls) < 1) {
            flash("There is no active payroll")->error();
            return redirect("/payroll/");
        }

        return view('payroll::payroll.bulk_edit', compact('payrolls', 'positions', 'departments', 'banks', 'contracts', 'payroll_categories', 'salary_scales'));
    }

    public function bulk_update(Request $request) {
        $records_array = $request->id;
        $position_array = $request->position;
        $department_array = $request->department;
        $nssf_number_array = $request->nssf_number;
        $tin_number_array = $request->tin_number;
        $salary_scale_array = $request->salary_scale;
        $contract_array = $request->contract;
        $payroll_bank_id_array = $request->payroll_bank_id;
        $bank_account_number_array = $request->bank_account_number;
        $basic_pay_array = $request->basic_pay;
        $payroll_category_array = $request->payroll_category;
        $contract_start_date_array = $request->contract_start_date;
        $contract_end_date_array = $request->contract_end_date;
        $social_security_amount_array = $request->social_security_amount;
        $tax_amount_array = $request->tax_amount;

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

        for ($x = 0; $x < count($records_array); $x++) {
            $payroll = Payroll::find($records_array[$x]);

            $payroll->payroll_category = $payroll_category_array[$x];
            $payroll->contract_period = json_encode([[0 => Carbon::createFromFormat('d/m/Y', $contract_start_date_array[$x])->toDateString(), 1 => Carbon::createFromFormat('d/m/Y', $contract_end_date_array[$x])->toDateString()]]);
            $payroll->position = $position_array[$x];
            $payroll->department = $department_array[$x];
            $payroll->nssf_number = $nssf_number_array[$x];
            $payroll->tin_number = $tin_number_array[$x];
            $payroll->salary_scale = $salary_scale_array[$x];
            $payroll->contract = $contract_array[$x];
            $payroll->payroll_bank_id = $payroll_bank_id_array[$x];
            $payroll->bank_account_number = $bank_account_number_array[$x];
            $payroll->basic_pay = $basic_pay_array[$x];
            $payroll->social_security_amount = $social_security_amount_array[$x];
            $payroll->tax_amount = $tax_amount_array[$x];
            $payroll->updated_by = $logged_in_user_id;

            try {
                $payroll->save();
            } catch (QueryException $e) {
                //
            }
        }

        flash("Payrolls have been updated")->success();
        return redirect("/payroll/");
    }

    // for payroll members of all banks without search
    public function create_bulk_payment(Request $request) {

        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id')->toArray();

        $banks = [0 => '- All Banks -'] + $banks;

        // no banks selected
        if ($request->bank_id && $request->bank_id != 0) {
            $payrolls = Payroll::where(['payroll_bank_id' => $request->bank_id])
                ->orderBy('first_name', 'asc')
                ->paginate(50);

            if (count($payrolls) < 1) {
                flash()->error("There is no payroll for this bank");
            }

            // get bank name
            $bank_name = $banks[$request->bank_id];
            flash()->success("Showing results for " . $bank_name);

            $bank_id = $request->bank_id;
        } else {
            $payrolls = Payroll::orderBy('first_name', 'asc')
                ->paginate(50);

            if (count($payrolls) < 1) {
                flash()->error("There is no active payroll");
            }

            $bank_id = 0;
        }

        $positions = StaffPositions::pluck('name', 'id');

        $departments = Department::pluck('name', 'id');

        $months = array(
            '-select-', 'January' => 'January', 'February' => 'February', 'March' => 'March',
            'April' => 'April', 'May' => 'May', 'June' => 'June', 'July' => 'July',
            'August' => 'August', 'September' => 'September', 'October' => 'October',
            'November' => 'November', 'December' => 'December'
        );

        $years = array('-select-');

        // add years from 10 years back to now(2050? ;) )
        $end_year = date('Y');
        $start_year = $end_year - 10;

        // create array with all the years in between
        $years_range = range($start_year, $end_year);

        // add to years array to be returned to view
        foreach ($years_range as $year) {
            $years[$year] = $year;
        }

        return view('payroll::payroll.create_bulk_payment', compact('payrolls', 'positions', 'departments', 'banks', 'months', 'years', 'bank_id'));
    }

    public function store_bulk_payment(Request $request) {

        $logged_in_user_id = Auth::user()->id;
        $year = $request->year;
        $month = $request->month;

        for ($x = 0; $x < count($request->index); $x++) {
            $index = $request->index[$x];

            $payroll = new PayrollPayments;

            $payroll->member_id = $request->member_id[$index];
            $payroll->bank_id = $request->bank_id[$index];
            $payroll->year = $year;
            $payroll->month = $month;
            $payroll->paye_payment = $request->paye_payment[$index];
            $payroll->nssf_payment = $request->nssf_payment[$index];
            $payroll->basic_pay = $request->basic_pay[$index];
            $payroll->gross_pay = $request->gross_pay[$index];
            $payroll->total_deductions = $request->total_deductions[$index];
            $payroll->net_pay = $request->net_pay[$index];
            $payroll->created_by = $logged_in_user_id;
            $payroll->updated_by = $logged_in_user_id;

            try {
                $payroll->save();
            } catch (QueryException $e) {
                //
            }
        }

        flash("Payroll payments have been made")->success();
        return redirect("/payroll/view_payroll_payments");
    }

    /** End Bulk Payroll Functions */

    /**
     * Calculate nssf amount
     */
    public function calculate_nssf(Request $request) {
        $amount = $request->amount;

        $nssf_rate = PayrollDefault::where(['id' => 1])->first();

        $return_amount = $amount * $nssf_rate->nssf_rate;

        return $return_amount;
    }

    /**
     * Calculate paye amount
     */
    public function calculate_paye(Request $request) {
        $amount = $request->amount;

        $tax_rate_record = PayrollDefault::where(['id' => 1])->first();

        $taxed_amount = 0;

        if (is_null($tax_rate_record->tax_from)) {
            $tax_from = [0, 235001, 335001, 410001, 10000000];
            $tax_to = [235000, 335000, 410000, 10000000, 1000000000];
            $tax_rate = [0, 10, 20, 30, 40];
        } else {
            $tax_from = json_decode($tax_rate_record->tax_from);
            $tax_to = json_decode($tax_rate_record->tax_to);
            $tax_rate = json_decode($tax_rate_record->tax_rate);
        }

        for ($i = 0; $i < count($tax_from); $i++) {
            if ($amount >= $tax_from[$i] && $amount <= $tax_to[$i]) {
                return $taxed_amount + ceil(($amount - $tax_from[$i]) * ($tax_rate[$i] / 100));
            } else {
                $taxed_amount += ceil(($tax_to[$i] - $tax_from[$i]) * ($tax_rate[$i] / 100));
            }
        }

        return 0;
    }

    public function allowances_or_deductions($id) {
        $member = Payroll::find($id);
        $income_accounts = ChartOfAccount::where('type', 1)->pluck('name', 'id');

        $records = PayrollAllowancesOrDeduction::where('member_id', $id)->orderBy('created_at', 'desc')->get();

        return view('payroll::payroll/allowances_or_deductions', compact('member', 'records', 'income_accounts'));
    }

    public function add_allowances_or_deductions($id) {
        $member = Payroll::find($id);
        $income_accounts = ChartOfAccount::where('type', 1)->pluck('name', 'id')->toArray();
        $income_accounts = ['' => '--select--'] + $income_accounts;

        $type = ['' => '--select--', 0 => 'Allowance', 1 => 'Deduction'];

        return view('payroll::payroll/add_allowances_or_deductions', compact('member', 'income_accounts', 'type'));
    }

    public function save_allowances_or_deductions(Request $request) {
        $record = new PayrollAllowancesOrDeduction();

        // update the track_receipt table to include created receipt
        $track_receipts = new TrackReceipt;
        $track_receipts->created_by = auth()->user()->id;
        $track_receipts->reason = 'Payroll';
        $track_receipts->save();
        $receipt_number = sprintf("%04u", $track_receipts->id);

        $record->member_id = $request->member_id;
        $record->reason = $request->reason;
        $record->amount = $request->amount;
        $record->type = $request->type;
        $record->receipt_number = $receipt_number;
        $record->recurring = $request->recurring;
        $record->billed = 0;
        $record->recurring_period = $request->recurring == 1 ? $request->recurring_period : NULL;
        $record->recurring_final_date = $request->recurring_period == 1 ? Carbon::createFromFormat('d/m/Y', $request->recurring_final_date)->toDateString() : NULL;
        $record->income_account_id = $request->income_account ?? 0;
        $record->created_by = Auth::user()->id;
        $record->updated_by = Auth::user()->id;

        $record->save();
        $patient_id = get_name($request->member_id, 'id', 'patient_id', 'payrolls');

        flash("Allowance/Deduction for " . get_full_name($patient_id, 'id', 'first_name', 'last_name', 'patients') . " has been recorded")->success();
        return redirect("/payroll/allowance_or_deductions_receipt/" . $record->id);
    }

    public function allowance_or_deductions_receipt($id) {
        $hospital_information = HospitalInformation::first();
        $records = PayrollAllowancesOrDeduction::find($id);

        return view('payroll::payroll.allowance_or_deductions_receipt', compact('hospital_information', 'records'));
    }

    public function get_allowance_or_deductions(Request $request) {
        $records = PayrollAllowancesOrDeduction::where('year', $request->year)
            ->where('month', $request->month)
            ->where('member_id', $request->member_id)
            ->get();

        if (count($records) > 0) {
            $allowances = 0;
            $deductions = 0;

            foreach ($records as $record) {
                if ($record->type == 0) {
                    $allowances += $record->amount;
                } elseif ($record->type == 1) {
                    $deductions += $record->amount;
                }
            }

            return $allowances . "," . $deductions;
        } else {
            return "0,0";
        }
    }

    public function remove_allowance_deduction($id) {
        $record = PayrollAllowancesOrDeduction::find($id);
        $member_id = $record->member_id;

        try {
            $record->delete();
            flash("Record has been removed")->success();
        } catch (\Exception $exception) {
            flash("Unable to remove record. Please try again")->error();
        }

        return redirect('/payroll/allowances_or_deductions/' . $member_id);
    }

    public function print_staff_details($id) {
        $member = Payroll::where(['id' => $id])->first();

        $payments = PayrollPayments::where(['member_id' => $id])
            ->orderBy('created_at', 'desc')
            ->limit(50)->get();

        $allow_deductions = PayrollAllowancesOrDeduction::where('member_id', $id)
            ->orderBy('created_at', 'desc')
            ->limit(50)->get();

        $positions = StaffPositions::pluck('name', 'id');
        $departments = Department::pluck('name', 'id');
        $banks = ChartOfAccount::where('type', 4)->pluck('name', 'id');
        $payroll_categories = PayrollCategory::pluck('name', 'id');
        $salary_scales = PayrollSalaryScale::pluck('name', 'id');

        $data = [
            'member' => $member,
            'payments' => $payments,
            'allow_deductions' => $allow_deductions,
            'positions' => $positions,
            'departments' => $departments,
            'banks' => $banks,
            'payroll_categories' => $payroll_categories,
            'salary_scales' => $salary_scales,
        ];

        $pdf = SnappyPDF::loadView("payroll::payroll.print_staff_details", $data)
            ->setOrientation('portrait')
            ->setPaper('a4')
            ->setOption('margin-bottom', 5)
            ->setOption('margin-top', 5)
            ->setOption('footer-html', '<i>Printed On  ' . date('d-M-Y  h:ia') . '</i>');

        return $pdf->inline('Patient Billing.pdf');
    }

    public function print_allowances_or_deductions($id) {
        $member = Payroll::find($id);
        $income_accounts = ChartOfAccount::where('type', 1)->pluck('name', 'id');

        $records = PayrollAllowancesOrDeduction::where('member_id', $id)->orderBy('created_at', 'desc')->get();

        $data = [
            'member' => $member,
            'income_accounts' => $income_accounts,
            'records' => $records,
        ];

        $pdf = SnappyPDF::loadView("payroll::payroll.print_allowances_or_deductions", $data)
            ->setOrientation('portrait')
            ->setPaper('a4')
            ->setOption('margin-bottom', 5)
            ->setOption('margin-top', 5)
            ->setOption('footer-html', '<i>Printed On  ' . date('d-M-Y  h:ia') . '</i>');

        return $pdf->inline('Allowances Deductions.pdf');
    }
}