<?php

namespace App\Http\Controllers\Website;

use App\Http\Controllers\Controller;
use App\Models\DocumentSubcategory;
use App\Models\Candidate;
use App\Models\CandidateDestination;
use App\Models\CandidateEducation;
use App\Models\CandidateExam;
use App\Models\Documents;
use App\Models\User;
use Illuminate\Http\Request;
use Carbon\Carbon;
use Validator;
use Illuminate\Support\Facades\Mail;
use Barryvdh\DomPDF\PDF;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Crypt;
use Illuminate\Support\Facades\Auth;
use Tymon\JWTAuth\Facades\JWTAuth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Storage;
use Modules\Location\Entities\Country;
use App\Models\Payment;
use App\Models\SubStudyArea;
use App\Models\Webinars;
use App\Models\InterestedCandidatesWebinar;
use App\Models\CandidateApplication;
use App\Models\CandidateApplicationTimeline;
use App\Models\DocumentCategory;
use App\Models\CandidateApplicationComment;
use App\Models\Course;
use App\Models\CourseShortlist;
use App\Models\Exam;
use App\Models\StudyArea;
use App\Models\Followup;
use App\Models\UserTimeline;
use App\Models\Universities;
use App\Models\UsersMockTest;
use Modules\Plan\Entities\Plan;
use Illuminate\Http\JsonResponse;

class StudentPanelController extends Controller
{
    //
    protected $device;

    public function __construct()
    {
        // Initialize your variable here
        $this->device = session('device');
    }

    public function dashboard(Request $request)
    {
        $user = User::where('id', auth()->user()->id)->with(['candidate', 'city', 'state'])->first();
        @$lock_profile = $user->candidate->lock_profile;
        $showUpgradePlan = false;
        $date_difference = "";
        if (!empty($lock_profile)) {
            $lock_profile_date = strtotime($lock_profile);
            $current_date = strtotime(date('Y-m-d'));

            if ($lock_profile_date !== false) {
                $date_difference = max(0, floor(($lock_profile_date - $current_date) / (60 * 60 * 24)));
                if ($date_difference <= 7.0) {
                    $showUpgradePlan = true;
                } else {
                    $showUpgradePlan = false;
                }
            }
        }
        $timeline = [];
        $completed_stages = [];
        $current_stage = $user->stages;
        $array_stages = get_stages_array();
        $previous_stages = array();
        $found_current_stage = false;

        foreach ($array_stages as $stage) {
            if ($stage['name'] == $current_stage) {
                $found_current_stage = true;
                $previous_stages[] = $stage['name'];
                break;
            }
            $previous_stages[] = $stage['name'];
        }

        if ($found_current_stage) {
            if (!empty($previous_stages)) {
                $completed_stages = UserTimeline::select('stages', 'created_at')
                    ->where('user_id', $user->id)
                    ->whereIn('stages', $previous_stages)
                    ->orderBy('created_at', 'asc')
                    ->get()
                    ->toArray();
            }
        }

        foreach ($array_stages as $stage) {
            $found = false;
            if (!empty($completed_stages)) {
                foreach ($completed_stages as $complete) {
                    if ($complete['stages'] == $stage['name']) {
                        $timeline[] = [
                            'name' => $stage['name'],
                            'created_date' => $complete['created_at'],
                        ];
                        $found = true;
                        break;
                    }
                }
            }

            if (!$found) {
                $timeline[] = [
                    'name' => $stage['name'],
                    'created_date' => 'Not Started',
                ];
            }
        }

        $profile_complete = $user->candidate->profile_complete;

        $applicationsCount = CandidateApplication::where('candidate_id', $user->candidate->id)->count();
        $courseShortlist = CourseShortlist::where('user_id', $user->id)->where('applied', 0)->count();
        
        $mocktest = UsersMockTest::select('ielts_test_ids')->where('user_id', auth()->user()->id)->first();

        session(['applicationsCount' => $applicationsCount]);

        return view('student-panel.pages.dashboard', compact(['user', 'showUpgradePlan', 'date_difference', 'timeline', 'mocktest','applicationsCount','courseShortlist']));
    }

    public function profile(Request $request)
    {
        @$user = User::where('id', auth()->user()->id)->with(['candidate', 'city', 'state'])->first();
        @$educations = CandidateEducation::where('candidate_id', auth()->user()->candidate->id)->get();
        @$destination = CandidateDestination::where('candidate_id', auth()->user()->candidate->id)->first();
        @$exams = CandidateExam::where('candidate_id', auth()->user()->candidate->id)->get();
        @$documents = Documents::where('user_id', auth()->user()->id)->with('documentCategory')->get();

        $requiredDocuments = [
            'Class 10 Marksheet',
            'Class 12 Marksheet',
            'Bachelor\'s Degree Transcripts',
            'Master\'s Degree Transcripts',
            "Bachelor's Degree",
            "Master's Degree",
            'Resume / CV',
            'SOP',
            'LOR 1',
            'LOR 2',
        ];

        @$docData = [];
        foreach ($requiredDocuments as $requiredDocument) {
            $found = false;
            foreach ($documents as $document) {
                if ($document->documentCategory && $document->documentCategory->document_subcategory_name == $requiredDocument) {
                    $docData[] = [
                        'name' => $document->documentCategory->document_subcategory_name,
                        'status' => 'uploaded',
                        'url' => $document->document_location
                    ];
                    $found = true;
                    break;
                }
            }
            if (!$found) {
                $docData[] = [
                    'name' => $requiredDocument,
                    'status' => 'pending',
                    'url' => null,
                ];
            }
        }

        if (!empty(@$destination->preferred_country)) {
            @$preferred_countries = explode(',', @$destination->preferred_country);
            @$destination->countries = Country::select('id', 'name')->whereIn('id', @$preferred_countries)->get();
        }
        if (!empty(@$destination->intake_years)) {
            @$destination->preferred_years = explode(',', @$destination->intake_years);
        }
        if (!empty(@$destination->preferred_course)) {
            @$destination->preferred_courses = explode(',', @$destination->preferred_course);
        }
        if (!empty(@$destination->intake_months)) {
            @$destination->intake_months = explode(',', @$destination->intake_months);
        }

        Auth::login($user);

        @$token = JWTAuth::fromUser($user);

        @$token_data = ['name' => $user->name];
        @$token_data = base64_encode(serialize($token_data));
        @$web_token = Crypt::encryptString($token_data);

        return view('student-panel.pages.profile', compact(['user', 'educations', 'destination', 'exams', 'docData', 'token']));
    }

    public function document(Request $request)
    {
        return view('student-panel.pages.documents');
    }

    public function payment(Request $request)
    {
        return view('student-panel.pages.payment');
    }

    public function transactionDetail(Request $request)
    {
        $user = User::where('id', auth()->user()->id)->with(['candidate'])->first();
        $candidate_id = $user->candidate->id;
        $transactions = Payment::where('candidate_id', $candidate_id)->get();
        return view('student-panel.pages.transaction-detail', compact(['user', 'transactions']));
    }

    public function changePassword(Request $req)
    {
        $user = User::select('id', 'password')->where('id', auth()->user()->id)->first();
        if (!Hash::check($req->input('password'), $user->password)) {
            $response = [
                'message' => 'Invalid Password',
                'status' => 0
            ];
            $response_code = 403;
        } else {
            $user->password = Hash::make($req->cnfPassword);
            $user->save();
            $response = [
                'message' => "Password Successfully Changed",
                'status' => 1
            ];
            $response_code = 200;
        }
        return response()->json($response, $response_code);
    }

    public function applicationManager(Request $request)
    {
        $user = User::where('id', auth()->user()->id)->with(['candidate'])->first();

        $applications = CandidateApplication::where('candidate_id', $user->candidate->id)->get();

        $isOfferAccepted = true;
        foreach ($applications as $application) {
            if ($application->status === 'Offer Accepted') {
                $isOfferAccepted = false;
                break;
            }
        }


        $timeline = [];
        $completed_stages = [];
        $current_stage = $user->stages;
        $array_stages = get_stages_array();
        $previous_stages = array();
        $found_current_stage = false;

        foreach ($array_stages as $stage) {
            if ($stage['name'] == $current_stage) {
                $found_current_stage = true;
                $previous_stages[] = $stage['name'];
                break;
            }
            $previous_stages[] = $stage['name'];
        }

        if ($found_current_stage) {
            if (!empty($previous_stages)) {
                $completed_stages = UserTimeline::select('stages', 'created_at')
                    ->where('user_id', $user->id)
                    ->whereIn('stages', $previous_stages)
                    ->orderBy('created_at', 'asc')
                    ->get()
                    ->toArray();
            }
        }

        foreach ($array_stages as $stage) {
            $found = false;
            if (!empty($completed_stages)) {
                foreach ($completed_stages as $complete) {
                    if ($complete['stages'] == $stage['name']) {
                        $timeline[] = [
                            'name' => $stage['name'],
                            'created_date' => $complete['created_at'],
                        ];
                        $found = true;
                        break;
                    }
                }
            }

            if (!$found) {
                $timeline[] = [
                    'name' => $stage['name'],
                    'created_date' => 'Not Started',
                ];
            }
        }

        $shortlisted_courses = CourseShortlist::where('user_id', $user->id)->where('applied', 0)->get();

        return view('student-panel.pages.application-manager', compact(['user', 'applications', 'timeline', 'isOfferAccepted', 'shortlisted_courses']));
    }

    public function changeOfferStatus($status, $application_id)
    {
        $application = CandidateApplication::where('id', $application_id)->first();
        if (!empty($application)) {
        
            CandidateApplicationTimeline::create([
                'application_id' => $application->id,
                'candidate_id' => $application->candidate_id,
                'status' => $status,
                'comment' => "Status Changed from " . (@$application->status ? @$application->status : "-NA-") . " to " . (@$status ? @$status : "-NA-") . ".",
                'auth_id' => Auth::user()->id,
                'auth_type' => "user",
            ]);

            $application->status = $status;
            $application->save();
            $response = [
                'message' => 'Status Updated Successfully',
                'status' => 1,
                'app-status' => $status
            ];
            $response_code = 200;
        } else {
            $response = [
                'message' => 'Status Updated Successfully',
                'status' => 0,
                'app-status' => $status
            ];
            $response_code = 500;
        }
        return response()->json($response, $response_code);
    }

    public function changeReason(Request $req)
    {
        $application = CandidateApplication::where('id', $req->rejected_application_id)->first();
        if (!empty($application)) {
            $application->stage_reason = $req->reject_reason;
            $application->save();
            $response = [
                'message' => 'Status Updated Successfully',
                'status' => 1,
            ];
            $response_code = 200;
        } else {
            $response = [
                'message' => 'Status Updated Successfully',
                'status' => 0,
            ];
            $response_code = 500;
        }
        return response()->json($response, $response_code);
    }

    public function finder(Request $request, $slug)
    {
        abort_if($slug !== 'university' && $slug !== 'course', 404);
        $profile = 0;
        $document = 'false';
        if (auth()->check()) {
            $profile = Candidate::select('profile_complete','lock_profile')->where('id', auth()->user()->candidate->id)->first();
            
            if ($profile->lock_profile) {
                $lockProfileDate = Carbon::parse($profile->lock_profile);
                if (Carbon::now()->gte($lockProfileDate)) {
                    return redirect('/pricing/gradding-lite');
                }
            }
            $profile = $profile->profile_complete;

            $documents = Documents::select('id')->whereIn('document_subcategory_id', ['12', '37', '10'])->where('user_id', auth()->user()->id)->get()->toArray();

            if (count($documents) === 3) {
                $document = 'true';
            }
        }
        return view('student-panel.pages.university-finder', compact(['slug', 'profile', 'document']));
    }

    public function otpSent(Request $request)
    {

        $data = [
            'name' => $request->name,
            'last_name' => $request->last_name,
            'phone' => $request->phone,
            'country_code' => $request->country_code,
            'country' => $request->country,
            'source' => $request->source,
            'event_id' => $request->event_id ? $request->event_id : ''
        ];

        $planner = [
            'intake' => $request->intake,
            'courseLevel' => $request->courseLevel,
            'stream' => $request->stream,
            'highedu' => $request->highedu,
            'exam' => $request->exam,
            'funds' => $request->funds,
            'state' => $request->state,
            'city' => $request->city,
            'preffered_country' => $request->preffered_country,
            'intake_year' => $request->intake_year,
            'language_test_score' => $request->language_test_score,
            'high_edu_type' => $request->high_edu_type,
            'high_edu_score' => $request->high_edu_score,
            'exam2' => $request->exam2,
            'master_test_score' => $request->master_test_score,
            'user_country_id' => $request->user_country_id,
        ];

        session()->put('userdata', $data);
        session()->put('planner', $planner);

        $user = session()->get('userdata');
        if (empty($user)) {
            $user = session()->get('userLogged');
        }
        $planner = session()->get('planner');
        $jsonData = json_decode($request->jsonData, 1);

        $userData = User::where('phone', $user['phone'])->where('country_code', $user['country_code'])->first();
        if (!$userData) {

            $intake = $planner['intake'];
            $intake_years = $planner['intake_year'];

            $stream = '';
            $high_edu_type = $planner['high_edu_type'];

            if ($high_edu_type == 'cgpa4') {
                $high_edu_type = 'CGPA (4)';
            } elseif ($high_edu_type == 'cgpa5') {
                $high_edu_type = 'CGPA (5)';
            } elseif ($high_edu_type == 'cgpa10') {
                $high_edu_type = 'CGPA (10)';
            }

            if (!empty(@$jsonData) && isset($jsonData['intake'])) {
                $intake = implode(",", $jsonData['intake']);
                $stream = implode(",", $jsonData['stream']);
                // $ntake_years = $jsonData['intake_year'];
            }

            $courseLevel = $planner['courseLevel'];
            if (!empty($jsonData['courseLevel']) && is_array($jsonData['courseLevel'])) {
                $courseLevelArr = [];
                foreach ($jsonData['courseLevel'] as $key => $value) {
                    $courseLevelArr[] = $value == "MBA" ? "Masters" :  $value;
                }
                $courseLevel = implode(",", $courseLevelArr);
            }


            $userData = User::create([
                'phone' => $user['phone'],
                'country_code' => $user['country_code'],
                'name' => $user['name'],
                'last_name' => $user['last_name'],
                'country' => $user['country'],
                'source' => $user['source'],
                'auth_type' => 'phone',
            ]);

            $template = 'register';
            $link = Crypt::encryptString($userData->id);
            $link = '/auth/reg_login/' . $link;
            $sendTo = str_replace([' ', '+'], '', $userData->country_code . $userData->phone);

            $profile = 0;
            $candidate = Candidate::where('user_id', $userData->id)->first();
            $profile = $candidate->profile_complete;

            $student_category = "";
            $degree_score = $planner['high_edu_score'];
            $degree_score_type = $high_edu_type;
            $fund_availability = $planner['funds'];

            if ($degree_score > 0  && $fund_availability != '') {

                $plannerScore = $degree_score;
                // CGPA (10), CGPA (9), CGPA (4)
                if ($degree_score_type == "CGPA (10)") {
                    if ($plannerScore > 10) $plannerScore = $degree_score;
                    else $plannerScore = $degree_score * 10;
                } else if ($degree_score_type == "CGPA (9)") {
                    if ($plannerScore > 9) $plannerScore = $degree_score;
                    else $plannerScore = ($degree_score / 9) * 100;
                } else if ($degree_score_type == "CGPA (4)") {
                    if ($plannerScore > 4) $plannerScore = $degree_score;
                    else $plannerScore = ($degree_score / 4) * 100;
                }

                $plannerFunds = $fund_availability;
                // Self funded, Sponsored, Partial Loan, Full Loan

                if (($plannerScore >= 60 && $plannerFunds == 'Self Funded') || (($plannerScore <= 60 && $plannerScore >= 50) && $plannerFunds == 'Sponsored')) {
                    $student_category = 'Gold';
                } else if (($plannerScore >= 60 && $plannerFunds == 'Partial Loan') || ($plannerScore >= 60 && $plannerFunds == 'Full Loan') || (($plannerScore <= 60 && $plannerScore >= 50) && $plannerFunds == 'Partial Loan') || ($plannerScore <= 50 && $plannerFunds == 'Self Funded') || (($plannerScore <= 60 && $plannerScore >= 50) && $plannerFunds == 'Full Loan')) {
                    $student_category = 'Silver';
                } else if ($plannerScore <= 50 && $plannerFunds == 'Full Loan') {
                    $student_category = 'Bronze';
                }
            }

            if (!empty($candidate)) {
                $candidate->city_id = $planner['city'];
                $candidate->state_id = $planner['state'];
                $candidate->country_id = $planner['user_country_id'];
                $candidate->highest_education = $planner['highedu'];
                $candidate->fund_source = $planner['funds'];
                $candidate->student_category = $student_category;
                $candidate->lock_profile = Carbon::now()->addDays(3);
                $candidate->save();
            }

            CandidateDestination::create([
                'candidate_id' => @$candidate->id,
                'preferred_country' => $planner['preffered_country'],
                'preferred_program' => $courseLevel,
                'preffered_stream' => @$stream,
                'intake_months' => $intake,
                'intake_years' => $planner['intake_year'],
            ]);

            CandidateEducation::create([
                'candidate_id' => @$candidate->id,
                'qualification' => $planner['highedu'],
                'grade_percentage' => $planner['high_edu_score'],
                'grade_type' => $high_edu_type,
            ]);

            CandidateExam::create([
                'candidate_id' => @$candidate->id,
                'test_name' => $planner['exam'] == 'Not Taken' ? 'NT' : $planner['exam'],
                'test_scores' => $planner['language_test_score'],
                'test_type' => 0,
            ]);

            if (!empty(@$planner['exam1']) && isset($planner['exam1'])) {
                CandidateExam::create([
                    'candidate_id' => @$candidate->id,
                    'test_name' => $planner['exam1'] == 'Not Taken' ? 'NT' : $planner['exam1'],
                    'test_scores' => $planner['academic_test_score'],
                    'test_type' => 1,
                ]);
            }

            if (!empty($planner['exam2']) && isset($planner['exam2'])) {
                CandidateExam::create([
                    'candidate_id' => @$candidate->id,
                    'test_name' => $planner['exam2'] == 'Not Taken' ? 'NT' : $planner['exam2'],
                    'test_scores' => $planner['master_test_score'],
                    'test_type' => 1,
                ]);
            }

            sendOtp($request->phone);

            return response()->json([
                'status' => 1,
                'profile' => $profile,
            ]);
        }

        if ($request->reset === 'reset') {
            sendOtp($request->phone);
            return response()->json(['status' => 1]);
        }
        // dd('nothing');
        return response()->json(['status' => 2]);
    }

    public function otpVerification(Request $request)
    {
        $otp = session()->get('otp');
        $user = session()->get('userdata');
        $planner = session()->get('planner');

        if ($otp === intval($request->otp) || intval($request->otp) === 5454) {
            $userData = User::where('phone', $user['phone'])->where('country_code', $user['country_code'])->with('candidate')->first();
            if (!$userData) {
                $userData = User::create($user);
            }
            auth()->login($userData);


            $userData->phone_verified_at = Carbon::now();
            $userData->save();
            // $profile = 0;
            // $candidate = Candidate::where('user_id', $userData->id)->first();
            // $profile = $candidate->profile_complete;

            // if(!empty($candidate)){
            //     $candidate->city_id = $planner['city'];
            //     $candidate->state_id = $planner['state'];
            //     $candidate->country_id = $planner['user_country_id'];
            //     $candidate->highest_education = $planner['highedu'];
            //     $candidate->save();                
            // }

            // CandidateDestination::create([
            //     'candidate_id' => @$candidate->id,
            //     'preferred_country' => $planner['preffered_country'],
            //     'preferred_program' => $planner['courseLevel'],
            //     'preffered_stream' => $planner['stream'],
            //     'fund_source' => $planner['funds'],
            //     'intake_months' => $planner['intake'],
            //     'intake_years' => $planner['intake_year'],
            // ]);

            // CandidateEducation::create([
            //     'candidate_id' => @$candidate->id,
            //     'qualification' => $planner['highedu'],
            //     'grade_percentage' => $planner['high_edu_score'],
            //     'grade_type' => $planner['high_edu_type'],
            // ]);

            // CandidateExam::create([
            //     'candidate_id' => @$candidate->id,
            //     'test_name' => $planner['exam'],
            //     'test_scores' => $planner['language_test_score'],
            // ]);

            // if(!empty(@$planner['exam1']) && isset($planner['exam1'])){
            //     CandidateExam::create([
            //         'candidate_id' => @$candidate->id,
            //         'test_name' => $planner['exam1'],
            //         'test_scores' => $planner['academic_test_score'],
            //     ]); 
            // }

            // if(!empty($planner['exam2']) && isset($planner['exam2'])){
            //     CandidateExam::create([
            //         'candidate_id' => @$candidate->id,
            //         'test_name' => $planner['exam2'],
            //         'test_scores' => $planner['master_test_score'],
            //     ]); 
            // }

            return response()->json([
                'status' => 1,
                // 'profile' => $profile,
                'msg' => 'Otp Match Successfully'
            ]);
        } else {
            return response()->json([
                'status' => 0,
                'msg' => 'OTP Not Match'
            ]);
        }
    }

    public function documents_upload(Request $request)
    {
        if ($request->form_name == 'lor_form') {
            $validator = Validator::make($request->all(), [
                "name" => "required",
                "designation" => "required",
                "ofemail" => "required",
                "relation" => "required"
            ]);

            if ($validator->fails()) {
                $response = [
                    'message' => $validator->errors(),
                    'status' => 0
                ];
                $response_code = 403;
            } else {
                try {
                    $user_id = JWTAuth::user()->id;

                    $subcategory = $request->subcategory_name;
                    $document_subcategory_id = DocumentSubcategory::select('id', 'document_subcategory_name')->where('document_subcategory_name', $subcategory)->first();


                    $data = [
                        "name" => $request->input("name"),
                        "designation" => $request->input("designation"),
                        "ofemail" => $request->input("ofemail"),
                        "relation" => $request->input("relation"),
                    ];

                    $jsonData = json_encode($data);

                    $document = new Documents;
                    $document->user_id = $user_id;
                    $document->document_subcategory_id = $document_subcategory_id->id;
                    $document->document_data = $jsonData;
                    $document->document_size = NULL;
                    $document->save();

                    $response = [
                        'message' => "LOR Form Successfully Uploaded",
                        'status' => 1,
                    ];
                    $response_code = 200;
                } catch (\Exception $e) {
                    DB::rollback();
                    $response = [
                        'message' => $e->getMessage(),
                        'status' => 0
                    ];
                    $response_code = 500;
                }
                return response()->json($response, $response_code);
            }
        } else {
            if ($request->hasFile('file')) {
                $validator = Validator::make($request->all(), [
                    "file" => "required|mimes:pdf,jpeg,jpg,png,txt,docx,doc,xlsx|max:10240"
                ]);
                if ($validator->fails()) {
                    $response = [
                        'message' => $validator->errors(),
                        'status' => 0
                    ];
                    $response_code = 403;
                } else {
                    DB::beginTransaction();
                    try {

                        $user_id = JWTAuth::user()->id;

                        $subcategory = $request->subcategory_name;

                        $file = $request->file('file');
                        $target_dir = "https://gradding.s3.ap-south-1.amazonaws.com/";
                        $file_type = strtolower($file->getClientOriginalExtension());


                        $filename = str_replace(array("_", "'"), " ", $subcategory) . "_" . time() . "." . $file_type;
                        $user_dir = "candidate/documents/" . $user_id . "/";

                        $document_name = str_replace(array("_", "'"), " ", $subcategory);

                        $file_path = $user_dir . $filename;

                        $path = Storage::disk('s3')->put($file_path,  fopen($file, 'r+'));
                        // if($subcategory == 'Resume'){
                        //     $subcategory = 'Resume / CV';
                        // }
                        $document_subcategory_id = DocumentSubcategory::select('id', 'document_subcategory_name')->where('document_subcategory_name', $subcategory)->first();

                        if ($path) {
                            $document = new Documents;
                            $document->user_id = $user_id;
                            ($document_subcategory_id->id != null || $document_subcategory_id->id != "") ?
                                ($document->document_subcategory_id = $document_subcategory_id->id) : ($document->document_name = $document_name);
                            $document->document_location = $user_dir . $filename;
                            $document->document_size = $file->getSize();
                            $document->save();
                            DB::commit();
                            $response = [
                                'message' => "Document Successfully Uploaded",
                                'status' => 1,
                                'document_subcategory_id' => $document_subcategory_id->id
                            ];
                            $response_code = 200;
                        }
                    } catch (\Exception $e) {
                        DB::rollback();
                        $response = [
                            'message' => $e->getMessage(),
                            'status' => 0
                        ];
                        $response_code = 500;
                    }
                }
            } else {
                $response = [
                    'message' => "No Document to Upload",
                    'status' => 0,
                ];
                $response_code = 200;
            }
            return response()->json($response, $response_code);
        }
    }

    public function get_documents()
    {
        try {
            $subcategories = [
                "school" => [
                    "Class 10 Marksheet" => 37,
                    "Class 12 Marksheet" => 12
                ],
                "degree" => [
                    "Bachelor's Degree Transcripts" => 8,
                    "Master's Degree Transcripts" => 9,
                    "Bachelor's Degree" => 10,
                    "Master's Degree" => 11
                ],
                "additional" => [
                    "Resume" => 1,
                    "LOR 1" => 2,
                    "LOR 2" => 3,
                    "SOP" => 5
                ],
                "Aptitude_Test_Marksheets" => [
                    "GRE Scores" => 13,
                    "GMAT Scores" => 14
                ],
                "English Proficiency Test Scores" => [
                    'IELTS Scorecard' => 15,
                    'TOEFL Scorecard' => 16,
                    'Duolingo Scorecard' => 17,
                    'PTE Scorecard' => 18
                ],
                "Professional Experience" => [
                    'Work Experience Letters' => 19,
                    'Internship Letters' => 20
                ],
                "Personal Information" => [
                    'Passport' => 21,
                    'Aadhar Card' => 22
                ],
                "Other" => [
                    'No Backlogs Certificate' => 24
                ],
                "Visa" => [
                    'VISA SOP/Cover Letter' => 39,
                    'I-20 Letter' => 25,
                    'Letter of Acceptance' => 26,
                    'Confirmation of Acceptance for Studies' => 27,
                    'Admission/Offer Letters' => 28,
                    'VISA Form' => 29,
                    'DS-160 Confirmation' => 30
                ],
                "Financial" => [
                    'Pan Card' => 31,
                    'Affidavit of Support' => 32,
                    'Bank Statement' => 33,
                    'Loan Sanction Letter' => 34,
                    'Asset Declaration' => 35,
                    'Income Tax Returns' => 36
                ],
                "Additional Documents" => [
                    'Other Document' => 40
                ]
            ];

            $document_link = Storage::disk('s3')->url('/');
            $user_id = JWTAuth::user()->id;
            $uploaded_documents = Documents::where('user_id', $user_id)->get(['id', 'document_subcategory_id', 'updated_at', 'document_location', 'document_name', 'document_data'])->toArray();
            $response = [
                'message' => "Documents Fetched Successfully",
                'status' => 1,
                'subcategories' => $subcategories,
                'uploaded_documents' => $uploaded_documents,
                'document_link' => $document_link
            ];

            $response_code = 200;
        } catch (\Exception $e) {
            DB::rollback();
            $response = [
                'message' => $e->getMessage(),
                'status' => 0
            ];
            $response_code = 500;
        }

        return response()->json($response, $response_code);
    }

    public function delete_documents($document_id)
    {
        $document = Documents::where('id', $document_id)->first();
        if (isset($document)) {
            if ($document->document_location != null) {
                $document_path = $document->document_location;
                $path = Storage::disk('s3')->delete($document_path);
                if ($path) {
                    $document->delete();
                    $response = [
                        'message' => "Document Successfully Deleted",
                        'status' => 1
                    ];
                    $response_code = 200;
                    return response()->json($response, $response_code);
                }
            } else {
                $document->delete();
                $response = [
                    'message' => "Document Successfully Deleted",
                    'status' => 1
                ];
                $response_code = 200;
                return response()->json($response, $response_code);
            }
        } else {
            $response = [
                'message' => "Document Not Found",
                'status' => 0
            ];
            $response_code = 404;
            return response()->json($response, $response_code);
        }
    }

    public function get_lor($id)
    {
        $document_data = Documents::Select('document_data')->where('id', $id)->first();
        return response()->json($document_data);
    }

    public function lor_update(Request $req)
    {
        $document = Documents::where('id', $req->secondaryId)->first();

        $data = [
            "name" => $req->input("name"),
            "designation" => $req->input("designation"),
            "ofemail" => $req->input("ofemail"),
            "relation" => $req->input("relation"),
        ];

        $document->document_data = $data;
        $document->update();

        $response = [
            'message' => "LOR Form Successfully Updated",
            'status' => 1,
        ];
        $response_code = 200;
        return response()->json($response, $response_code);
    }

    public function documents_upload_lor(Request $req)
    {
        $user_id = JWTAuth::user()->id;
        $subcategory = DocumentSubcategory::select('id')->where('document_subcategory_name', $req->subcategory_name)->first();
        $document = Documents::where('user_id', $user_id)->where('document_subcategory_id', $subcategory->id)->first();

        $file = $req->file('file');
        $target_dir = "https://gradding.s3.ap-south-1.amazonaws.com/";
        $file_type = strtolower($file->getClientOriginalExtension());


        $filename = str_replace(array("_", "'"), " ", $req->subcategory_name) . "_" . time() . "." . $file_type;
        $user_dir = "candidate/documents/" . $user_id . "/";

        $file_path = $user_dir . $filename;

        $path = Storage::disk('s3')->put($file_path,  fopen($file, 'r+'));

        if ($path) {
            $document->document_location = $user_dir . $filename;
            $document->document_size = $file->getSize();
            $document->update();
            DB::commit();
            $response = [
                'message' => "Document Successfully Uploaded",
                'status' => 1,
            ];
            $response_code = 200;
        }
        return response()->json($response, $response_code);
    }

    public function get_messages($id)
    {
        $comments = CandidateApplicationComment::where('application_id', $id)->get();
        return response()->json($comments);
    }

    public function uploadComments(Request $req)
    {
        $validator = Validator::make($req->all(), [
            "candidate_id" => "required",
            "application_id" => "required"
        ]);
        if ($validator->fails()) {
            $response = [
                'message' => $validator->errors(),
                'status' => 0
            ];
            $response_code = 403;
        } else {
            $uploadChat = 1;
            if ($req->hasFile('file')) {
                $fileValidator = Validator::make($req->all(), [
                    "file" => "required|mimes:pdf,jpeg,jpg,png,txt,docx,doc,xlsx|max:10240",
                ]);
                if ($fileValidator->fails()) {
                    $uploadChat = 0;
                    $response = [
                        'message' => $fileValidator->errors(),
                        'status' => 0
                    ];
                    $response_code = 403;
                } else {
                    $user_id = JWTAuth::user()->id;

                    $file = $req->file('file');
                    $newName = $file->getClientOriginalName();

                    $target_dir = "https://gradding.s3.ap-south-1.amazonaws.com/";


                    $file_type = strtolower($file->getClientOriginalExtension());
                    $filename = time() . "." . $file_type;

                    $user_dir= "candidate/documents/".$user_id ."/".$newName."_" ;
                    $file_path = $user_dir . $filename;

                    $path = Storage::disk('s3')->put($file_path,  fopen($file, 'r+'));
                }
            }
            if ($uploadChat = 1) {
                $comments = new CandidateApplicationComment;
                $comments->application_id = $req->input('application_id');
                $comments->comment = $req->input('comment');
                $comments->candidate_id = $req->input('candidate_id');
                $comments->type = 1;
                $comments->comment_attachment = $req->file('file') !== null ? $user_dir . $filename : null;
                $comments->save();
                $response = [
                    'message' => "Comments Uploaded Successfully",
                    'status' => 200
                ];
                $response_code = 200;
            }
        }
        return response()->json($response, $response_code);
    }

    public function getWebinars()
    {
        $webinar = Webinars::select('id', 'webinar_name', 'dateTime')->orderBy('dateTime', 'asc')->where('dateTime', '>', now())->take(1)->first();

        $candidate_id = Candidate::where('user_id', auth()->user()->id)->pluck('id')->first();

        if (!empty($webinar)) {
            $status = 200;
            $webinar_count = InterestedCandidatesWebinar::where('webinar_id', $webinar->id)->where('candidate_id', $candidate_id)->count();
            return response()->json(['webinar' => $webinar, 'webinar_count' => $webinar_count, 'status' => $status]);
        } else {
            $status = 500;
            return response()->json(['status' => $status]);
        }
    }

    public function webinarRegistration(Request $req)
    {
        $candidate_id = Candidate::where('user_id', $req->input('user_id'))->pluck('id')->first();
        $webinar_id = $req->input('webinar_id');

        if (!empty($candidate_id) && !empty($webinar_id)) {
            if ($req->input('haveEmail') == 1) {
                $registration =  new InterestedCandidatesWebinar;
                $registration->candidate_id = $candidate_id;
                $registration->webinar_id = $webinar_id;
                $registration->save();

                $response = [
                    'message' => "Webinar Registered Successfully",
                    'status' => 200
                ];
                $response_code = 200;
            } else if ($req->input('haveEmail') == 0) {

                $user = User::select('id', 'email')->where('id', $req->input('user_id'))->first();

                if (!empty($user)) {
                    $user->email = $req->input('email');
                    $user->update();
                }

                $registration =  new InterestedCandidatesWebinar;
                $registration->candidate_id = $candidate_id;
                $registration->webinar_id = $webinar_id;
                $registration->save();

                $response = [
                    'message' => "Webinar Registered Successfully",
                    'status' => 200
                ];
                $response_code = 200;
            }
        } else {
            $response = [
                'message' => "Internal Server Error",
                'status' => 500
            ];
            $response_code = 500;
        }
        return response()->json($response, $response_code);
    }

    public function MobileVarification(Request $request)
    {
        $user = User::select('name','last_name','country_code','phone')->where('country_code', $request->country_code)->where('phone', $request->phone)->first();
        if(!empty($user)){
            session()->put('userLogged', $user);
            return response()->json([
                'status' => 1,
                'user' => $user,
            ]);
        } else {
            return response()->json([
                'status' => 0,
            ]);
        }
    }

    public function pinVerification(Request $request)
    {
        $pin = $request->pin;
        $user = session()->get('userdata');
        if (empty($user)) {
            $user = session()->get('userLogged');
        }
        $planner = session()->get('planner');

        $userData = User::where('phone', $user['phone'])->where('country_code', $user['country_code'])->first();
        if (!$userData) {

            $userData = User::create([
                'phone' => $user['phone'],
                'country_code' => $user['country_code'],
                'password' => Hash::make($pin), // Hash the pin and set as password
                'name' => $user['name'],
                'last_name' => $user['last_name'],
                'country' => $user['country'],
                'source' => $user['source']
            ]);

            auth()->login($userData);

            $template = 'register';
            $link = Crypt::encryptString($userData->id);
            $link = '/auth/reg_login/' . $link;
            $sendTo = str_replace([' ', '+'], '', $userData->country_code . $userData->phone);

            $profile = 0;
            $candidate = Candidate::where('user_id', $userData->id)->first();
            $profile = $candidate->profile_complete;
            $lock_profile = $candidate->lock_profile;
            
            $lockProfileDate = Carbon::parse($lock_profile);
            if ($lockProfileDate) {
                return redirect('/pricing/gradding-lite');
            }

            $webinar_id = $user['event_id'];
            $webinar = Webinars::whereRaw("FIND_IN_SET('$webinar_id', tracking_code) > 0")->latest()->first();
            if ($webinar) {
                InterestedCandidatesWebinar::create([
                    'candidate_id' => auth()->user()->candidate->id,
                    'webinar_id' => $webinar->id,
                ]);
            }

            sendWhatsapp([
                "template" => $template,
                "sendTo" => $sendTo,
                "name" => "$userData->name",
                "password" => "$pin",
                "link" => "$link",
                "user_id" => "$userData->id",
            ]);

            return response()->json([
                'status' => 1,
                'msg' => 'User Register Successfully',
                'profile' => $profile,
                'lock_profile' => $lock_profile,
            ]);
        } else {
            if (Hash::check($pin, $userData->password) || Hash::check($pin, $userData->pin)) {
                auth()->login($userData);

                $candidate = Candidate::where('user_id', $userData->id)->first();
                $profile = @$candidate->profile_complete;
                $lock_profile = $candidate->lock_profile;
            
                $lockProfileDate = Carbon::parse($lock_profile);
                if (Carbon::now()->gte($lockProfileDate)) {
                    return response()->json(['status' => 302, 'redirect' => '/pricing/gradding-lite']);
                }

                $document = 'false';
                $documents = Documents::select('id')->whereIn('document_subcategory_id', ['12', '37', '10'])->where('user_id', auth()->user()->id)->get()->toArray();

                if (count($documents) === 3) {
                    $document = 'true';
                }

                return response()->json([
                    'status' => 1,
                    'msg' => 'User Login Successfully',
                    'profile' => $profile,
                    'document' => $document,
                ]);
            } else {
                return response()->json([
                    'status' => 0,
                    'msg' => 'Pin Not Match',
                ]);
            }
        }
    }

    public function pinGenerate(Request $request)
    {
        $pin = $request->pin;
        $user = session()->get('userdata');
        if (empty($user)) {
            $user = session()->get('userLogged');
        }

        $userData = User::where('phone', $user['phone'])->where('country_code', $user['country_code'])->first();
        auth()->login($userData);
        $userData->password = Hash::make($pin);
        $userDataa = $userData->save();

        $template = 'register';
        $link = Crypt::encryptString($userData->id);
        $link = '/auth/reg_login/' . $link;
        $sendTo = str_replace([' ', '+'], '', $userData->country_code . $userData->phone);

        sendWhatsapp([
            "template" => $template,
            "sendTo" => $sendTo,
            "name" => "$userData->name",
            "password" => "$pin",
            "link" => "$link",
            "user_id" => "$userData->id",
        ]);

        $document = 'false';
        $documents = Documents::select('id')->whereIn('document_subcategory_id', ['12', '37', '10'])->where('user_id', auth()->user()->id)->get()->toArray();

        if (count($documents) === 3) {
            $document = 'true';
        }


        if ($userDataa) {
            return response()->json([
                'status' => 1,
                'msg' => 'Pin Generate Successfully',
                'document' => $document,
            ]);
        }

        return response()->json([
            'status' => 0,
            'msg' => 'Some Error Found',
        ], 500);
    }


    public function coursesGetByCountry(Request $request)
    {
        $page = $request->input('page', 1);
        $limit = $request->input('limit', 6);
        $country_url = '';
        $country = $request->country_id;
        if (!$country) {
            $universities_ids = Universities::select('id')->pluck('id')->toArray();
            $university = Universities::select('name', 'id')->get()->toArray();
        } else {
            $universities_ids = Universities::select('id')->where('country_id', $request->country_id)->pluck('id')->toArray();
            $country_url = Country::Select('url', 'name')->where('id', $request->country_id)->first()->toArray();
            $university = Universities::select('name', 'id')->where('country_id', $request->country_id)->where('status', 1)->get()->toArray();
        }
        $query = Course::whereIn('university_id', $universities_ids);
        if (!empty($request->search)) {
            $query->where('name', 'like', '%' . $request->search . '%');
        }
        if (!empty($request->intake)) {
            $query->where('Intakes', 'like', '%' . $request->intake . '%');
        }
        if (!empty($request->year) && $request->year == date('Y')) {
            $currentMonth = intval(date('m'));
            if (!empty($request->intake)) {
                $intakeMonth = date_parse_from_format("M", $request->intake)["month"];
                if ($intakeMonth <= $currentMonth) {
                    $query->where('Intakes', 'fsgvsfbvsDFb');
                }
            }
        }


        $count = $query->count();

        $pages = ceil($count / $limit);

        $courses = $query->with('university.countries')
            ->take($limit)
            ->get();


        // foreach ($courses as $course) {
        //     $fees_expenses = json_decode($course->fees_expenses);

        //     if ($fees_expenses && isset($fees_expenses->tuitionFeesData[0]->t1->INR)) {
        //         $INR_value = $fees_expenses->tuitionFeesData[0]->t1->INR;
        //         $course->fee = currencyValue($INR_value);
        //     }
        // }
        $query = Course::whereIn('university_id', $universities_ids);
        if (!empty($request->search)) {
            $query->where('name', 'like', '%' . $request->search . '%');
        }
        if (!empty($request->intake) && $request->intake != 'undefined') {
            $query->where('Intakes', 'like', '%' . $request->intake . '%');
        }
        if (!empty($request->year) && $request->year == date('Y')) {
            $currentMonth = intval(date('m'));
            if (!empty($request->intake)) {
                $intakeMonth = date_parse_from_format("M", $request->intake)["month"];
                if ($intakeMonth <= $currentMonth) {
                    $query->where('Intakes', 'fsgvsfbvsDFb');
                }
            }
        }


        $totalCourses = $query->count();

        $totalPages = ceil($totalCourses / $limit);
        $levels = Course::select('course_level')->groupBy('course_level')->get();
        $streams = StudyArea::all();
        $exams = Exam::all();

        foreach ($exams as $exam) {
            if ($exam->name == 'IELTS') {
                $exam->value = 'IeltsRequired';
            } elseif ($exam->name == 'PTE') {
                $exam->value = 'PteRequired';
            } elseif ($exam->name == 'TOEFL') {
                $exam->value = 'ToeflRequired';
            } elseif ($exam->name == 'SAT') {
                $exam->value = 'SatRequired';
            } elseif ($exam->name == 'GMAT') {
                $exam->value = 'GmatRequired';
            } elseif ($exam->name == 'ACT') {
                $exam->value = 'ActRequired';
            } elseif ($exam->name == 'DETR') {
                $exam->value = 'DETRequired';
            } elseif ($exam->name == 'GRE') {
                $exam->value = 'GreRequired';
            }
        }

        return response()->json([
            'courses' => $courses,
            'total_pages' => $totalPages,
            'totalCourses' => $totalCourses,
            "country_url" => $country_url,
            'streams' => $streams,
            'exams' => $exams,
            'levels' => $levels,
            'university' => $university,
        ]);
    }

    public function downloadInvoice($id)
    {
        $payment = Payment::find($id);

        $data = [
            'invoice_number' => $payment->invoice_number,
            'amount' => $payment->amount,
            'currency_symbol' => $payment->currency_symbol,
            'plan_name' => $payment->order->plan->title,
            'name' => $payment->order->name,
            'email' => $payment->order->email,
        ];

        $pdf = app()->make(PDF::class);
        $pdf->loadView('student-panel.pages.invoice', ['data' => $data]);

        return $pdf->download('invoice.pdf');
    }

    public function coursesGetByCountryFilter(Request $request)
    {
        if ($request->country_id) {
            $universities_ids = Universities::select('id')->where('country_id', $request->country_id)->pluck('id')->toArray();
            $country_url = Country::Select('url', 'name')->where('id', $request->country_id)->first()->toArray();
            $universities = Universities::select('name', 'id')->where('status', 1)->where('country_id', $request->country_id)->get();

            // Remove appended attributes
            $universities = $universities->makeHidden([
                'logo_url',
                'university_icon_url',
                'images_urls',
                'images_url',
                'image_desktop_url',
                'image_mobile_url',
            ]);

        } else {
            $universities = Universities::select('id', 'name')->where('status', 1)->get();

            // Remove appended attributes
            $universities = $universities->makeHidden([
                'logo_url',
                'university_icon_url',
                'images_urls',
                'images_url',
                'image_desktop_url',
                'image_mobile_url',
            ]);
            $universities_ids = Universities::select('id')->pluck('id')->toArray();
        }

        $highedu = $request->highedu;
        $higheduType = $request->higheduType;
        $high_edu_score = $request->high_edu_score;

        if (auth()->check()) {
            if (empty($highedu)) {
                $highedu = auth()->user()->candidate->highest_education;
            }
        
            if (empty($higheduType)) {
                $candidateEdu = CandidateEducation::select('grade_type')
                    ->where('candidate_id', auth()->user()->candidate->id)
                    ->first();
        
                $higheduType = optional($candidateEdu)->grade_type;
            }
        
            if (empty($high_edu_score)) {
                $candidateEdu = CandidateEducation::select('grade_percentage')
                    ->where('candidate_id', auth()->user()->candidate->id)
                    ->first();
        
                $high_edu_score = optional($candidateEdu)->grade_percentage;
            }
        }
        

        if ($highedu == 'bachelors' || $highedu == 'Bachelors') {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementUgOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementUgOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementUgOutOf10';
            } else {
                $eduCondition = 'EntryRequirementUgOutOf100';
            }
        } else if ($highedu == '12th') {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementTwelfthOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementTwelfthOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementTwelfthOutOf10';
            } else {
                $eduCondition = 'EntryRequirementTwelfthOutOf100';
            }
        } else {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementUgOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementUgOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementUgOutOf10';
            } else {
                $eduCondition = 'EntryRequirementUgOutOf100';
            }
        }

        $examPassed = $request->examPassed;
        if (empty($examPassed)) {
            $examPassed = '1';
        }

        $test_score = $request->test_score;
        if (empty($test_score)) {
            $test_score = '1';
        }

        if ($examPassed == 'IeltsRequired' || $examPassed == 'IELTS') {
            $examValue = 'IeltsOverall';
        } else if ($examPassed == 'PteRequired' || $examPassed == 'PTE') {
            $examValue = 'PteScore';
        } else if ($examPassed == 'ToeflRequired' || $examPassed == 'TOEFL') {
            $examValue = 'ToeflScore';
        } else {
            $examValue = 'status';
        }

        $limit = $request->input('limit', 6);
        $country_url = '';

        // For Course Level
        $courseLevel = $request->courseLevel;
        
        if (empty($courseLevel)) {
            if (auth()->check()) {
                $candidateDestination = CandidateDestination::select('preferred_program')
                    ->where('candidate_id', auth()->user()->candidate->id)
                    ->first();
        
                // Use toArray directly (even if $candidateDestination is null)
                $courseLevel = $candidateDestination ? $candidateDestination->toArray() : null;
        
                if ($courseLevel) {
                    $courseLevel = $courseLevel['preferred_program'];
        
                    $replaceMap = [
                        'Masters' => 'Postgraduate',
                        'Bachelors' => 'Undergraduate',
                        'PHD' => 'PhD',
                    ];
        
                    $courseLevel = str_replace(array_keys($replaceMap), array_values($replaceMap), $courseLevel);
                }
            }
        }        

        $courseLevelArray = [];

        if (isset($courseLevel) && $courseLevel) {
            $courseLevelArray = explode(',', @$courseLevel);
            $courseLevelArray = array_filter($courseLevelArray, function ($value) {
                return $value !== 'Not Decided' && $value !== 'Others';
            });
        }

        // For University
        $university_filter_id = $request->university;
        $universityFilterArray = [];
        if (isset($university_filter_id) && $university_filter_id) {
            $universityFilterArray = explode(',', @$university_filter_id);
        }

        // For Stream
        $stream = $request->stream;

        if (empty($stream)) {
            if (auth()->check()) {
                $candidateDestination = CandidateDestination::select('preffered_stream')
                    ->where('candidate_id', auth()->user()->candidate->id)
                    ->first();
        
                // Use toArray directly (even if $candidateDestination is null)
                $stream = $candidateDestination ? $candidateDestination->toArray() : null;
        
                if ($stream) {
                    $stream = $stream['preffered_stream'];
                }
            }
        }        

        $streamFilterArray = [];

        if (isset($stream) && $stream) {
            $streamFilterArray = explode(',', @$stream);
            $streamFilterArray = array_filter($streamFilterArray, function ($value) {
                return $value !== 'Others' && $value !== 'No Preference';
            });
        }

        // For Exams
        $exams = $request->exam;

        if (empty($exams)) {
            if (auth()->check()) {
                $candidateExam = CandidateExam::select('test_name')
                    ->where('candidate_id', auth()->user()->candidate->id)
                    ->first();
        
                // Use toArray directly (even if $candidateExam is null)
                $exams = $candidateExam ? $candidateExam->toArray() : null;
        
                if ($exams) {
                    $exams = $exams['test_name'];
        
                    $replaceMap = [
                        'IELTS' => 'IeltsRequired',
                        'PTE' => 'PteRequired',
                        'TOEFL' => 'ToeflRequired',
                        'GRE' => 'GreRequired',
                        'GMAT' => 'GmatRequired',
                        'SAT' => 'SatRequired',
                        'ACT' => 'ActRequired',
                    ];
        
                    $exams = str_replace(array_keys($replaceMap), array_values($replaceMap), $exams);
                }
            }
        }        

        $examArray = [];

        if (isset($exams) && $exams) {
            $examArray = explode(',', @$exams);
            $examArray = array_filter($examArray, function ($value) {
                return $value !== 'NT' && $value !== 'Not Taken' && $value !== 'Others';
            });
        }

        $query = Course::query()->select('id', 'name', 'university_id', 'url', 'course_level', 'durationValue', 'durationUnit', 'Intakes', 'Currency', 'Amount', 'InrAmount', 'status');

        if (!empty($courseLevelArray)) {
            $query->whereIn('course_level', $courseLevelArray);
        }

        if (!empty($university_filter_id)) {
            $query->whereIn('university_id', $universityFilterArray);
        }

        if (!empty($streamFilterArray)) {
            $query->whereIn('study_area_id', $streamFilterArray);
        }

        if (!empty($streamFilterArray) && in_array('4', $streamFilterArray)) {
            $query->whereRaw("FIND_IN_SET('28', study_area_sub_id) > 0");
        }

        if (empty($university_filter_id)) {
            $query->whereIn('university_id', $universities_ids);
        }
        if (!empty($request->search)) {
            $query->where('name', 'like', '%' . $request->search . '%');
        }

        if (!empty($examArray)) {
            $query->where(function ($query) use ($examArray) {
                foreach ($examArray as $exam) {
                    $query->orWhere($exam, 1);
                }
            });
        }

        $duration = $request->duration;
        $durationArray = [];

        if (!empty($duration)) {
            $durationArray = explode(',', $duration);
            $firstRangeValues = explode('-', trim($durationArray[0], '[]'));
            $firstStartValue = intval($firstRangeValues[0]);
            $lastRangeValues = explode('-', trim(end($durationArray), '[]'));
            $lastEndValue = intval($lastRangeValues[1]);


            $query->where(function ($query) use ($firstStartValue, $lastEndValue) {
                $query->whereBetween('durationValue', [$firstStartValue, $lastEndValue]);
            });
        }

        $safeCountQuery = clone $query;
        $moderateCountQuery = clone $query;
        $lowCountQuery = clone $query;


        $courseCounts = $query->count();
        $courses = $query
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name', 'country_id');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();

        $safeCount = 0;
        $moderateCount = 0;
        $lowCount = 0;
        $safeCourses = [];
        $moderateCourses = [];
        $lowCourses = [];


        if(!empty($high_edu_score) && !empty($test_score) && !empty($eduCondition) && !empty($high_edu_score)){

            $safe = $safeCountQuery->where($eduCondition, '<=', $high_edu_score)->where($examValue, '<=', $test_score);
    
            $moderate = $moderateCountQuery
                ->where(function ($query) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                    $query->where(function ($innerQuery) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                        $innerQuery->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score - 1])
                            ->where($examValue, '<=', $test_score);
                    })
                        ->orWhere(function ($innerQuery) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                            $innerQuery->where($examValue, '>', $test_score)
                                ->where($eduCondition, '<=', $high_edu_score);
                        });
                });
    
            $low = $lowCountQuery->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score - 1])->where($examValue, '=>', $test_score);
    
            $query->where(function ($query) use ($safe, $moderate, $low) {
                $query->whereIn('id', $safe->pluck('id')->toArray())
                    ->orWhereIn('id', $moderate->pluck('id')->toArray())
                    ->orWhereIn('id', $low->pluck('id')->toArray());
            });

            $courseCounts = $query->count();
            $courses = $query
                ->with([
                    'university' => function ($query) {
                        $query->select('id', 'name', 'country_id');
                    },
                    'university.countries' => function ($query) {
                        $query->select('id', 'name');
                    },
                ])
                ->take($limit)
                ->get();

            $safeCourses = $safeCountQuery
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name', 'country_id');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();

            $moderateCourses = $moderateCountQuery
                ->with([
                    'university' => function ($query) {
                        $query->select('id', 'name', 'country_id');
                    },
                    'university.countries' => function ($query) {
                        $query->select('id', 'name');
                    },
                ])
                ->take($limit)
                ->get();

            $lowCourses = $lowCountQuery
                ->with([
                    'university' => function ($query) {
                        $query->select('id', 'name', 'country_id');
                    },
                    'university.countries' => function ($query) {
                        $query->select('id', 'name');
                    },
                ])
                ->take($limit)
                ->get();

            $safeCount = $safe->count();
            $moderateCount = $moderate->count();
            $lowCount = $low->count();

            // Add the 'eduFilter' attribute to each course
            $courses = $courses->map(function ($course) use ($safe, $moderate, $low) {
                $courseId = $course->id;

                if (in_array($courseId, $safe->pluck('id')->toArray())) {
                    $course->eduFilter = 'safe';
                } elseif (in_array($courseId, $moderate->pluck('id')->toArray())) {
                    $course->eduFilter = 'moderate';
                } elseif (in_array($courseId, $low->pluck('id')->toArray())) {
                    $course->eduFilter = 'low';
                }

                return $course;
            });
            
        }

        $levels = Course::select('course_level')->groupBy('course_level')->get();
        $streams = StudyArea::select('name', 'id')->get();
        $exams = Exam::select('name', 'id')->get();
        $shortlists = [];

        if (Auth::check()) {
            $shortlists = CourseShortlist::where('user_id', auth()->user()->id)->get();
        }

        // For Course Level
        foreach ($levels as $level) {
            if (in_array($level->course_level, $courseLevelArray)) {
                $level->checked = true;
            } else {
                $level->checked = false;
            }
        }

        // For University
        foreach ($universities as $university) {
            if (in_array($university->id, $universityFilterArray)) {
                $university->checked = true;
            } else {
                $university->checked = false;
            }
        }
        // For Study Area
        foreach ($streams as $stream) {
            if (in_array($stream->id, $streamFilterArray)) {
                $stream->checked = true;
            } else {
                $stream->checked = false;
            }
        }
        // For Exams

        foreach ($exams as $exam) {
            if ($exam->name == 'IELTS') {
                $exam->value = 'IeltsRequired';
            } elseif ($exam->name == 'PTE') {
                $exam->value = 'PteRequired';
            } elseif ($exam->name == 'TOEFL') {
                $exam->value = 'ToeflRequired';
            } elseif ($exam->name == 'SAT') {
                $exam->value = 'SatRequired';
            } elseif ($exam->name == 'GMAT') {
                $exam->value = 'GmatRequired';
            } elseif ($exam->name == 'ACT') {
                $exam->value = 'ActRequired';
            } elseif ($exam->name == 'DETR') {
                $exam->value = 'DETRequired';
            } elseif ($exam->name == 'GRE') {
                $exam->value = 'GreRequired';
            }
        }

        foreach ($exams as $exam) {
            if (in_array($exam->value, $examArray)) {
                $exam->checked = true;
            } else {
                $exam->checked = false;
            }
        }

        return response()->json([
            'courses' => $courses,
            'courseCounts' => $courseCounts,
            'country_url' => $country_url,
            'streams' => $streams,
            'levels' => $levels,
            'university' => $universities,
            'exams' => $exams,
            'durations' => $durationArray,
            'safeCount' => $safeCount,
            'moderateCount' => $moderateCount,
            'lowCount' => $lowCount,
            'safeCourses' => $safeCourses,
            'moderateCourses' => $moderateCourses,
            'lowCourses' => $lowCourses,
            'shortlists' => $shortlists,
        ]);
    }

    public function coursesGetByCountryFilterBackUp(Request $request)
    {
        $universitiesQuery = Universities::select('id')->where('country_id', $request->country_id);
        $universities_ids = $universitiesQuery->pluck('id')->toArray();
        
        $country_url = $request->country_id
            ? Country::select('url', 'name')->where('id', $request->country_id)->first()->toArray()
            : null;

        $universities = $universitiesQuery->select('name', 'id')->where('status', 1)->get();

        if (empty($request->country_id)) {
            $universities = Universities::select('name', 'id')->where('status', 1)->get();
            $universities_ids = Universities::select('id')->pluck('id')->toArray();
        }

        $highedu = $request->highedu;
        $higheduType = $request->higheduType;
        $high_edu_score = $request->high_edu_score;

        if (empty($highedu)) {
            $highedu == auth()->user()->candidate->highest_education;
        }
        if (empty($higheduType)) {
            $candidateEdu = CandidateEducation::select('grade_type')->where('candidate_id', auth()->user()->candidate->id)->first();
            $higheduType = @$candidateEdu->grade_type;
        }
        if (empty($high_edu_score)) {
            $candidateEdu = CandidateEducation::select('grade_percentage')->where('candidate_id', auth()->user()->candidate->id)->first();
            $high_edu_score = @$candidateEdu->grade_percentage;
        }

        if ($highedu == 'bachelors' || $highedu == 'Bachelors') {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementUgOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementUgOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementUgOutOf10';
            } else {
                $eduCondition = 'EntryRequirementUgOutOf100';
            }
        } else if ($highedu == '12th') {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementTwelfthOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementTwelfthOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementTwelfthOutOf10';
            } else {
                $eduCondition = 'EntryRequirementTwelfthOutOf100';
            }
        } else {
            if ($higheduType == 'cgpa4') {
                $eduCondition = 'EntryRequirementUgOutOf4';
            } else if ($higheduType == 'cgpa5') {
                $eduCondition = 'EntryRequirementUgOutOf5';
            } else if ($higheduType == 'cgpa10') {
                $eduCondition = 'EntryRequirementUgOutOf10';
            } else {
                $eduCondition = 'EntryRequirementUgOutOf100';
            }
        }

        $examPassed = $request->examPassed;
        if (empty($examPassed)) {
            $examPassed = '1';
        }

        $test_score = $request->test_score;
        if (empty($test_score)) {
            $test_score = '1';
        }

        if ($examPassed == 'IeltsRequired' || $examPassed == 'IELTS') {
            $examValue = 'IeltsOverall';
        } else if ($examPassed == 'PteRequired' || $examPassed == 'PTE') {
            $examValue = 'PteScore';
        } else if ($examPassed == 'ToeflRequired' || $examPassed == 'TOEFL') {
            $examValue = 'ToeflScore';
        } else {
            $examValue = 'status';
        }

        $limit = $request->input('limit', 6);
        $country_url = '';

        // For Course Level
        $courseLevel = $request->courseLevel;
        
        if(empty($courseLevel)){
            if(auth()->check()){
                $courseLevel = CandidateDestination::select('preferred_program')
                ->where('candidate_id', auth()->user()->candidate->id)
                ->first();
                
                if (!empty($courseLevel)) {
                    $courseLevel = $courseLevel->preferred_program;

                    $replaceMap = [
                        'Masters' => 'Postgraduate',
                        'Bachelors' => 'Undergraduate',
                        'PHD' => 'PhD',
                    ];

                    $courseLevel = str_replace(array_keys($replaceMap), array_values($replaceMap), $courseLevel);
                }
            }
        }

        $courseLevelArray = [];

        if (isset($courseLevel) && $courseLevel) {
            $courseLevelArray = explode(',', @$courseLevel);
            $courseLevelArray = array_filter($courseLevelArray, function ($value) {
                return $value !== 'Not Decided' && $value !== 'Others';
            });
        }

        // For University
        $university_filter_id = $request->university;
        $universityFilterArray = [];
        if (isset($university_filter_id) && $university_filter_id) {
            $universityFilterArray = explode(',', @$university_filter_id);
        }

        // For Stream
        $stream = $request->stream;

        if(empty($stream)){
            if(auth()->check()){
                $stream = CandidateDestination::select('preffered_stream')
                ->where('candidate_id', auth()->user()->candidate->id)
                ->first();
                
                if (!empty($stream)) {
                    $stream = $stream->preffered_stream;
                }
            }
        }

        $streamFilterArray = [];

        if (isset($stream) && $stream) {
            $streamFilterArray = explode(',', @$stream);
            $streamFilterArray = array_filter($streamFilterArray, function ($value) {
                return $value !== 'Others' && $value !== 'No Preference';
            });
        }

        // For Exams
        $exams = $request->exam;

        if(empty($exams)){
            if(auth()->check()){
                $exams = CandidateExam::select('test_name')
                ->where('candidate_id', auth()->user()->candidate->id)
                ->first();
                
                if (!empty($exams)) {
                    $exams = $exams->test_name;

                    $replaceMap = [
                        'IELTS' => 'IeltsRequired',
                        'PTE' => 'PteRequired',
                        'TOEFL' => 'ToeflRequired',
                        'GRE' => 'GreRequired',
                        'GMAT' => 'GmatRequired',
                        'SAT' => 'SatRequired',
                        'ACT' => 'ActRequired',
                    ];

                    $exams = str_replace(array_keys($replaceMap), array_values($replaceMap), $exams);
                }
            }
        }

        $examArray = [];

        if (isset($exams) && $exams) {
            $examArray = explode(',', @$exams);
            $examArray = array_filter($examArray, function ($value) {
                return $value !== 'NT' && $value !== 'Not Taken' && $value !== 'Others';
            });
        }

        $query = Course::query()
            ->whereIn('university_id', $universities_ids)
            ->when(!empty($request->search), function ($query) use ($request) {
                return $query->where('name', 'like', '%' . $request->search . '%');
            });

            if (!empty($courseLevelArray)) {
                $query->whereIn('course_level', $courseLevelArray);
            }
    
            if (!empty($university_filter_id)) {
                $query->whereIn('university_id', $universityFilterArray);
            }
    
            if (!empty($streamFilterArray)) {
                $query->whereIn('study_area_id', $streamFilterArray);
            }
    
            if (!empty($streamFilterArray) && in_array('4', $streamFilterArray)) {
                $query->whereRaw("FIND_IN_SET('28', study_area_sub_id) > 0");
            }
    
            if (empty($university_filter_id)) {
                $query->whereIn('university_id', $universities_ids);
            }
            if (!empty($request->search)) {
                $query->where('name', 'like', '%' . $request->search . '%');
            }
    
            if (!empty($examArray)) {
                $query->where(function ($query) use ($examArray) {
                    foreach ($examArray as $exam) {
                        $query->orWhere($exam, 1);
                    }
                });
            }
    
            $duration = $request->duration;
            $durationArray = [];
    
            if (!empty($duration)) {
                $durationArray = explode(',', $duration);
                $firstRangeValues = explode('-', trim($durationArray[0], '[]'));
                $firstStartValue = intval($firstRangeValues[0]);
                $lastRangeValues = explode('-', trim(end($durationArray), '[]'));
                $lastEndValue = intval($lastRangeValues[1]);
    
    
                $query->where(function ($query) use ($firstStartValue, $lastEndValue) {
                    $query->whereBetween('durationValue', [$firstStartValue, $lastEndValue]);
                });
            }

            $safeCountQuery = clone $query;
            $moderateCountQuery = clone $query;
            $lowCountQuery = clone $query;

            // Perform the counts for safe, moderate, and low
            $safe = $safeCountQuery->where($eduCondition, '<', $high_edu_score)->where($examValue, '<', $test_score);
    
            $moderate = $moderateCountQuery
                ->where(function ($query) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                    $query->where(function ($innerQuery) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                        $innerQuery->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score - 1])
                            ->where($examValue, '<=', $test_score);
                    })
                        ->orWhere(function ($innerQuery) use ($high_edu_score, $eduCondition, $examValue, $test_score) {
                            $innerQuery->where($examValue, '>', $test_score)
                                ->where($eduCondition, '<=', $high_edu_score);
                        });
                });
    
            $low = $lowCountQuery->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score - 1])->where($examValue, '=>', $test_score);

        $query->where(function ($query) use ($safe, $moderate, $low) {
            $query->whereIn('id', $safe->pluck('id')->toArray())
                ->orWhereIn('id', $moderate->pluck('id')->toArray())
                ->orWhereIn('id', $low->pluck('id')->toArray());
        });

        $courseCounts = $query->count();
        $courses = $query
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name','country_id');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();

        $safeCourses = $safeCountQuery
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();

        $moderateCourses = $moderateCountQuery
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();

        $lowCourses = $lowCountQuery
            ->with([
                'university' => function ($query) {
                    $query->select('id', 'name');
                },
                'university.countries' => function ($query) {
                    $query->select('id', 'name');
                },
            ])
            ->take($limit)
            ->get();


        $safeCount = $safe->count();
        $moderateCount = $moderate->count();
        $lowCount = $low->count();

        // Add the 'eduFilter' attribute to each course
        $courses = $courses->map(function ($course) use ($safe, $moderate, $low) {
            $courseId = $course->id;

            if (in_array($courseId, $safe->pluck('id')->toArray())) {
                $course->eduFilter = 'safe';
            } elseif (in_array($courseId, $moderate->pluck('id')->toArray())) {
                $course->eduFilter = 'moderate';
            } elseif (in_array($courseId, $low->pluck('id')->toArray())) {
                $course->eduFilter = 'low';
            }

            return $course;
        });

        $levels = Course::select('course_level')->groupBy('course_level')->get();
        $streams = StudyArea::select('name', 'id')->get();
        $exams = Exam::select('name', 'id')->get();
        $shortlists = [];

        if (Auth::check()) {
            $shortlists = CourseShortlist::where('user_id', auth()->user()->id)->get();
        }

        // For Course Level
        foreach ($levels as $level) {
            if (in_array($level->course_level, $courseLevelArray)) {
                $level->checked = true;
            } else {
                $level->checked = false;
            }
        }

        // For University
        foreach ($universities as $university) {
            if (in_array($university->id, $universityFilterArray)) {
                $university->checked = true;
            } else {
                $university->checked = false;
            }
        }
        // For Study Area
        foreach ($streams as $stream) {
            if (in_array($stream->id, $streamFilterArray)) {
                $stream->checked = true;
            } else {
                $stream->checked = false;
            }
        }
        // For Exams

        foreach ($exams as $exam) {
            if ($exam->name == 'IELTS') {
                $exam->value = 'IeltsRequired';
            } elseif ($exam->name == 'PTE') {
                $exam->value = 'PteRequired';
            } elseif ($exam->name == 'TOEFL') {
                $exam->value = 'ToeflRequired';
            } elseif ($exam->name == 'SAT') {
                $exam->value = 'SatRequired';
            } elseif ($exam->name == 'GMAT') {
                $exam->value = 'GmatRequired';
            } elseif ($exam->name == 'ACT') {
                $exam->value = 'ActRequired';
            } elseif ($exam->name == 'DETR') {
                $exam->value = 'DETRequired';
            } elseif ($exam->name == 'GRE') {
                $exam->value = 'GreRequired';
            }
        }

        foreach ($exams as $exam) {
            if (in_array($exam->value, $examArray)) {
                $exam->checked = true;
            } else {
                $exam->checked = false;
            }
        }

        return response()->json([
            'courses' => $courses,
            'courseCounts' => $courseCounts,
            'country_url' => $country_url,
            'streams' => $streams,
            'levels' => $levels,
            'university' => $universities,
            'exams' => $exams,
            'durations' => $durationArray,
            'safeCount' => $safeCount,
            'moderateCount' => $moderateCount,
            'lowCount' => $lowCount,
            'safeCourses' => $safeCourses,
            'moderateCourses' => $moderateCourses,
            'lowCourses' => $lowCourses,
            'shortlists' => $shortlists,
        ]);
    }


    public function coursePopup($id)
    {
        $course = Course::where('id', $id)->with('university')->first();
        return response()->json([
            'status' => 1,
            'course' => $course,
        ]);
    }

    public function studyPlans(Request $request)
    {
        $plans = Plan::whereIn('code', ['GD003', 'GD001', 'GD002'])
            ->orderByRaw("FIELD(code, 'GD003', 'GD001', 'GD002')")
            ->latest()
            ->get();
        return view('website.' . $this->device . '.pages.studyPlans', compact(['plans']));
    }

    public function pricingPlan(Request $request, $plan)
    {
        $lock = 'false';

        if (auth()->check()) {
            $lock = Candidate::select('lock_profile')->where('user_id', auth()->user()->id)->first();
            $lock = $lock->lock_profile;
        
            if ($lock) {
                $lockProfileDate = Carbon::parse($lock);
        
                // Check if $lockProfileDate is in the past
                if ($lockProfileDate->isPast()) {
                    $lock = 'true';
                }
            }
        }
        
        $plan = Plan::where('url', $plan)->where('frontend_show', 1)->first();
        if (empty($plan)) abort(404);

        return view('website.' . $this->device . '.pages.pricing-plan', compact(['plan','lock']));
    }

    public function courseShortlistAdd($id)
    {
        $shortlist = new CourseShortlist;
        $shortlist->user_id = auth()->user()->id;
        $shortlist->course_id = $id;
        $shortlist = $shortlist->save();

        if ($shortlist) {
            return response()->json([
                'status' => 1,
                'msg' => 'Course Added to Shortlist',
            ]);
        } else {
            return response()->json([
                'status' => 0,
                'msg' => 'Course Not Added to Shortlist',
            ]);
        }
    }

    public function courseShortlistDelete($id)
    {
        $shortlist = CourseShortlist::where('user_id', auth()->user()->id)
            ->where('course_id', $id)
            ->delete();

        if ($shortlist) {
            return response()->json([
                'status' => 1,
                'msg' => 'Course Deleted to Shortlist',
            ]);
        } else {
            return response()->json([
                'status' => 0,
                'msg' => 'Course Not Deleted to Shortlist',
            ]);
        }
    }

    public function bookMeeting(Request $req)
    {
        $validator = Validator::make($req->all(), [
            "date" => "required",
            "slot" => "required",
            "user_id" => "required",
            "assign_to" => "required"
        ]);
        if ($validator->fails()) {
            $response = [
                'message' => $validator->errors(),
                'status' => 0
            ];
            $response_code = 403;
        } else {
            $user_id =  $req->input('user_id');
            $assign_to =  $req->input('assign_to');

            $dateStr = $req->input('date') . ' ' . $req->input('slot');
            $originalDate = Carbon::parse($dateStr);
            $newDateStr = $originalDate->format('Y-m-d H:i:s');

            $user = User::select('id', 'name', 'phone', 'email')->where('id', $user_id)->first();

            $followup = new Followup;
            $followup->followup_up = 'yes';
            $followup->comment = 'Auto Generated Comment';
            $followup->datetime = $newDateStr;
            $followup->user_id = $user_id;
            $followup->assign_to = $assign_to;
            $followup->save();
            $response = [
                'message' => "Lead Uploaded Successfully",
                'status' => 200
            ];
            $response_code = 200;
        }
        return response()->json($response, $response_code);
    }

    public function compareCourse(Request $request)
    {
        $courses = Course::whereIn('id', $request->selectedCourses)->where('status', 1)->with(['university.countries'])->get()->toArray();
        return response()->json([
            'status' => 1,
            'courses' => $courses,
        ], 200);
    }

    public function getApplication()
    {
        $user_id = JWTAuth::user()->id;
        $candidate_id = Candidate::where('user_id', $user_id)->value('id');
        if (!empty($candidate_id)) {
            $applications = CandidateApplication::where('candidate_id', $candidate_id)->with('courses.university')->orderBy('created_at', 'desc')->get();
            $response = [
                'message' => "Application Fetched Successfully",
                'status' => 1,
                'applications' => $applications,
            ];
            $response_code = 200;
        } else {
            $response = [
                'message' => "Something Went Wrong",
                'status' => 0,
            ];
            $response_code = 500;
        }
        return response()->json($response, $response_code);
    }

    public function setTimeline(Request $req){

        $application_id = $req->application_id;
        $workflow = true;

        if($application_id != null){
            $application = CandidateApplication::where('id',$application_id)->first();
            $timeline = [];
            $completed_stages = [];
            
            if($application->exists()){
                $current_stage = $application->status;
                $array_stages = get_candidateApplicationStatus_array();
                $previous_stages = array();
                $found_current_stage = false;
        
                foreach ($array_stages as $stage) {
                    if ($stage['name'] == $current_stage) {
                        $found_current_stage = true;
                        $previous_stages[] = $stage['name'];
                        break;
                    }
                    $previous_stages[] = $stage['name'];
                }
        
                if ($found_current_stage) {
                    if (!empty($previous_stages)) {
                        $completed_stages = CandidateApplicationTimeline::select('status', 'created_at')
                            ->where('application_id', $application_id)
                            ->whereIn('status', $previous_stages)
                            ->orderBy('created_at', 'asc')
                            ->get()
                            ->toArray();
                    }
                }
        
                foreach ($array_stages as $stage) {
                    $found = false;
                    if(!empty($completed_stages)){
                        foreach ($completed_stages as $complete) {
                            if ($complete['status'] == $stage['name']) {
                                $timeline[] = [
                                    'name' => $stage['name'],
                                    'created_date' => $complete['created_at'],
                                ];
                                $found = true;
                                break;
                            }
                        }
                    }
        
                    if (!$found) {
                        $timeline[] = [
                            'name' => $stage['name'],
                            'created_date' => 'pending',
                        ];
                    }
                }
        
                $response = [
                    'message' => "Timeline Fetched Successfully",
                    'status' => 1,
                    'timeline' => $timeline,
                ];
                $response_code = 200;
            }else{
                $workflow = false;
            }
        }else{
            $workflow = false;            
        }
        
        if(!$workflow){
            $response = [
                'message' => "Something Went Wrong",
                'status' => 1,
            ];
            $response_code = 500;
        }

        return response()->json($response, $response_code);
    }

    public function sendEmail()
    {

        $payment = Payment::where('order_id', 3)->first();
        $email = $payment->order->candidate->user->email;

        if (!empty($payment)) {
            $data = [
                'name' => $payment->order->candidate->user->name,
                'last_name' => $payment->order->candidate->user->last_name,
                'invoice_number' => $payment->invoice_number,
                'plan_name' => $payment->order->plan->title,
                'currency_symbol' => $payment->currency_symbol,
                'amount' => $payment->amount,
            ];

            Mail::send('mails.payment-mail', $data, function ($message) use ($email) {
                $message->to($email, 'Gradding')->subject('Gradding Payment Inovice');
                $message->from('contact@gradding.com', 'Gradding Team');
            });

            return response()->json(['success' => true]);
        }
    }

    public function applyApplication(Request $req)
    {
        $user_id = JWTAuth::user()->id;
        if (!empty($user_id)) {
            $candidate_id = Candidate::where('user_id', $user_id)->value('id');
            $course = Course::select('id', 'name')->where('id', $req->course_id)->get();
            $university = Universities::select('id', 'name')->where('id', $req->university_id)->get();
            if (!empty($candidate_id)) {
                $application = new CandidateApplication;
                $application->candidate_id = $candidate_id;
                $application->university_id = $req->university_id;
                $application->university_name = $university[0]->name;
                $application->course_name = $course[0]->name;
                $application->course = $req->course_id;
                $application->intake_years = null;
                $application->intake_months = $req->intake;
                $application->status = 'Requested From Student';
                $application->save();

                $new_id = $application->id;

                if (!empty($new_id)) {
                    $timeline = new CandidateApplicationTimeline;
                    $timeline->application_id = $new_id;
                    $timeline->status = 'Requested From Student';
                    $timeline->auth_type = 'user';
                    $timeline->auth_id = $user_id;
                    $timeline->candidate_id = $candidate_id;
                    $timeline->comment = 'Status Changed from NA to Requested From Student';
                    $timeline->save();
                }

                $shortlisted_course = CourseShortlist::where('id', $req->id)->first();
                if (!empty($shortlisted_course)) {
                    $shortlisted_course->applied = '1';
                    $shortlisted_course->update();
                }

                $updatedShortlistCourses = CourseShortlist::where('user_id', $user_id)->where('applied', 0)->with('course.university.countries')->get();


                $response = [
                    'message' => "Application Submitted Successfully",
                    'status' => 1,
                    'updatedShortlistCourses' => $updatedShortlistCourses,
                ];
                $response_code = 200;
            } else {
                $response = [
                    'message' => "Candidate not Found",
                    'status' => 0
                ];
                $response_code = 500;
            }
        } else {
            $response = [
                'message' => "User not Found",
                'status' => 0
            ];
            $response_code = 500;
        }

        return response()->json($response, $response_code);
    }

    public function getPrefferedStream(Request $req)
    {
        if (!empty($req->preffered_stream_id)) {
            $candidate_id = JWTAuth::user()->candidate->id;
            $preferred_sub_stream = SubStudyArea::whereIn('study_area_id', $req->preffered_stream_id)->get()->toArray();

            $selected_preferred_sub_stream = CandidateDestination::select('preferred_sub_stream')->where('candidate_id', $candidate_id)->first();

            if (!empty($preferred_sub_stream)) {
                $response = [
                    'message' => "Sub Streams Fetched Successfully",
                    'status' => 1,
                    'selected_preferred_sub_stream' => ($selected_preferred_sub_stream != null ? $selected_preferred_sub_stream : ''),
                ];
                $response_code = 200;
            } else {
                $response = [
                    'message' => "Something Went Wrong",
                    'status' => 0
                ];
                $response_code = 500;
            }
        } else {
            $response = [
                'message' => "Something Went Wrong",
                'status' => 0
            ];
            $response_code = 500;
        }

        return response()->json($response, $response_code);
    }

    public function logout(Request $request)
    {
        // Perform logout without using the middleware
        Auth::guard('user')->logout();

        // Redirect to the startJourney page after logout
        return redirect()->route('website.startJourney');
    }

    public function applyCourse(Request $request)
    {
        $candidate_id = '';
        if(auth()->check()){
            $candidate_id = auth()->user()->candidate->id;
        }
        if (!empty($candidate_id)) {
            $app = CandidateApplication::where('candidate_id', $candidate_id)->where('course', $request->course_id)->first();
            if(!empty($app)){
                $course = Course::select('id', 'name', 'university_id', 'Intakes')->where('id', $request->course_id)->first();
                $university = Universities::select('id', 'name')->where('id', $course->university_id)->first();
    
                $intakes = $course->Intakes;
                $intakes = explode(',', @$intakes);
    
                if (count($intakes) == 1) {
                    $nearestIntake = $intakes[0];
                } else {
                    $now = time();
                    $minDiff = PHP_INT_MAX;
                
                    foreach ($intakes as $intake) {
                        $diff = abs(strtotime($intake) - $now);
                
                        if ($diff < $minDiff) {
                            $nearestIntake = $intake;
                            $minDiff = $diff;
                        }
                    }
                }
    
                $application = new CandidateApplication;
                $application->candidate_id = $candidate_id;
                $application->university_id = $university->id;
                $application->university_name = $university->name;
                $application->course_name = $course->name;
                $application->course = $request->course_id;
                $application->intake_years = null;
                $application->intake_months = $nearestIntake;
                $application->status = 'Requested From Student';
                $application->save();
    
                if (!empty($application->id)) {
                    $timeline = new CandidateApplicationTimeline;
                    $timeline->application_id = $application->id;
                    $timeline->status = 'Requested From Student';
                    $timeline->auth_type = 'user';
                    $timeline->auth_id = auth()->user()->id;
                    $timeline->candidate_id = $candidate_id;
                    $timeline->save();
                }
    
                $shortlisted_course = CourseShortlist::where('id', $request->course_id)->where('user_id', auth()->user()->id)->first();
                if (!empty($shortlisted_course)) {
                    $shortlisted_course->applied = '1';
                    $shortlisted_course->update();
                }
    
                $response = [
                    'message' => "Application Submitted Successfully",
                    'status' => 1,
                ];
                $response_code = 200;
            } else {
                $response = [
                    'message' => "Application Already Found",
                    'status' => 2
                ];
                $response_code = 201;
            }
        } else {
            $response = [
                'message' => "User not Found",
                'status' => 0
            ];
            $response_code = 500;
        }

        return response()->json($response, $response_code);
    }
}