<?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 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',
                ];
            }
        }
        
        $applicationsCount = CandidateApplication::where('candidate_id',$user->candidate->id)->count();
        
        session(['applicationsCount' => $applicationsCount]);

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

    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 = false;
            foreach ($applications as $application) {
                if ($application->status === 'Offer Accepted') {
                    $isOfferAccepted = true;
                    break;
                }
            }

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

        return view('student-panel.pages.application-manager', compact(['user','applications','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;
        if(auth()->check()){
            $profile = Candidate::select('profile_complete')->where('id', auth()->user()->candidate->id)->first();
            $profile = $profile->profile_complete;
        }
        return view('student-panel.pages.university-finder',compact(['slug','profile']));
    }

    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);

        sendOtp($request->phone);

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

    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);
            // }else{
            //     auth()->login($userData);
            // }

            // $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{
                    $uploadChat = 1;
                        $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');
        $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)){
                $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'],
                '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;

            $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->save();
            }

            CandidateDestination::create([
                'candidate_id' => @$candidate->id,
                'preferred_country' => $planner['preffered_country'],
                'preferred_program' => $courseLevel,
                'preffered_stream' => @$stream,
                // 'fund_source' => $planner['funds'],
                '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,
                ]); 
            }

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


    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();
        }else{
            $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;
        $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;
        $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;
        $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();

        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);
                }
            });
        }

        // if(!empty($request->levelFilter) && $request->levelFilter == 'safe'){
        //     $query->where($eduCondition, '<' ,$high_edu_score)->where($examValue ,'<', $test_score);
        // }

        // if(!empty($request->levelFilter) && $request->levelFilter == 'moderate'){
        //     $query->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);
        //         });
        //     });
        // }

        // if(!empty($request->levelFilter) && $request->levelFilter == 'low'){
        //     $query->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score -1])->where($examValue, '>', $test_score);
        // }
        $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);
        // $moderateCount = $moderateCountQuery
        //                 ->whereBetween($eduCondition, [$high_edu_score - 2, $high_edu_score + 5])
        //                 ->whereBetween($examValue, [$test_score - 3, $test_score + 5])
        //                 ->where($eduCondition, '<', $high_edu_score)
        //                 ->where(function ($query) use ($examValue, $test_score) {
        //                     $query->where($examValue, '<', $test_score)
        //                         ->orWhere($examValue, '>', $test_score);
        //                 })->count();

        $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.countries')
        ->take($limit)
        ->get();

        $safeCourses = $safeCountQuery
        ->with('university.countries')
        ->take($limit)
        ->get();

        $moderateCourses = $moderateCountQuery
        ->with('university.countries')
        ->take($limit)
        ->get();

        $lowCourses = $lowCountQuery
        ->with('university.countries')
        ->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 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)){
            $preferred_sub_stream = SubStudyArea::where('study_area_id',$req->preffered_stream_id)->get()->toArray();
            
            if(!empty($preferred_sub_stream)){
                $response = [
                    'message' => "Sub Streams Fetched Successfully",
                    'status' => 1,
                    'preferred_sub_stream' => $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');
    }

}