<?php

namespace Modules\Primaya\Http\Controllers\Api;

use App\Helpers\Helper;
use App\Models\CorporateBenefit;
use App\Models\Member;
use App\Models\MemberPlan;
use App\Models\Plan;
use Illuminate\Contracts\Support\Renderable;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Validator;
use Modules\Primaya\Helpers\ApiResponse;
use Illuminate\Support\Facades\DB;

class MemberController extends Controller
{
    /**
     * Display a listing of the resource.
     * @return Renderable
     */
    public function search(Request $request)
    {
        $data = [
            'no_polis' => $request->no_polis,
            'birth_date' => $request->birth_date
        ];
        $validator = Validator::make($request->all(), [
            'no_polis' => 'required',
            'birth_date' => 'required'
        ], [
            'no_polis.required' => trans('Validation.required',['attribute' => 'Member ID']),
            'birth_date.required' => trans('Validation.required',['attribute' => 'Birth Date']),
        ]);
        if ($validator->fails())
        {
            return ApiResponse::apiResponse('Bad Request', $data, $validator->errors(), 400);
        }
        else
        {
            $members = DB::table('members')
            ->leftJoin('member_policies', 'member_policies.member_id','=', 'members.member_id')
            ->leftJoin('corporate_employees', 'corporate_employees.member_id','=', 'members.member_id')
            ->leftJoin('persons', 'persons.id', '=', 'members.person_id')
            ->where('members.member_id', '=', $request->no_polis)
            ->where('members.birth_date', '=', $request->birth_date)
            ->select(
                'members.id',
                'members.name',
                'members.member_id',
                'member_policies.policy_id',
                'persons.nik',
                'members.email',
                'members.birth_date',
                'members.gender',
                'members.marital_status',
                'members.language',
                'members.race',
                'members.relation_with_principal')
            ->first();
            if($members)
            {
                $res_data['members'] = $members;

                // $services = DB::table('member_plans')
                // ->leftJoin('plans', 'plans.id', '=', 'member_plans.plan_id')
                // ->leftJoin('services', 'services.code', '=', 'plans.service_code')
                // ->where('member_plans.member_id', $members->id)
                // ->whereNull('member_plans.deleted_at')
                // ->select('plans.service_code', 'services.name')
                // ->get();
                // $res_data['services'] = $services;

                $benefits = DB::table('member_plans')
                ->leftJoin('corporate_benefits','corporate_benefits.plan_id', '=', 'member_plans.plan_id')
                ->leftJoin('benefits', 'benefits.id', '=', 'corporate_benefits.benefit_id')
                ->leftJoin('plans', 'plans.id', '=', 'member_plans.plan_id')
                ->leftJoin('services', 'services.code', '=', 'plans.service_code')
                ->where('member_plans.member_id', '=', $members->id)
                ->where('plans.service_code','=', 'OP')
                ->select(
                    'benefits.id',
                    'benefits.description',
                    'benefits.code',
                    'corporate_benefits.corporate_id',
                    'plans.service_code',
                    'corporate_benefits.cashless_percentage',
                    'corporate_benefits.reimbursement_percentage',
                    )
                ->get();
                $res_data['benefits'] = $benefits;

                // Group Services
                // $groupServices = [];
                // foreach ($res_data['benefits'] as $benefit) {
                //     $serviceCode = $benefit->service_code;
                //     $groupServices[$serviceCode][] = [
                //         'description' => $benefit->description,
                //         'code' => $benefit->code,
                //     ];
                // }

                // $res_data['groupServices'] = $groupServices;

                // $res_data['type'] = $request->type;

                // Provider
                $providers = DB::table('organizations')
                ->where('organizations.type', '=', 'hospital')
                ->where('organizations.code', '=', 'LMS')
                ->where('organizations.corporate_id_partner', '!=', 8)
                // ->orWhere('organizations.corporate_id_partner', NULL)
                ->where('status', '=', 'active')
                ->orderBy('organizations.name','asc')
                ->select(
                    'organizations.id',
                    'organizations.name'
                )
                ->get();

                $res_data['providers'] = $providers;

                //company
                // $companies =  DB::table('corporates')
                // ->where('corporates.active', '=', 1)
                // ->select(
                //     'corporates.id',
                //     'corporates.name'
                // )
                // ->get();

                // $res_data['companies'] = $companies;

                $corporateEmployee = DB::table('corporate_employees')
                ->leftJoin('corporates', 'corporates.id', '=', 'corporate_employees.corporate_id')
                ->leftJoin('corporate_policies', 'corporate_policies.corporate_id', '=', 'corporates.id')
                // ->where('corporate_employees.status', 'ACTIVE')
                ->where('corporates.active', 1)
                ->where('corporate_policies.active', 1)
                ->where('corporate_employees.member_id', $members->id)
                ->select(
                    'corporate_policies.total_premi',
                    'corporate_employees.corporate_id'
                )
                ->first();

                $res_data['total_premi'] = $corporateEmployee->total_premi ?? 0;
                $limitRules = DB::table('member_plans')
                    ->leftJoin('plans', 'plans.id', '=', 'member_plans.plan_id')
                    ->where('member_plans.member_id', $members->id)
                    ->where('member_plans.status', 'active')
                    ->where('plans.active', 1)
                    ->value('plans.limit_rules') ?? 0;
                $res_data['limit_rules'] = $limitRules ?? 0;

                $planMember = MemberPlan::where('member_id', $members->id)->get('plan_id');

                $planId = Plan::whereIn('id', $planMember)->where('service_code', 'OP')->first();
                $benefit = CorporateBenefit::with(['benefit', 'plan'])->where('plan_id', $planId->id)->get()->toArray();
                $benefitData = [];
                if (count($benefit)){
                    foreach($benefit as $data){
                        $data['benefit']['plan_id'] = $data['plan_id'];
                        $data['benefit']['limit_amount'] = $data['limit_amount'];
                        $data['benefit']['family_plan'] = $planId->family_plan;
                        $data['benefit']['max_frequency_period'] = $data['max_frequency_period'];
                        $data['benefit']['limit_amount_plan'] = $data['plan']['limit_rules'];
                        $data['benefit']['family_plan_plans'] = $data['plan']['family_plan'];
                        array_push($benefitData, $data['benefit']);
                    }
                }
                $memberUsage = Helper::getUsageMember($corporateEmployee->corporate_id, $members->id, $benefitData);;

                $res_data['used_limit'] = json_decode($memberUsage);

                $usedLimit = json_decode($memberUsage, true);

                $totalUsed = 0;

                if (is_array($usedLimit)) {
                    foreach ($usedLimit as $value) {
                        $totalUsed += (int) $value;
                    }
                }

                $limitRules = (int) $limitRules;

                // hitung sisa
                $remainingLimit = $limitRules - $totalUsed;

                // biar gak minus
                if ($remainingLimit < 0) {
                    $remainingLimit = 0;
                }

                // set ke response
                $res_data['remaining_limit'] = $remainingLimit;
                $res_data['total_used_limit'] = $totalUsed;

                // company
                $companies = DB::table('corporates')
                    ->where('corporates.active', 1)
                    ->where('corporates.id', $corporateEmployee->corporate_id ?? null)
                    ->select(
                        'corporates.id',
                        'corporates.name'
                    )
                    ->get();

                $res_data['companies'] = $companies;

                // specialities
                // $specialities = DB::table('specialities')
                // ->select(
                //     'specialities.id',
                //     'specialities.name'
                // )
                // ->orderBy('specialities.name','asc')
                // ->get();

                // $res_data['specialities'] = $specialities;


                return ApiResponse::apiResponse("Success", $res_data, trans('Message.success'), 200);
            }
            else
            {
                return ApiResponse::apiResponse("Data Not Found", $data, trans('Message.not_found'), 404);
            }

        }
    }

    public function calculateBenefit(Request $request)
    {
        $request->validate([
            'member_id'  => 'required|integer',
            'benefit_id' => 'required|integer',
            'biaya'      => 'required|numeric|min:0'
        ]);

        $memberId  = $request->member_id;
        $benefitId = $request->benefit_id;
        $biaya     = $request->biaya;

        // ===============================
        // Ambil member
        // ===============================
        $member = DB::table('members')->where('id', $memberId)->first();

        if (!$member) {
            return ApiResponse::apiResponse("Data Not Found", [], "Member not found", 404);
        }

        // ===============================
        // Ambil corporate employee
        // ===============================
        $corporateEmployee = DB::table('corporate_employees')
            ->where('member_id', $memberId)
            ->first();

        if (!$corporateEmployee) {
            return ApiResponse::apiResponse("Data Not Found", [], "Corporate not found", 404);
        }

        // ===============================
        // Ambil Plan OP
        // ===============================
        $planMember = MemberPlan::where('member_id', $memberId)->pluck('plan_id');

        $plan = Plan::whereIn('id', $planMember)
            ->where('service_code', 'OP')
            ->first();

        if (!$plan) {
            return ApiResponse::apiResponse("Data Not Found", [], "Plan OP not found", 404);
        }

        // ===============================
        // Ambil Benefit
        // ===============================
        $corporateBenefit = CorporateBenefit::where('plan_id', $plan->id)
            ->where('benefit_id', $benefitId)
            ->first();

        if (!$corporateBenefit) {
            return ApiResponse::apiResponse("Data Not Found", [], "Benefit not found", 404);
        }

        // ===============================
        // Hitung Used Limit (PAKAI HELPER)
        // ===============================
        $allBenefits = CorporateBenefit::with(['benefit', 'plan'])
            ->where('plan_id', $plan->id)
            ->get();

        $benefitData = [];

        foreach ($allBenefits as $data) {
            $benefitData[] = [
                'id' => $data->benefit_id,
                'limit_amount' => $data->limit_amount ?? 0,
                'limit_amount_plan' => $plan->limit_rules ?? 0,
                'family_plan' => $plan->family_plan ?? 'S',
                'max_frequency_period' => $data->max_frequency_period ?? 0
            ];
        }

        $memberUsage = Helper::getUsageMember(
            $corporateEmployee->corporate_id,
            $memberId,
            $benefitData
        );

        $usedLimitArray = json_decode($memberUsage, true);

        // total semua benefit (INI YANG BENAR)
        $totalUsedLimit = is_array($usedLimitArray) ? array_sum($usedLimitArray) : 0;

        // tetap ambil per benefit (kalau mau ditampilkan)
        $usedLimit = $totalUsedLimit;

        // ===============================
        // Limit Logic
        // ===============================
        $limitPlan = $plan->limit_rules ?? 0;
        $sisaLimit = $limitPlan - $totalUsedLimit;

        if ($sisaLimit < 0) {
            $sisaLimit = 0;
        }

        if ($sisaLimit < 0) {
            $sisaLimit = 0;
        }

        // ===============================
        // Percentage Logic
        // ===============================
        $cashlessPercentage = $corporateBenefit->cashless_percentage ?? 0;

        $ditanggungPercentage = ($biaya * $cashlessPercentage) / 100;

        $ditanggungFinal = min($ditanggungPercentage, $sisaLimit);

        $sisaBayar = $biaya - $ditanggungFinal;

        // ===============================
        // Response
        // ===============================
        return ApiResponse::apiResponse("Success", [
            'member_id' => $memberId,
            'benefit_id' => $benefitId,
            'biaya' => $biaya,
            'cashless_percentage' => $cashlessPercentage,
            'limit_plan' => $limitPlan,
            'used_limit' => $usedLimit,
            'sisa_limit' => $sisaLimit,
            'ditanggung_asuransi' => $ditanggungFinal,
            'sisa_bayar_member' => $sisaBayar
        ], "Calculation successful", 200);
    }
}