<?php

namespace App\Http\Controllers\Website;

use Illuminate\Support\Facades\Mail;
use Carbon\Carbon;
use App\Models\Cms;
use App\Models\Job;
use App\Models\User;
use App\Models\Skill;
use AmrShawky\Currency;
use App\Models\Company;
use App\Models\JobRole;
use App\Models\Setting;
use App\Models\Candidate;
use App\Models\Education;
use App\Models\CmsContent;
use App\Models\Experience;
use App\Models\Profession;
use Illuminate\Pagination\Paginator;
use App\Models\Ranking;
use App\Models\JobCategory;
use App\Models\Media;
use Illuminate\Support\Str;
use App\Http\Traits\Jobable;
use App\Models\IndustryType;
use Illuminate\Http\Request;
use App\Models\ManualPayment;
use App\Models\PaymentSetting;
use App\Models\CandidateResume;
use Modules\Blog\Entities\Post;
use Modules\Plan\Entities\Plan;
use App\Models\OrganizationType;
use App\Models\CandidateLanguage;
use App\Http\Traits\Candidateable;
use Illuminate\Support\Facades\DB;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
// use Modules\Faq\Entities\FaqCategory;
use Modules\Blog\Entities\PostComment;
use Modules\Location\Entities\Country;
use Modules\Blog\Entities\PostCategory;
use Modules\Language\Entities\Language;
use App\Http\Traits\HasCountryBasedJobs;
use App\Models\Address;
use App\Models\CandidateDestination;
use App\Models\CandidateEducation;
use App\Models\CandidateExam;
use App\Models\CandidateTestPreparation;
use App\Traits\ResetCvViewsHistoryTrait;
use Illuminate\Support\Facades\Validator;
use App\Services\Website\IndexPageService;
use Stevebauman\Location\Facades\Location;
use Illuminate\Contracts\Support\Renderable;
use Illuminate\Support\Facades\Notification;
use Modules\Testimonial\Entities\Testimonial;
use App\Services\Midtrans\CreateSnapTokenService;
use Modules\Currency\Entities\Currency as CurrencyModel;
use App\Notifications\Website\Candidate\ApplyJobNotification;
use App\Notifications\Website\Candidate\BookmarkJobNotification;
use App\Models\Countries;
use App\Models\Universities;
use App\Models\Course;
use App\Models\CourseCategory;
use App\Models\TagTranslation;
use App\Models\CourseLevel;
use Modules\Faq\Entities\Faq;
use App\Models\Contact;
use App\Models\Lead;
use App\Models\Category;
use App\Models\City;
use App\Models\Exam;
use App\Models\University;
use Illuminate\Support\Facades\Hash;
use App\Models\Page;
use App\Models\Review;
use App\Models\Tag;
use App\Models\PageComment;
use App\Models\Specialization;
use App\Models\State;
use App\Models\Stream;
use App\Models\StudyArea;
use App\Notifications\CompanyCreatedNotification;
use App\Notifications\CandidateCreateNotification;
use App\Notifications\Admin\NewUserRegisteredNotification;
use App\Notifications\CompanyCreateApprovalPendingNotification;
use App\Notifications\CandidateCreateApprovalPendingNotification;
use Google\Service\CloudSearch\Content;
use Google\Service\CloudSearch\Id;
use Google\Service\Fitness\Session;

use App\Models\InterestedCandidatesWebinar;
use Illuminate\Support\Facades\Crypt;

use function Clue\StreamFilter\append;

class WebsiteController extends Controller
{
    protected $device;

    use Jobable, Candidateable, ResetCvViewsHistoryTrait, HasCountryBasedJobs;

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

    public function dashboard()
    {
        if (auth('user')->check() && auth('user')->user()->role == 'candidate') {
            return redirect()->route('candidate.dashboard');
        } elseif (auth('user')->check() && auth('user')->user()->role == 'company') {
            storePlanInformation();
            return redirect()->route('company.dashboard');
        }

        return redirect('login');
    }

    public function notificationRead()
    {
        foreach (auth()->user()->unreadNotifications as $notification) {
            $notification->markAsRead();
        }

        return response()->json(true);
    }

    public function index()
    {
        return view('website.' . $this->device . '.pages.index');
    }

    public function termsCondition()
    {
        // $termscondition = Cms::select('terms_page')->first();
        // $cms_content = CmsContent::query();

        // $terms_page = null;

        // //check session current language
        // $current_language = currentLanguage() ? currentLanguage() : '';
        // if ($current_language) {

        //     $exist_cms_content =  $cms_content->where('translation_code', $current_language->code)->where('page_slug', 'terms_condition_page')->first();

        //     if ($exist_cms_content) {
        //         $terms_page = $exist_cms_content->text;
        //     }
        // } else { //else push default one

        //     $exist_cms_content_en =  $cms_content->where('translation_code', 'en')->where('page_slug', 'terms_condition_page')->first();

        //     if ($exist_cms_content_en) {

        //         $terms_page = $exist_cms_content_en->text;
        //     } else {

        //         $terms_page = $termscondition->terms_page;
        //     }
        // }

        return view('website.' . $this->device . '.pages.terms-condition');
    }

    public function privacyPolicy()
    {
        // $privacy_page_default = Cms::select('privary_page')->first();
        // $cms_content = CmsContent::query();

        // $privacy_page = null;

        //check session current language
        // $current_language = currentLanguage() ? currentLanguage() : '';

        //if has session current language
        // if ($current_language) {

        //     $exist_cms_content =  $cms_content->where('translation_code', $current_language->code)->where('page_slug', 'privacy_page')->first();

        //     if ($exist_cms_content) {
        //         $privacy_page = $exist_cms_content->text;
        //     }
        // } else { //else push default one

        //     $exist_cms_content_en =  $cms_content->where('translation_code', 'en')->where('page_slug', 'privacy_page')->first();

        //     if ($exist_cms_content_en) {

        //         $privacy_page = $exist_cms_content_en->text;
        //     } else {

        //         $privacy_page = $privacy_page_default->privary_page;
        //     }
        // }

        return view('website.' . $this->device . '.pages.privacy-policy');
    }

    public function refundPolicy()
    {
        // $page_name = "refund_page";
        // $page_default = Cms::select($page_name)->first();
        // $cms_content = CmsContent::query();

        // $page = null;

        // //check session current language
        // $current_language = currentLanguage() ? currentLanguage() : '';

        // //if has session current language
        // if ($current_language) {

        //     $exist_cms_content =  $cms_content->where('translation_code', $current_language->code)->where('page_slug', $page_name)->first();

        //     if ($exist_cms_content) {
        //         $page = $exist_cms_content->text;
        //     }
        // } else { //else push default one

        //     $exist_cms_content_en =  $cms_content->where('translation_code', 'en')->where('page_slug', $page_name)->first();

        //     if ($exist_cms_content_en) {

        //         $page = $exist_cms_content_en->text;
        //     } else {

        //         $page = $page_default->$page_name;
        //     }
        // }

        return view('website.' . $this->device . '.pages.refund-policy');
    }
    public function jobs(Request $request)
    {
        $data = $this->getJobs($request);
        $data['indeed_jobs'] = $this->getIndeedJobs($request);
        $data['careerjet_jobs'] = $this->getCareerjetJobs($request);

        if (auth('user')->check() && auth('user')->user()->role == 'candidate') {
            $data['resumes'] = auth('user')->user()->candidate->resumes;
        } else {
            $data['resumes'] = [];
        }

        return view('website.pages.jobs', $data);
    }

    public function jobDetails(Job $job)
    {
        if ($job->status == 'pending') {
            if (!auth('admin')->check()) {
                abort_if(!auth('user')->check(), 404);
                abort_if(auth('user')->user()->role != 'company', 404);
                abort_if(auth('user')->user()->company->id != $job->company_id, 404);
            }
        }

        $data = $this->getJobDetails($job);

        return view('website.pages.job-details', $data);
    }

    public function candidates(Request $request)
    {
        abort_if(auth('user')->check() && auth('user')->user()->role == 'candidate', 404);

        $data['professions'] = Profession::all();
        $data['candidates'] = $this->getCandidates($request);
        $data['countries'] = Country::all();
        $data['experiences'] = Experience::all();
        $data['educations'] = Education::all();
        $data['skills'] = Skill::all();
        $data['candidate_languages'] = CandidateLanguage::all(['id', 'name']);

        // reset candidate cv views history
        $this->reset();

        return view('website.pages.candidates', $data);
    }

    public function candidateDetails(Request $request, $username)
    {
        $candidate = User::where('username', $username)
            ->with('candidate', 'contactInfo', 'socialInfo')
            ->firstOrFail();

        abort_if(auth('user')->check() && $candidate->id != auth('user')->id(), 404);

        if ($request->ajax) {
            return response()->json($candidate);
        }

        return view('website.pages.candidate-details', compact('candidate'));
    }

    public function candidateProfileDetails(Request $request)
    {
        $user = auth('user')->user();

        if ($user->role != 'company') {
            return response()->json([
                'message' => __('you_are_not_authorized_to_perform_this_action'),
                'success' => false
            ]);
        } else {
            $user_plan = $user->company->userPlan;
        }
        if (!$user_plan) {
            return response()->json([
                'message' => __('you_dont_have_a_chosen_plan_please_choose_a_plan_to_continue'),
                'success' => false
            ]);
        }

        if (isset($user_plan) && $user_plan->candidate_cv_view_limitation == 'limited' && $user_plan->candidate_cv_view_limit <= 0) {
            return response()->json([
                'message' => __('you_have_reached_your_limit_for_viewing_candidate_cv_please_upgrade_your_plan'),
                'success' => false,
                'redirect_url' => route('website.plan'),
            ]);
        }

        $candidate = User::where('username', $request->username)
            ->with(['contactInfo', 'socialInfo', 'candidate' => function ($query) {
                $query->with('experience', 'education', 'experiences', 'educations', 'profession', 'languages:id,name', 'skills')
                    ->withCount(['bookmarkCandidates as bookmarked' => function ($q) {
                        $q->where('company_id',  auth('user')->user()->company->id);
                    }])
                    ->withCount(['already_views as already_view' => function ($q) {
                        $q->where('company_id', auth('user')->user()->company->id);
                    }]);
            }])
            ->firstOrFail();

        $candidate->candidate->birth_date = Carbon::parse($candidate->candidate->birth_date)->format('d F, Y');

        if ($user_plan->candidate_cv_view_limitation == 'limited' && $request->count_view) {

            $company = auth()->user()->company;
            $cv_views = $company->cv_views; // get auth company all cv views
            $cv_view_exist = $cv_views->where('candidate_id', $candidate->candidate->id)->first(); // get specific view

            if (!$cv_view_exist) { // check view isn't exist
                isset($user_plan) ? $user_plan->decrement('candidate_cv_view_limit') : ''; // point reduce
                // and create view count item
                $company->cv_views()->create([
                    'candidate_id' => $candidate->candidate->id,
                    'view_date' => Carbon::parse(Carbon::now()),
                ]);
            }
        }

        $cv_limit_message = $user_plan->candidate_cv_view_limitation == 'limited' ? 'You have ' . $user_plan->candidate_cv_view_limit . ' cv views remaining.' : null;

        $languages = $candidate->candidate->languages()->pluck('name')->toArray();
        $candidate_languages = $languages ? implode(", ", $languages) : '';

        $skills = $candidate->candidate->skills->pluck('name');
        $candidate_skills = $skills ? implode(", ",  json_decode(json_encode($skills), true)) : '';

        return response()->json([
            'success' => true,
            'data' => $candidate,
            'skills' => $candidate_skills ?? '',
            'languages' => $candidate_languages ?? '',
            'profile_view_limit' => $cv_limit_message,
        ]);
    }

    public function candidateApplicationProfileDetails(Request $request)
    {
        $candidate = User::where('username', $request->username)
            ->with(['contactInfo', 'socialInfo', 'candidate' => function ($query) {
                $query->with('experiences', 'educations', 'experience', 'education', 'profession', 'languages:id,name', 'skills');
            }])
            ->firstOrFail();

        $candidate->candidate->birth_date = Carbon::parse($candidate->candidate->birth_date)->format('d F, Y');

        $languages = $candidate->candidate->languages()->pluck('name')->toArray();
        $candidate_languages = $languages ? implode(", ", $languages) : '';

        $skills = $candidate->candidate->skills->pluck('name');
        $candidate_skills = $skills ? implode(", ", json_decode(json_encode($skills))) : '';

        return response()->json([
            'success' => true,
            'data' => $candidate,
            'skills' => $candidate_skills,
            'languages' => $candidate_languages,
        ]);
    }

    public function candidateDownloadCv(CandidateResume $resume)
    {
        $filePath = $resume->file;

        $filename = time() . '.pdf';

        $headers = ['Content-Type: application/pdf',  'filename' => $filename,];
        $fileName = rand() . '-resume' . '.pdf';

        return response()->download($filePath, $fileName, $headers);
    }

    public function employees(Request $request)
    {
        abort_if(auth('user')->check() && auth('user')->user()->role == 'company', 404);

        $query = Company::with('user', 'user.contactInfo')->withCount([
            'jobs as activejobs' => function ($q) {
                $q->where('status', 'active');

                $selected_country = session()->get('selected_country');
                if ($selected_country && $selected_country != null && $selected_country != 'all') {
                    $country = selected_country()->name;
                    $q->where('country', 'LIKE', "%$country%");
                } else {

                    $setting = Setting::first();
                    if ($setting->app_country_type == 'single_base') {
                        if ($setting->app_country) {

                            $country = Country::where('id', $setting->app_country)->first();
                            if ($country) {
                                $q->where('country', 'LIKE', "%$country->name%");
                            }
                        }
                    }
                }
            }
        ])->withCount([
            'bookmarkCandidateCompany as candidatemarked' => function ($q) {
                $q->where('user_id', auth()->id());
            }
        ])
            ->withCasts(['candidatemarked' => 'boolean'])->active();

        // Keyword search
        if ($request->has('keyword') && $request->keyword != null) {
            $keyword = $request->keyword;
            $query->whereHas('user', function ($q) use ($keyword) {
                $q->where('name', 'LIKE', "%$keyword%");
            });
        }

        // location search
        if ($request->has('lat') && $request->has('long') && $request->lat != null && $request->long != null) {
            $ids = $this->company_location_filter($request->lat, $request->long);
            $query->whereIn('id', $ids)->orWhere('country', $request->location ? $request->location : '');
        }

        // industry_type
        if ($request->has('industry_type') && $request->industry_type !== null) {
            $industry_type_id = IndustryType::where('name', $request->industry_type)->value('id');
            $query->where('industry_type_id', $industry_type_id);
        }

        // organization_type
        if ($request->has('organization_type') && $request->organization_type !== null) {

            $organization_type = $request->organization_type;

            $query->whereHas('organization', function ($q) use ($organization_type) {
                $q->where('name', $organization_type);
            });
        }
        // sortBy search
        if ($request->has('sortBy') && $request->sortBy) {
            if ($request->sortBy == 'latest') {
                $query->latest();
            } else {
                $query->oldest();
            }
        } else {
            $query->latest();
        }

        $companies = $query;

        // perpage filter
        if ($request->has('perpage') && $request->perpage != null) {
            switch ($request->perpage) {
                case '12':
                    $companies = $query->latest('activejobs')->paginate(12);
                    break;
                case '18':
                    $companies = $query->latest('activejobs')->paginate(18);
                    break;
                case '30':
                    $companies = $query->latest('activejobs')->paginate(30);
                    break;
            }
        } else {
            $companies = $query->latest('activejobs')->paginate(12);
        }

        $industry_types = IndustryType::all();
        $organization_type = OrganizationType::all();

        // return $companies;

        return view('website.pages.employees', compact('companies', 'industry_types', 'organization_type'));
    }

    public function employersDetails(User $user)
    {
        $companyDetails =  Company::with(
            'organization:id,name',
            'industry',
            'team_size:id,name',
        )->where('user_id', $user->id)->withCount([
            'jobs as activejobs' => function ($q) {
                $q->where('status', true);
                $q->where('deadline', '>=', Carbon::now()->toDateString());
                $selected_country = session()->get('selected_country');
                if ($selected_country && $selected_country != null && $selected_country != 'all') {
                    $country = selected_country()->name;
                    $q->where('country', 'LIKE', "%$country%");
                } else {

                    $setting = Setting::first();
                    if ($setting->app_country_type == 'single_base') {
                        if ($setting->app_country) {

                            $country = Country::where('id', $setting->app_country)->first();
                            if ($country) {
                                $q->where('country', 'LIKE', "%$country->name%");
                            }
                        }
                    }
                }
            }
        ])
            ->withCount([
                'bookmarkCandidateCompany as candidatemarked' => function ($q) {
                    $q->where('user_id', auth()->id());
                }
            ])
            ->withCasts(['candidatemarked' => 'boolean'])
            ->first();

        // open_jobs Jobs With Single && Multiple Country Base
        $open_jobs_query = Job::withoutEdited()->with('company');

        $setting = Setting::first();
        if ($setting->app_country_type == 'single_base') {
            if ($setting->app_country) {

                $country = Country::where('id', $setting->app_country)->first();
                if ($country) {
                    $open_jobs_query->where('country', 'LIKE', "%$country->name%");
                }
            }
        } else {
            $selected_country = session()->get('selected_country');

            if ($selected_country && $selected_country != null) {
                $country = selected_country()->name;
                $open_jobs_query->where('country', 'LIKE', "%$country%");
            }
        }
        $open_jobs = $open_jobs_query->companyJobs($companyDetails->id)->openPosition()->latest()->get();

        return view('website.pages.employe-details', compact('user', 'companyDetails', 'open_jobs'));
    }

    public function about()
    {
        $candidates = Candidate::count();
        $about = Cms::first();

        return view('website.' . $this->device . '.pages.about', compact('candidates', 'about'));
    }

    public function categoryWisePosts(PostCategory $category)
    {
        $key = request()->search;
        $key = request()->category;

        $posts = Post::query()->published();

        if ($key) {
            $posts->where('title', 'Like', '%' . $key . '%');
        }

        $posts = $category->posts()->latest()->paginate(15);

        $recent_posts = Post::published()->latest()->take(5)->get();
        $categories = PostCategory::latest()->get();
        return view('website.pages.posts', compact('posts', 'categories', 'recent_posts', 'key'));
    }

    public function pricing()
    {
        abort_if(auth('user')->check() && auth('user')->user()->role == 'candidate', 404);
        $plans = Plan::active()->get();
        return view('website.pages.pricing', compact('plans'));
    }

    public function planDetails($label)
    {
        abort_if(auth('user')->check() && auth('user')->user()->role == 'candidate', 404);

        // session data storing
        $plan = Plan::where('label', $label)->firstOrFail();
        session(['stripe_amount' => currencyConversion($plan->price) * 100]);
        session(['razor_amount' => currencyConversion($plan->price, null, 'INR', 1) * 100]);
        session(['ssl_amount' => currencyConversion($plan->price, null, 'BDT', 1)]);
        session(['plan' => $plan]);
        session(['job_payment_type' => 'package_job']);
        session()->forget('job_request');

        $payment_setting = PaymentSetting::first();
        $manual_payments = ManualPayment::whereStatus(1)->get();

        // midtrans snap token
        if (config('zakirsoft.midtrans_active') && config('zakirsoft.midtrans_merchat_id') && config('zakirsoft.midtrans_client_key') && config('zakirsoft.midtrans_server_key')) {
            $usd = $plan->price;
            $amount = (int) Currency::convert()
                ->from(config('zakirsoft.currency'))
                ->to('IDR')
                ->amount($usd)
                ->round(2)
                ->get();

            $order['order_no'] = uniqid();
            $order['total_price'] = $amount;

            $midtrans = new CreateSnapTokenService($order);
            $snapToken = $midtrans->getSnapToken();

            session(['midtrans_details' => [
                'order_no' => $order['order_no'],
                'total_price' => $order['total_price'],
                'snap_token' => $snapToken,
                'plan_id' => $plan->id,
            ]]);
        }


        return view('website.pages.plan-details', [
            'plan' => $plan,
            'payment_setting' => $payment_setting,
            'mid_token' => $snapToken ?? null,
            'manual_payments' => $manual_payments,
        ]);
    }

    public function contact(Request $request)
    {
        // if ($request->post()) {
        //     $validatedData = $request->validate([
        //         'name' => 'required|string|max:255',
        //         'email' => 'required|email|max:255',
        //         'phone' => 'required|min:10',
        //         'description' => 'required|string',
        //     ]);
        //     // Save the data to the database
        //     $contact = Lead::create($validatedData);

        //         // Redirect back with a success message
        //         flashSuccess(__('Your message has been sent! '));
        //         return back()->with('success', 'Your message has been sent!');

        // }
        $addresses = Address::with('page')->get();
        return view('website.' . $this->device . '.pages.contact', compact('addresses'));
    }

    // public function contactDetails(Request $request)
    // {
    //     $request->validate([
    //         'name' => 'required| string| max:50',
    //         'email' => 'required| email| max:255',
    //         'phone' => 'required | min:9| max:255',
    //       ]);

    //     $data['name'] = $request->name;
    //     $data['email'] = $request->email;
    //     $data['phone'] = $request->phone;
    //     $data['description'] = $request->description;
    //     $data['url'] = $request->url;
    //     $data['source'] = $request->source;

    //     $contact = Lead::create($data);

    //     if (!empty($contact)) {
    //         return ['status' => 1, 'msg' => 'We Will Contact You Soon'];
    //     }

    //     return ['status' => 0, 'msg' => 'Something Went Wrong'];

    // }

    public function faq(Request $request)
    {
        $faq_categories = Category::with(['faqs' => function ($q) {
            $q->where('code', currentLangCode());
        }])->get();
        $condition = [];
        if ($request->isMethod('get')) {
            if ($request->input('searchData')) {
                $condition[] = ['question', 'like', '%' . $request->input('searchData') . '%'];
            }
        }
        $faqs = Faq::with('university')->where($condition)->orderBy('id', 'desc')->take(8)->get();
        return view('website.' . $this->device . '.pages.faq', compact('faq_categories', 'faqs'));
    }

    public function comingSoon()
    {
        return view('website.pages.comingsoon');
    }

    public function toggleBookmarkJob(Job $job)
    {
        $check = $job->bookmarkJobs()->toggle(auth('user')->user()->candidate);

        if ($check['attached'] == [1]) {

            $user = auth('user')->user();
            // make notification to company candidate bookmark job
            Notification::send($job->company->user, new BookmarkJobNotification($user, $job));
            // make notification to candidate for notify
            if (auth()->user()->recent_activities_alert) {
                Notification::send(auth('user')->user(), new BookmarkJobNotification($user, $job));
            }
        }


        $check['attached'] == [1] ? $message = __('job_added_to_favorite_list') : $message = __('job_removed_from_favorite_list');

        flashSuccess($message);
        return back();
    }

    public function toggleApplyJob(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'resume_id' => 'required',
            'cover_letter' => 'required',
        ], [
            'resume_id.required' => 'Please select resume',
            'cover_letter.required' => 'Please enter cover letter',
        ]);

        if ($validator->fails()) {
            flashError($validator->errors()->first());
            return back();
        }

        if (auth('user')->user()->candidate->profile_complete != 0) {
            flashError(__('complete_your_profile_before_applying_to_jobs_add_your_information_resume_and_profile_picture_for_a_better_chance_of_getting_hired'));
            return redirect()->route('candidate.dashboard');
        }

        $candidate = auth('user')->user()->candidate;
        $job = Job::find($request->id);

        DB::table('applied_jobs')->insert([
            'candidate_id' => $candidate->id,
            'job_id' => $job->id,
            'cover_letter' => $request->cover_letter,
            'candidate_resume_id' => $request->resume_id,
            'application_group_id' => $job->company->applicationGroups->where('is_deleteable', false)->first()->id ?? 1,
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        // make notification to candidate and company for notify
        $job->company->user->notify(new ApplyJobNotification(auth('user')->user(), $job->company->user));

        if (auth('user')->user()->recent_activities_alert) {
            auth('user')->user()->notify(new ApplyJobNotification(auth('user')->user(), $job->company->user));
        }

        flashSuccess(__('job_applied_successfully'));
        return back();
    }

    public function register($role)
    {
        return view('auth.register', compact('role'));
    }

    public function posts(Request $request)
    {
        $key = request()->search;
        $posts = Post::query()->published()->withCount('comments');

        if ($key) {
            $posts->where('title', 'Like', '%' . $key . '%');
        }

        if ($request->category) {
            $category_ids = PostCategory::whereIn('slug', $request->category)->get()->pluck('id');
            $posts = $posts->whereIn('category_id', $category_ids)->latest()->paginate(10)->withQueryString();
        } else {
            $posts = $posts->latest()->paginate(10)->withQueryString();
        }

        $recent_posts = Post::published()->withCount('comments')->latest()->take(5)->get();
        $categories = PostCategory::latest()->get();

        return view('website.pages.posts', compact('posts', 'categories', 'recent_posts'));
    }

    public function post($slug)
    {
        $post = Post::published()->whereSlug($slug)
            ->with([
                'author:id,name,name',
                'comments.replies.user:id,name,image'
            ])
            ->first();
        if (!$post) {
            abort(404);
        }

        return view('website.pages.post', compact('post'));
    }

    public function comment(Post $post, Request $request)
    {

        $request->validate([
            'body' => 'required|max:2500|min:2'
        ]);

        $comment = new PostComment();
        $comment->author_id = auth()->user()->id;
        $comment->post_id = $post->id;
        if ($request->has('parent_id')) {
            $comment->parent_id = $request->parent_id;
            $redirect = "#replies-" . $request->parent_id;
        } else {
            $redirect = "#comments";
        }
        $comment->body = $request->body;
        $comment->save();

        return redirect(url()->previous() . $redirect);
    }

    public function markReadSingleNotification(Request $request)
    {
        auth()->user()->unreadNotifications->where('id', $request->id)->markAsRead();

        return true;
    }

    public function setSession(Request $request)
    {
        $request->session()->put('location', $request->input());
        return response()->json(true);
    }

    public function setCurrentLocation($request)
    {
        // Current Visitor Location Track && Set Country IF App Is Multi Country Base
        $app_country = setting('app_country_type');

        if ($app_country == 'multiple_base') {

            $ip = request()->ip();
            // $ip = '103.102.27.0'; // Bangladesh
            // $ip = '105.179.161.212'; // Mauritius
            // $ip = '110.33.122.75'; // AUD
            // $ip = '5.132.255.255'; // SA
            // $ip = '107.29.65.61'; // United States"
            // $ip = '46.39.160.0'; // Czech Republic
            // $ip = "94.112.58.11"; // Czechia

            if ($ip) {
                $current_user_data = Location::get($ip);
                if ($current_user_data) {
                    $user_country = $current_user_data->countryName;
                    if ($user_country) {
                        $this->setLangAndCurrency($user_country);
                        $database_country = Country::where('name', $user_country)->where('status', 1)->first();
                        if ($database_country) {
                            $selected_country = session()->get('selected_country');
                            if (!$selected_country) {
                                session()->put('selected_country', $database_country->id);
                                return true;
                            }
                        }
                    }
                }
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    /**
     * Process for set currency & language
     */
    public function setLangAndCurrency($name)
    {
        // this process for get language code/sort name  and currency sortname
        $get_lang_wise_sort_name = json_decode(file_get_contents(base_path('public/json/country_currency_language.json')), true);

        $country_name = Str::slug($name);
        if ($get_lang_wise_sort_name) { // loop json file data

            for ($i = 0; $i < count($get_lang_wise_sort_name); $i++) {

                $json_country_name = Str::slug($get_lang_wise_sort_name[$i]['name']);

                if ($country_name == $json_country_name) { // check country are same

                    $cn_code = $get_lang_wise_sort_name[$i]['currency']['code'];
                    $ln_code = $get_lang_wise_sort_name[$i]['language']['code'];

                    // Currency setup
                    $set_currency = CurrencyModel::where('code', Str::upper($cn_code))->first();
                    if ($set_currency) {
                        session(['current_currency' => $set_currency]);
                        currencyRateStore();
                    }
                    // // Currency setup
                    $set_language = Language::where('code', Str::lower($ln_code))->first();
                    if ($set_language) {
                        session(['current_lang' => $set_language]);
                        // session()->put('set_lang', $lang);
                        app()->setLocale($ln_code);
                    }
                    return true;
                }
            }
        } else {
            return false;
        }
    }

    public function setSelectedCountry(Request $request)
    {
        session()->put('selected_country', $request->country);

        return back();
    }

    public function removeSelectedCountry()
    {
        session()->forget('selected_country');
        return redirect()->back();
    }

    public function company_location_filter($latitude, $longitude)
    {
        $distance = 50;

        $haversine = "(
                    6371 * acos(
                        cos(radians(" . $latitude . "))
                        * cos(radians(`lat`))
                        * cos(radians(`long`) - radians(" . $longitude . "))
                        + sin(radians(" . $latitude . ")) * sin(radians(`lat`))
                    )
                )";

        $data = Company::select('id')->selectRaw("$haversine AS distance")
            ->having("distance", "<=", $distance)->get();

        $ids = [];

        foreach ($data as $id) {
            array_push($ids, $id->id);
        }

        return $ids;
    }

    public function jobAutocomplete(Request $request)
    {
        $jobs = Job::select("title as value", "id")
            ->where('title', 'LIKE', '%' . $request->get('search') . '%')
            ->active()
            ->withoutEdited()
            ->latest()
            ->get()
            ->take(15);

        if ($jobs && count($jobs)) {
            $data = '<ul class="dropdown-menu show">';
            foreach ($jobs as $job) {
                $data .= '<li class="dropdown-item"><a href="' . route('website.job', ['keyword' => $job->value]) . '">' . $job->value . '</a></li>';
            }
            $data .= '</ul>';
        } else {
            $data = '<ul class="dropdown-menu show"><li class="dropdown-item">No data found</li></ul>';
        }

        return response()->json($data);
    }

    /**
     * Careerjet jobs list
     *
     * @return Renderable
     */
    public function careerjetJobs(Request $request)
    {
        if (!config('zakirsoft.careerjet_active') || !config('zakirsoft.careerjet_id')) {
            abort(404);
        }

        $careerjet_jobs = $this->getCareerjetJobs($request, 25);

        return view('website.pages.jobs.careerjet-jobs', compact('careerjet_jobs'));
    }

    /**
     * Indeed jobs list
     *
     * @return Renderable
     */
    public function indeedJobs(Request $request)
    {
        if (!config('zakirsoft.indeed_active') || !config('zakirsoft.indeed_id')) {
            abort(404);
        }

        $indeed_jobs = $this->getIndeedJobs($request, 25);

        return view('website.pages.jobs.indeed-jobs', compact('indeed_jobs'));
    }
    public function all_countries(Request $request)
    {

        dd('All Countries');
    }
    public function country(Request $request, $country)
    {
        return view('website.pages.company.country-details');

        dd($country);
    }
    // public function universities(Request $request,$university){
    //     dd($university); 
    // }
    // public function uk_universities(Request $request,$universityName,$name){
    //     dd($request);
    //     $university = Universities::where('url',$universityName)->with('countries')->first();
    //     $countries = Countries::where('id',1)->get();
    //     // dd($university);
    //     // dd(trim($university->courseWidget) );
    //     // print_r(json_decode(($university->courseWidget),true));die;
    //     return view('website.pages.company.universities',compact('university'));
    // }
    public function uk_universities_courses(Request $request)
    {
        return view('website.' . $this->device . '.pages.universities-courses');
    }


    public function cw_universities($country = null, Request $request)
    {
        // dd($request->all());
        // $countryId = null;
        // $pageContent = null;
        // $condition=['status'=>1];
        // if($request->input('searchUniversity')){
        //     $condition[] = ['name', 'LIKE', '%' . $request->searchUniversity . '%'];   
        // }
        // if($country !== null){
        //     @$pageContent = Page::where('category_id', 49)->where('url', $country)->first();

        //     $country = Countries::where('url', $country)->first();
        //     if(empty($country)){
        //         abort(404);
        //     }
        //     $countryId = $country->id;
        // }
        // if($request->input('country')){
        //     $countryId = $request->input('country');
        //     if($request->country !== 'university'){
        //         $condition[] = ['country_id', $countryId ];
        //     }
        // }
        // else{
        //     if(!empty($countryId)){
        //         $condition[] = ['country_id', $countryId ];
        //     }
        // }
        // if($request->input('studyLevel') != ''){
        //     $condition[] = ['name', 'LIKE', '%' . $request->studyLevel . '%'];
        // }
        // if($request->input('fees') != ''){
        //     $condition[] = ['name', 'LIKE', '%' . $request->fees . '%'];
        // }
        // if($request->input('exams') != ''){
        //     $condition[] = ['name', 'LIKE', '%' . $request->exams . '%'];
        // }

        // $universities = Universities::with(['countries'])->where($condition)->sorting()->with('countries')->orderBy('sorting','Desc')->paginate(15);
        // if(empty($universities)) abort(404);
        // $universities->country = Countries::where('url', $country)->first();
        // dd($universities);
        if ($country == 'study-in-uk' || $country == 'study-in-australia' || $country == 'study-in-usa' || $country == 'study-in-canada' || $country == 'study-in-hungary' || $country == 'study-in-malta') {
            return $this->searchFinder(new Request(), 'university', $country);
        }
        abort(404);
        // return view('website.'.$this->device.'.pages.cw_universities', compact(['universities', 'countryId','pageContent']));

    }
    public function cw_university_details($country, $university_url)
    {

        $redirectCountries = [
            'uk' => 'study-in-uk',
            'us' => 'study-in-usa',
            'au' => 'study-in-australia',
            'ca' => 'study-in-canada',
            'hu' => 'study-in-hungary',
            'mt' => 'study-in-malta',
            'it' => 'study-in-italy',
            'in' => 'study-in-india',
            'fr' => 'study-in-france'
        ];
        
        if (array_key_exists($country, $redirectCountries)) {
            $redirectUrl = str_replace($country, $redirectCountries[$country], url()->current());
            return redirect($redirectUrl, 301);
        }        
        
        $university = Universities::where('url', $university_url)->where('status', 1)->with(['countries', 'faq', 'courses', 'cities', 'review'])
            ->whereHas('countries', function ($query) use ($country) {
                $query->where('url', $country);
            })
            ->first();

        if (empty($university)) abort(404);

        $id = $university->id;
        $category = CourseCategory::with('course')->whereHas('course', function ($query) use ($id) {
            $query->where('university_id', $id);
        })->get();

        $university->category = $category;
        $university->blogs = Page::where('category_id', 42)->latest()->published()->with('category')->get();

        $rankings = Ranking::where('university_id', $university->id)->get();
        $groupedData = [];
        if (filled($rankings)) {
            foreach ($rankings as $item) {
                $publisherId = $item["publisher_id"];
                if (!isset($groupedData[$publisherId])) {
                    $groupedData[$publisherId] = [];
                }
                $groupedData[$publisherId][] = $item;
            }
        }


        return view('website.' . $this->device . '.pages.universities', compact('university', 'groupedData'));
    }
    public function cw_courses($country, $university_url, Request $request)
    {
        $condition = [];
        if ($request->isMethod('get')) {
            // dd($request->all());
            if ($request->has('search')) {
                $condition[] = ['name', 'LIKE', '%' . $request->search . '%'];
            }
            if (!empty($request->category)) {
                $condition['course_categories_id'] = $request->input('category');
            }
            if (!empty($request->course_level)) {
                $condition['course_level_id'] = $request->input('course_level');
            }
        }
        // dd();
        $university = Universities::with('countries')->where('url', $university_url)->first();

        // \DB::enableQueryLog(); // Enable query log
        $university->courses = Course::with(['university', 'category'])->where($condition)
            ->whereHas('university', function ($query) use ($university_url) {
                $query->where(['url' => $university_url]);
            })
            ->paginate(9);
        // ->toSql();
        // dd($university->courses);
        //         dd($university_url .' => '.$country);
        $university->category = CourseCategory::all();
        $university->categoryLevel = CourseLevel::all();
        // $course = Course::where('university_id',$university->id)->with(['university.countries','university'])->first();
        // dd($uni);
        return view('website.pages.company.universities-courses', compact('university'));

        // code to fetch courses for the given university
    }
    public function cw_coursesFilter($country, $university_url, Request $request)
    {
        $condition = [];
        if (!empty($request)) {


            if ($request->input('search')) {
                $condition[] = ['name', 'LIKE', '%' . $request->search . '%'];
            }
            if ($request->input('courses')) {
                $condition[] = ['course_level', 'LIKE', '%' . $request->courses . '%'];
            }
            if ($request->input('category')) {
                $category_id = implode(',', $request->input('category'));
                $condition['course_categories_id'] = $category_id;
            }
            $courses = Course::with(['university', 'category'])
                ->where($condition)
                ->whereHas('university', function ($query) use ($university_url) {
                    $query->where(['url' => $university_url]);
                })

                ->get();

            // dd($courses);
            if (!empty($courses)) {
                return ['status' => 1, 'data' => $courses];
            }
        }
        return ['status' => 0, 'data' => 'invalid Request'];

        // $courses = Course::with(['university'])
        // ->whereHas('university', function ($query) use ($university_url) {
        //     $query->where(['url'=> $university_url]);
        // })->paginate(9);

    }
    // Course Data
    public function cw_courses_details($country, $university_url, $course_url)
    {

        $redirectCountries = [
            'uk' => 'study-in-uk',
            'us' => 'study-in-usa',
            'au' => 'study-in-australia',
            'ca' => 'study-in-canada',
            'hu' => 'study-in-hungary',
            'mt' => 'study-in-malta',
            'it' => 'study-in-italy',
            'in' => 'study-in-india',
            'fr' => 'study-in-france'
        ];
        
        if (array_key_exists($country, $redirectCountries)) {
            $redirectUrl = str_replace($country, $redirectCountries[$country], url()->current());
            return redirect($redirectUrl, 301);
        }

        $country = Countries::Select('id')->where('url', $country)->first();
        $countryId = @$country->id;
        $courses = Course::with(['university', 'level', 'category'])
            ->where('url', $course_url)
            ->whereHas('university', function ($query) use ($university_url, $countryId) {
                $query->where('country_id', $countryId)
                    ->where('url', $university_url);
            })->first();

        if (empty($courses)) abort(404);

        $country_id = Universities::where('id', $courses->university_id)->pluck('country_id')->toArray();
        $relatedCourses = Course::where('university_id', $courses->university_id)->where('id', '!=', $courses->id)->with('university')->take(3)->get();
        $relatedUniversities = Universities::where('id', '!=', $courses->university_id)->where('recommended', 1)->where('country_id', $country_id)->take(3)->with('courses')->get();
        $filteredIntakesByUniversity = [];
        $i = 0;

        foreach ($relatedUniversities as $university) {
            $universityId = $university->id;

            if (!empty($university->courses)) {
                $intake = [];
                foreach ($university->courses as $course) {
                    if (!empty($course->Intakes)) {
                        $intake = array_merge($intake, explode(',', $course->Intakes));
                    }
                }

                $filteredIntakes = [];

                foreach ($intake as $intake) {
                    $trimmedIntake = trim($intake);
                    $lowercaseIntake = strtolower($trimmedIntake);

                    if (!in_array($lowercaseIntake, array_map('strtolower', $filteredIntakes))) {
                        $filteredIntakes[] = $trimmedIntake;
                    }
                }

                $filteredIntakesByUniversity[$i] = $filteredIntakes;
                $i++;
            }
        }
        if (!empty($relatedUniversities)) {
            $relatedUniversityIds = $relatedUniversities->pluck('id')->toArray();
            $requiredTestsByUniversity = [];
            $requiredIntakesByUniversity = [];
            $index = 0;
            $i = 0;

            foreach ($relatedUniversityIds as $universityId) {
                $exams = Course::select('id', 'SatRequired', 'GmatRequired', 'ActRequired', 'GreRequired', 'IeltsRequired', 'ToeflRequired', 'PteRequired', 'DETRequired')
                    ->where('university_id', $universityId)
                    ->get();

                $requiredTests = [];

                foreach ($exams as $exam) {
                    $testFields = ['GmatRequired', 'ActRequired', 'GreRequired', 'IeltsRequired', 'ToeflRequired', 'PteRequired', 'DETRequired'];

                    foreach ($testFields as $testField) {
                        if ($exam->{$testField} === 1 && !in_array($testField, $requiredTests)) {
                            array_push($requiredTests, $testField);
                        }
                    }
                }

                $requiredTestsByUniversity[$index] = $requiredTests;
                $index++;
            }
        }
        foreach ($relatedUniversityIds as $universityId) {
            $intakes = Course::Select('Intakes')
                ->where('university_id', $universityId)
                ->get();
            $requiredIntakes = [];
            foreach ($intakes as $course) {
                $intakeArray = explode(',', $intakes);

                foreach ($intakeArray as $intake) {
                    $trimmedIntake = trim($intake);
                    $capitalizedIntake = ucfirst($trimmedIntake);
                    if (!in_array($capitalizedIntake, $requiredIntakes)) {
                        $requiredIntakes[] = $capitalizedIntake;
                    }
                }
            }

            $requiredIntakesByUniversity[$i] = $requiredIntakes;
            $i++;
        }
        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $pages = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();

        $examArray = Course::Select('SatRequired', 'GmatRequired', 'ActRequired', 'GreRequired', 'IeltsRequired', 'ToeflRequired', 'PteRequired', 'DETRequired')->where('id', $courses->id)->get()->toArray();

        $examScoreArray = Course::Select('SatScore', 'GmatScore', 'ActScore', 'GreScore', 'IeltsOverall', 'ToeflScore', 'PteScore', 'DETScore')->where('id', $courses->id)->get()->toArray();

        $examFilterArray = [];

        foreach ($examArray[0] as $key => $value) {
            if ($value == 1) {
                $newKey = strtoupper(str_replace('Required', '', $key));
                $examFilterArray[$newKey] = $value;
            }
        }
        $examFilterScoreArray = [];

        foreach ($examScoreArray[0] as $key => $value) {
            if (!is_null($value)) {
                $examFilterScoreArray[$key] = $value;
            }
        }

        $relatedExamsArray = [];

        foreach ($relatedCourses as $course) {
            $examData = Course::select('SatRequired', 'GmatRequired', 'ActRequired', 'GreRequired', 'IeltsRequired', 'ToeflRequired', 'PteRequired', 'DETRequired')->where('id', $course['id'])->first();

            if ($examData) {
                $examInfo = [];

                foreach ($examData->toArray() as $key => $value) {
                    if ($value == 1) {
                        $examName = strtoupper(str_replace('Required', '', $key));
                        $examInfo[] = $examName;
                    }
                }

                $relatedExamsArray[] = implode(', ', $examInfo);
            }
        }
        $tests = ['SatRequired', 'GmatRequired', 'ActRequired', 'GreRequired', 'IeltsRequired', 'ToeflRequired', 'PteRequired', 'DETRequired'];

        foreach ($requiredTestsByUniversity as &$requiredTests) {
            $requiredTests = array_map(function ($test) {
                $testWithoutRequired = str_replace('Required', '', $test);
                return strtoupper($testWithoutRequired);
            }, $requiredTests);
        }

        return view('website.' . $this->device . '.pages.course-details', compact('courses', 'filteredIntakesByUniversity', 'relatedCourses', 'relatedUniversities', 'pages', 'examFilterArray', 'relatedExamsArray', 'examFilterScoreArray', 'requiredTestsByUniversity'));
    }
    // public function stepperData(Request $request)
    // {
    //     if ($request->isMethod('post')) {

    //         // $oldUser = User::where('email', $request->input('email'))->first();
    //         // if(!($oldUser)){
    //         // $newUsername = Str::slug($request->input('name'));
    //         // $password='user@123';
    //         // $user = User::create([
    //         //     'name' => $request->input('name'),
    //         //     'email' => $request->input('email'),
    //         //     'username' => Str::slug($newUsername) . '_' . Str::random(5),
    //         //     'password' => Hash::make($password),
    //         //     'role' => 'candidate',
    //         // ]);
    //         // if (checkMailConfig()) {
    //         //     if ($user->role == "candidate") {
    //         //         $candidate_account_auto_activation_enabled = Setting::where("candidate_account_auto_activation", 1)->count();
    //         //         if ($candidate_account_auto_activation_enabled) {
    //         //             Notification::route('mail', $user->email)->notify(new CandidateCreateNotification($user, $password));
    //         //         } else {
    //         //             Notification::route('mail', $user->email)->notify(new CandidateCreateApprovalPendingNotification($user, $password));
    //         //         }
    //         //     } elseif ($user->role == "company") {
    //         //         $employer_auto_activation_enabled = Setting::where("employer_auto_activation", 1)->count();
    //         //         if ($employer_auto_activation_enabled) {
    //         //             Notification::route('mail', $user->email)->notify(new CompanyCreatedNotification($user, $password));
    //         //         } else {
    //         //             Notification::route("mail", $user->email)->notify(new CompanyCreateApprovalPendingNotification($user, $password));
    //         //         }
    //         //     }
    //         // }
    //         // // session(['isLoggedIn' => true]);
    //         // // Auth::guard('user')->login($user);
    //         //     return ['status' => 10, 'msg' => 'Lead Submit Successfully'];
    //         // }
    //         // else{
    //             $lead = new Lead;
    //             $lead->name = $request->input('name');
    //             $lead->email = $request->input('email');
    //             $lead->phone = $request->input('phone');
    //             $lead->country_id = $request->input('country');
    //             $lead->url =  $request->input('url');
    //             $lead->source =  $request->input('source');
    //             $questions = [];
    //             $questions['location'] = $request->input('location');
    //             $questions['level'] = $request->input('level');
    //             $questions['journey'] = $request->input('journey');
    //             $jsonData = json_encode($questions);
    //             $lead->description = $jsonData;
    //             $lead = $lead->save();
    //             // if(session(['isLoggedIn' => true])){
    //             //     Auth::guard('user')->login($oldUser);
    //             // }
    //             if($lead){
    //                 return ['status' => 1, 'msg' => 'Lead Submit Successfully'];
    //             }
    //         // }
    //         return ['status' => 0, 'msg' => 'Data Not save in Lead Data'];
    //     }
    // }


    // public function popupData(Request $request)
    // {
    //     if ($request->isMethod('post')) {
    //         if(!empty($request->input('name'))){
    //             $name = $request->input('name');
    //         }
    //         else{
    //             $name = $request->input('name1');
    //         }

    //         // $oldUser = User::where('email', $request->input('email'))->first();
    //         // if(!($oldUser)){
    //         //     $newUsername = Str::slug($request->input('name'));
    //         //     $password='user@123';
    //         //     $user = User::create([
    //         //         'name' => $request->input('name'),
    //         //         'email' => $request->input('email'),
    //         //         'username' => Str::slug($newUsername) . '_' . Str::random(5),
    //         //         'password' => Hash::make($password),
    //         //         'role' => 'candidate',
    //         //     ]);
    //         //     if (checkMailConfig()) {
    //         //         if ($user->role == "candidate") {
    //         //             $candidate_account_auto_activation_enabled = Setting::where("candidate_account_auto_activation", 1)->count();
    //         //             if ($candidate_account_auto_activation_enabled) {
    //         //                 Notification::route('mail', $user->email)->notify(new CandidateCreateNotification($user, $password));
    //         //             } else {
    //         //                 Notification::route('mail', $user->email)->notify(new CandidateCreateApprovalPendingNotification($user, $password));
    //         //             }
    //         //         } elseif ($user->role == "company") {
    //         //             $employer_auto_activation_enabled = Setting::where("employer_auto_activation", 1)->count();
    //         //             if ($employer_auto_activation_enabled) {
    //         //                 Notification::route('mail', $user->email)->notify(new CompanyCreatedNotification($user, $password));
    //         //             } else {
    //         //                 Notification::route("mail", $user->email)->notify(new CompanyCreateApprovalPendingNotification($user, $password));
    //         //             }
    //         //         }
    //         //     }
    //         //     // session(['isLoggedIn' => true]);
    //         //     // Auth::guard('user')->login($user);
    //         //     return ['status' => 1, 'msg' => 'Lead Submit Successfully'];
    //         // }
    //         // else{
    //                 $lead = new Lead;
    //                 $lead->name = $name;
    //                 $lead->email = $request->input('email');
    //                 $lead->phone = $request->input('phone');
    //                 $lead->country_id = $request->input('country');
    //                 $lead->url =  $request->input('url');
    //                 $lead->source =  $request->input('source');
    //                 $questions = [];
    //                 $questions['date'] = $request->input('date');
    //                 $questions['intake'] = $request->input('intake');
    //                 $jsonData = json_encode($questions);
    //                 $lead->description = $jsonData;
    //                 $lead = $lead->save();
    //                 // if(Auth::guard('user')){
    //                 //     Auth::guard('user')->login($oldUser);
    //                 // }
    //                 if($lead){
    //                     return ['status' => 1, 'msg' => 'Lead Submit Successfully'];
    //                 }            
    //                 // }
    //         return ['status' => 0, 'msg' => 'Data Not save in Lead Data'];
    //     }
    // }

    public function blog(Request $request)
    {
        
        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $populars = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(5)->get();
        $trendings = Page::whereIn('category_id', $category_id)->where('trending_blog', 1)->with('category')->published()->latest()->take(2)->get();
        $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->paginate(5);
        
        return view('website.' . $this->device . '.pages.blog', compact(['populars', 'trendings', 'blogs']));
    }

    public function blogCategory(Request $request, $slug)
    {
        if ($slug == 'courses') {
            $blogCategory = Page::where('category_id', 36)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 36)->latest()->published()->get();
        }
        if ($slug == 'university') {
            $blogCategory = Page::where('category_id', 42)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 42)->latest()->published()->get();
        }
        if ($slug == 'exams') {
            $blogCategory = Page::where('category_id', 37)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 37)->latest()->published()->get();
        }
        if ($slug == 'travel') {
            $blogCategory = Page::where('category_id', 43)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 43)->latest()->published()->get();
        }
        if ($slug == 'finance') {
            $blogCategory = Page::where('category_id', 38)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 38)->latest()->published()->get();
        }
        if ($slug == 'visa') {
            $blogCategory = Page::where('category_id', 41)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 41)->latest()->published()->get();
        }
        if ($slug == 'scholarships') {
            $blogCategory = Page::where('category_id', 40)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 40)->latest()->published()->get();
        }
        if ($slug == 'jobs') {
            $blogCategory = Page::where('category_id', 39)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 39)->latest()->published()->get();
        }
        if ($slug == 'news') {
            $blogCategory = Page::where('category_id', 35)->with('category')->latest()->published()->paginate(5);
            $blogs = Page::where('category_id', 35)->latest()->published()->get();
        }
        if ($slug == 'all') {
            $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();            
            $blogCategory = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->paginate(5);
            $blogs = [];
        }
        if ($slug == 'study-abroad') {
            $category_id = Category::where('parent_id', 15)->where('url',$slug)->pluck('id');
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }
        if ($slug == 'life-at-abroad') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }       
        if ($slug == 'ielts') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        } 
        if ($slug == 'pte') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }if ($slug == 'toefl') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }if ($slug == 'duolingo') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }if ($slug == 'language') {
            $category_id = Category::Select('id')->where('parent_id', 15)->where('url',$slug)->pluck('id');        
            $blogs = Page::where('category_id', $category_id)->latest()->published()->get();
            $blogCategory = Page::where('category_id', $category_id)->with('category')->latest()->published()->paginate(5);
        }   

        if (empty($blogCategory)) abort(404);

        $blogCategory->setCollection($blogCategory->getCollection());
        
        if ($request->isMethod('post')) {
            return response()->json([
                'status' => 1,
                'blogCategory' => $blogCategory,
                'pagination_html' => $blogCategory->links()->toHtml(),
                'slug' => $slug
            ]);
        }
        abort_if($slug == 'all', 404);

        return view('website.' . $this->device . '.pages.blogCategory', compact(['blogCategory', 'slug', 'blogs']));        
    }

    public function blogSubcategory(Request $request)
    {
        $parent_category_id = Category::select('id')->where('parent_id', 15)->where('url',$request->exam)->first();

        $parent_tag_ids = TagTranslation::whereIn('name', explode(',', $request->exam))->pluck('tag_id')->toArray();
        $filter_tag_ids = TagTranslation::whereIn('name', explode(',', $request->url))->pluck('tag_id')->toArray();
        
        $combined_ids = array_merge($parent_tag_ids, $filter_tag_ids);    
        
        $blogCategory = Page::where('category_id',$parent_category_id->id)->with('category')->whereRaw('FIND_IN_SET(?, tag_id) AND FIND_IN_SET(?, tag_id)', $combined_ids)->latest()->published()->paginate(5);
                
        $blogCategory->setCollection($blogCategory->getCollection());
        
        return response()->json([
            'status' => 1,
            'blogCategory' => $blogCategory,
            'pagination_html' => $blogCategory->links()->toHtml(),
        ]);
    }

    public function blogSearch(Request $request)
    {
        $categoryIds = Category::where('parent_id', 15)->pluck('id')->toArray();

        $query = Page::query();

        if (!empty($request->category) && isset($request->category)) {
            $query->where('category_id', $request->category);
        }

        if (!empty($request->q) && isset($request->q)) {
            $query->where('header_title', 'like', '%' . $request->q . '%');
        }

        if (!empty($request->country) && isset($request->country)) {
            $query->where('country_id', $request->country);
        }

        if (empty($request->category)) {
            $query->whereIn('category_id', $categoryIds);
        }

        $blogSearch = $query
            ->with('category')
            ->published()
            ->paginate(5);


        $blogSearch->setCollection($blogSearch->getCollection());
        $paginator = new Paginator($blogSearch, $blogSearch->perPage(), $blogSearch->currentPage());

        return response()->json([
            'blogSearch' => $paginator->toArray(),
            'pagination_html' => $blogSearch->links()->toHtml(),
            'status' => 1,
        ]);
    }


    public function blogDetails(Request $request)
    {

        return view('website.pages.blog-details');
    }


    public function searchData(Request $search)
    {
        $condition = ['status' => 1];
        $search = $search["search"] ?? "";
        if ($search != "") {
            $data = Course::where('name', 'like', '%' . $search . '%')->with('university')->get();

            if (count($data) > 0) {
                $universityData = Universities::where('status', 1)->whereIn('id', $data->pluck('university_id'))->with('countries')->get();
            } else {
                $universityData = Universities::where('status', 1)->where('name', 'like', '%' . $search . '%')->with('countries')->get();
                $data = Course::whereIn('id', $universityData->pluck('id'))->with('university')->get();
            }
            return view('website.' . $this->device . '.pages.search', compact(['data', 'universityData']));
        } else {
            return view('website.' . $this->device . '.pages.index');
        }

        // $data = Course::where('name','like','%'.$search.'%')->with('university')->get()->toArray();
        // $universityData = Universities::where('name','like','%'.$search.'%')->with('courses')->get()->toArray();
    }


    public function countryNew(Request $request, $country)
    {
        // dd($country);
        $pages_categories = Page::where('url', $country)->where('category_id', 16)->with('country')->published()->first();
        // $pages_categories = Category::with(['pages'])->where('type','page')
        // ->whereHas('pages', function ($q) use ($country) {
        //     $q->where('url', $country)
        //    ->where('category_id', 16);
        // })
        // ->first();
        // dd($pages_categories->country_id);

        if (empty($pages_categories)) abort(404);
        session(['countryName' => @$pages_categories->title]);

        if (!empty($pages_categories->country_id)) {
            $universityData = University::where('country_id', $pages_categories->country_id)->where('status', 1)->select('id', 'name', 'country_id', 'url')->get()->toArray();
            // dd($universityData);
            $courseCounts = Course::select('course_categories.name', 'course_categories.id', DB::raw('COUNT(courses.id) AS courseCount'))
                ->join('course_categories', 'course_categories.id', '=', 'courses.course_categories_id')
                ->whereIn('university_id', function ($query) use ($pages_categories) {
                    $query->select('id')
                        ->from('universities')
                        ->where('country_id', '=', $pages_categories->country_id);
                })
                ->groupBy(['course_categories.id', 'course_categories.name'])
                ->get()->toArray();
            $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 33)->where('page_id', $pages_categories->country_id)->where('status', 1)->orderBy('id', 'desc')->get();
        } else {
            $universityData = [];
            $courseCounts = [];
            $faqs = [];
        }

        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();
        $reviews = [];

        $querys = Review::query()->select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images',)->where('category_id', 34)->where('page_id', $pages_categories->country_id)->orderBy('display_date', 'DESC');
        if (!empty($request->rating_search)) {
            $querys->where('star_rating', $request->rating_search);
        }
        $reviews = $querys->get();

        $count_university = count($universityData);

        return view('website.' . $this->device . '.pages.new-country-details', compact('pages_categories', 'universityData', 'courseCounts', 'faqs', 'country', 'blogs', 'reviews', 'count_university'));
    }
    // public function universitiesGetByCountry(Request $request)
    // {
    //     if(!empty($request->country_id)){
    //         // $universities = University::where('country_id',$request->country_id)->get();
    //         $querys = Universities::query()
    //         ->select('id', 'name', 'address', 'headerImageDesktop', 'qs_ranking', 'url', 'university_icon')
    //         ->where('status', 1)
    //         ->with(['review', 'courses' => function ($query) {
    //             $query->select('id', 'university_id', 'Amount','Currency');
    //         }]);

    //         $querys->withCount('courses');

    //         $country_url = Country::Select('url','symbol')->where('id',$request->country_id)->first()->toArray();
    //         if ($request->country_id) {
    //             $querys->where('country_id', $request->country_id);
    //         }

    //         $page = $request->input('page', 1);
    //         $limit = $request->input('limit', 8);
    //         $universities = $querys->whereNotNull('sorting')
    //         ->take($limit)
    //         ->get();

    //         foreach ($universities->courses as $university) {
    //             if ($request->currency == 'INR') {
    //                 $totalAmount = 0;
    //                 foreach ($university->InrAmount as $amount) {
    //                     $totalAmount += $amount;
    //                 }
    //                 $university->Amount = $totalAmount / count($university->InrAmount);
    //             } else {
    //                 $totalAmount = 0;
    //                 foreach ($university->Amount as $amount) {
    //                     $totalAmount += $amount;
    //                 }
    //                 $university->Amount = $totalAmount / count($university->Amount);
    //             }
    //         }

    //         $totalUniversity = $querys->whereNotNull('sorting')->count();

    //         $universitiesArray = $universities->map(function ($university) {
    //             return $university->toArray();
    //         })->all();

    //         foreach ($universitiesArray as $key => $value) {

    //             $universitiesArray[$key]['totel_star_rating'] = 0;
    //             if(!empty($value['review'])){  
    //                 $ratingTotel = (count($value['review'])*5);
    //                 $universitiesArray[$key]['totel_star_rating'] = 0;
    //                 $count_review = 0;
    //                 foreach ($value['review'] as $r_value) {
    //                    $count_review = $count_review+$r_value['star_rating']; 
    //                 }
    //                    $universitiesArray[$key]['totel_star_rating'] = ratingCalculate($count_review , $ratingTotel); 
    //             }
    //         }        
    //     }else{
    //         $universitiesArray = [];
    //     }

    //     $levels = Course::select('course_level')->groupBy('course_level')->get();
    //     $streams = StudyArea::all();
    //     $exams = Exam::all();
    //     $cities = State::Select('id', 'name')->where('country_id', $request->country_id)->get();

    //     $filter = Universities::where('country_id', $request->country_id)->with('courses')->get();
    //     return response()->json([
    //         'university'=>$universitiesArray,
    //         'filter' => $filter,
    //         'country_url' => $country_url,
    //         'programs' => $exams,
    //         'streams' => $streams,
    //         'levels' => $levels,
    //         'totalUniversity' => $totalUniversity,
    //         'cities' => $cities,
    //     ]);
    // }

    public function universitiesGetByCountry(Request $request)
    {
        $country_url = '';
        if ($request->country_id) {
            $querys = Universities::query()
                ->select('id', 'name', 'qs_ranking', 'url', 'recommended')
                ->where('status', 1)
                ->with(['courses:id,university_id,Amount,Currency,InrAmount,SatRequired,GmatRequired,ActRequired,GreRequired,IeltsRequired,ToeflRequired,PteRequired,DETRequired,Intakes', 'countries']);

            $country_url = Country::select('url', 'symbol')->where('id', $request->country_id)->first()->toArray();
            if ($request->country_id) {
                $querys->where('country_id', $request->country_id);
            }

            // Nayan Soni
            if (!empty($request->search)) {
                $search = str_replace(['university', 'college', 'colleges', 'universities'], '', strtolower($request->search));

                // Full-text search
                $fullTextMatches = Universities::whereRaw("MATCH(name) AGAINST(? IN BOOLEAN MODE)", [$search])
                    ->pluck('id');
                if ($fullTextMatches->isNotEmpty()) {
                    $result = $fullTextMatches;
                } else {
                    // Split Match
                    $searchWords = explode(' ', $search);
                    $searchWords = array_filter($searchWords, function ($word) {
                        return strlen($word) > 3;
                    });
                    $maxDistance = 3;
                    $searchWords = array_diff($searchWords, ['university', 'college', 'colleges', 'universities','technology']);

                    // Levenshtein Extra Matches
                    $levenshteinExtraMatches = Universities::select('id', 'name')
                        ->get()
                        ->map(function ($university) use ($searchWords, $maxDistance) {
                            $nameParts = explode(' ', str_replace(['university', 'college', 'colleges', 'universities'], '', strtolower($university->name)));
                            $nameParts = array_filter($nameParts, function ($word) {
                                return strlen($word) > 2;
                            });

                            $totalDistance = 0;
                            foreach ($nameParts as $namePart) {
                                $minDistance = 5;
                                foreach ($searchWords as $searchWord) {
                                    $distance = levenshtein($namePart, strtolower($searchWord));
                                    if ($distance < $minDistance) {
                                        $minDistance = $distance;
                                    }
                                }
                                $totalDistance += $minDistance;
                            }

                            return [
                                'id' => $university->id,
                                'name' => $university->name,
                                'distance' => $totalDistance
                            ];
                        })
                        ->filter(function ($university) use ($maxDistance) {
                            return $university['distance'] <= $maxDistance; // Filter out matches exceeding the maximum distance
                        })
                        ->sortBy('distance')
                        ->pluck('name');

                    if ($levenshteinExtraMatches->isNotEmpty()) {
                        $searchWords = explode(' ', strtolower($levenshteinExtraMatches->implode(' '))); // Implode to get a string, then explode to split into words

                        $searchWords = array_filter($searchWords, function ($word) {
                            return strlen($word) > 3;
                        });
                        $searchWords = array_diff($searchWords, ['university', 'college', 'colleges', 'universities']);

                        $split = Universities::select('id')
                            ->whereIn('name', function ($query) use ($searchWords) {
                                $query->select('name')
                                    ->from('universities')
                                    ->where(function ($innerQuery) use ($searchWords) {
                                        $innerQuery->where(function ($subQuery) use ($searchWords) {
                                            foreach ($searchWords as $word) {
                                                $subQuery->orWhere('name', 'like', '%' . $word . '%');
                                            }
                                        });
                                    });
                            })
                            ->pluck('id');

                        $result = $split;
                    } else {
                        $exact = Universities::where('name', $search)->pluck('id')->first();
                        if ($exact) {
                            $result = $exact;
                        } else {
                            // Partial Match
                            $partial = Universities::where('name', 'like', '%' . $search . '%')->pluck('id');
                            if (!$partial->isEmpty()) {
                                $result = $partial;
                            } else {
                                if (!empty($searchWords)) {
                                    $split = Universities::select('id')
                                        ->whereIn('name', function ($query) use ($searchWords) {
                                            $query->select('name')
                                                ->from('universities')
                                                ->where(function ($innerQuery) use ($searchWords) {
                                                    $innerQuery->where(function ($subQuery) use ($searchWords) {
                                                        foreach ($searchWords as $word) {
                                                            $subQuery->orWhere('name', 'like', '%' . $word . '%');
                                                        }
                                                    });
                                                });
                                        })
                                        ->pluck('id');

                                    if ($split->isNotEmpty()) {
                                        $result = $split;
                                    } else {
                                        // Levenshtein Distance
                                        $levenshtein = Universities::select('name', 'id')
                                            ->get()
                                            ->map(function ($university) use ($search, $maxDistance) {
                                                $distance = levenshtein(strtolower($university->name), $search);
                                                return [
                                                    'id' => $university->id,
                                                    'name' => $university->name,
                                                    'distance' => $distance,
                                                    'isMatch' => $distance <= $maxDistance // Check if the distance is within the threshold
                                                ];
                                            })
                                            ->filter(function ($university) {
                                                return $university['isMatch']; // Filter out matches that exceed the threshold
                                            })
                                            ->sortBy('distance')
                                            ->pluck('id');

                                        if ($levenshtein->isNotEmpty()) {
                                            $result = $levenshtein;
                                        } else {
                                            $result = [];
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                
                $querys->whereIn('id', $result)->orderBy('recommended', 'DESC');
            }

            if ($request->MinValue != null && $request->MaxValue != null) {
                $sliderMinValue = $request->MinValue;
                $sliderMaxValue = $request->MaxValue;
                if ($request->currency != 'INR' && $sliderMaxValue <= 100000) {
                    $querys->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                        $query->select(DB::raw('avg(Amount) as average_amount'))
                            ->havingRaw('average_amount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                    });
                } else {
                    $querys->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                        $query->select(DB::raw('avg(InrAmount) as average_inramount'))
                            ->havingRaw('average_inramount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                    });
                }
            }

            $limit = $request->input('limit', 8);
            $universities = $querys->paginate($limit);

            $totalUniversity = $querys->count();
            $universitiesArray = $universities->map(function ($university) {
                return $university->toArray();
            })->all();

            $city_id = Universities::select('city_id')->where('country_id', $request->country_id)->groupBy('city_id')->get()->pluck('city_id')->toArray();
            $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
        } else {
            $querys = Universities::query()
                ->select('id', 'name', 'qs_ranking', 'url', 'recommended', 'country_id')
                ->where('status', 1)
                ->with(['countries', 'courses:id,university_id,Amount,Currency,InrAmount,SatRequired,GmatRequired,ActRequired,GreRequired,IeltsRequired,ToeflRequired,PteRequired,DETRequired,Intakes']);

            // Nayan Soni
            if (!empty($request->search)) {
                $search = str_replace(['university', 'college', 'colleges', 'universities'], '', strtolower($request->search));

                // Full-text search
                $fullTextMatches = Universities::whereRaw("MATCH(name) AGAINST(? IN BOOLEAN MODE)", [$search])
                    ->pluck('id');
                if ($fullTextMatches->isNotEmpty()) {
                    $result = $fullTextMatches;
                } else {
                    // Split Match
                    $searchWords = explode(' ', $search);
                    $searchWords = array_filter($searchWords, function ($word) {
                        return strlen($word) > 3;
                    });
                    $maxDistance = 3;
                    $searchWords = array_diff($searchWords, ['university', 'college', 'colleges', 'universities','technology']);

                    // Levenshtein Extra Matches
                    $levenshteinExtraMatches = Universities::select('id', 'name')
                        ->get()
                        ->map(function ($university) use ($searchWords, $maxDistance) {
                            $nameParts = explode(' ', str_replace(['university', 'college', 'colleges', 'universities'], '', strtolower($university->name)));
                            $nameParts = array_filter($nameParts, function ($word) {
                                return strlen($word) > 2;
                            });

                            $totalDistance = 0;
                            foreach ($nameParts as $namePart) {
                                $minDistance = 5;
                                foreach ($searchWords as $searchWord) {
                                    $distance = levenshtein($namePart, strtolower($searchWord));
                                    if ($distance < $minDistance) {
                                        $minDistance = $distance;
                                    }
                                }
                                $totalDistance += $minDistance;
                            }

                            return [
                                'id' => $university->id,
                                'name' => $university->name,
                                'distance' => $totalDistance
                            ];
                        })
                        ->filter(function ($university) use ($maxDistance) {
                            return $university['distance'] <= $maxDistance; // Filter out matches exceeding the maximum distance
                        })
                        ->sortBy('distance')
                        ->pluck('name');

                    if ($levenshteinExtraMatches->isNotEmpty()) {
                        $searchWords = explode(' ', strtolower($levenshteinExtraMatches->implode(' '))); // Implode to get a string, then explode to split into words

                        $searchWords = array_filter($searchWords, function ($word) {
                            return strlen($word) > 3;
                        });
                        $searchWords = array_diff($searchWords, ['university', 'college', 'colleges', 'universities']);

                        $split = Universities::select('id')
                            ->whereIn('name', function ($query) use ($searchWords) {
                                $query->select('name')
                                    ->from('universities')
                                    ->where(function ($innerQuery) use ($searchWords) {
                                        $innerQuery->where(function ($subQuery) use ($searchWords) {
                                            foreach ($searchWords as $word) {
                                                $subQuery->orWhere('name', 'like', '%' . $word . '%');
                                            }
                                        });
                                    });
                            })
                            ->pluck('id');

                        $result = $split;
                    } else {
                        $exact = Universities::where('name', $search)->pluck('id')->first();
                        if ($exact) {
                            $result = $exact;
                        } else {
                            // Partial Match
                            $partial = Universities::where('name', 'like', '%' . $search . '%')->pluck('id');
                            if (!$partial->isEmpty()) {
                                $result = $partial;
                            } else {
                                if (!empty($searchWords)) {
                                    $split = Universities::select('id')
                                        ->whereIn('name', function ($query) use ($searchWords) {
                                            $query->select('name')
                                                ->from('universities')
                                                ->where(function ($innerQuery) use ($searchWords) {
                                                    $innerQuery->where(function ($subQuery) use ($searchWords) {
                                                        foreach ($searchWords as $word) {
                                                            $subQuery->orWhere('name', 'like', '%' . $word . '%');
                                                        }
                                                    });
                                                });
                                        })
                                        ->pluck('id');

                                    if ($split->isNotEmpty()) {
                                        $result = $split;
                                    } else {
                                        // Levenshtein Distance
                                        $levenshtein = Universities::select('name', 'id')
                                            ->get()
                                            ->map(function ($university) use ($search, $maxDistance) {
                                                $distance = levenshtein(strtolower($university->name), $search);
                                                return [
                                                    'id' => $university->id,
                                                    'name' => $university->name,
                                                    'distance' => $distance,
                                                    'isMatch' => $distance <= $maxDistance // Check if the distance is within the threshold
                                                ];
                                            })
                                            ->filter(function ($university) {
                                                return $university['isMatch']; // Filter out matches that exceed the threshold
                                            })
                                            ->sortBy('distance')
                                            ->pluck('id');

                                        if ($levenshtein->isNotEmpty()) {
                                            $result = $levenshtein;
                                        } else {
                                            $result = [];
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                $querys->whereIn('id', $result)->orderBy('recommended', 'DESC');
            }

            if (!empty($request->intake) && $request->intake != 'undefined') {
                $querys->whereHas('courses', function ($query) use ($request) {
                    $query->where('intakes', 'like', '%' . $request->intake . '%');
                });
            }

            if (!empty($request->year) && $request->year == date('Y') && $request->intake != 'undefined') {
                $currentMonth = intval(date('m'));
                if (!empty($request->intake)) {
                    $intakeMonth = date_parse_from_format("M", $request->intake)["month"];
                    if ($intakeMonth <= $currentMonth) {
                        $querys->where('name', 'fsgvsfbvsDFb');
                    }
                }
            }

            if ($request->MinValue != null && $request->MaxValue != null) {
                $sliderMinValue = $request->MinValue;
                $sliderMaxValue = $request->MaxValue;
                if ($request->currency != 'INR' && $sliderMaxValue <= 100000) {
                    $querys->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                        $query->select(DB::raw('avg(Amount) as average_amount'))
                            ->havingRaw('average_amount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                    });
                } else {
                    $querys->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                        $query->select(DB::raw('avg(InrAmount) as average_inr_amount'))
                            ->havingRaw('average_inr_amount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                    });
                }
            }


            $limit = $request->input('limit', 8);
            $universities = $querys->paginate($limit);
            $totalUniversity = $querys->count();

            $universitiesArray = $universities->map(function ($university) {
                return $university->toArray();
            })->all();

            $city_id = Universities::select('city_id')->groupBy('city_id')->get()->pluck('city_id')->toArray();
            $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
        }

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

        return response()->json([
            'university' => $universitiesArray,
            'country_url' => $country_url,
            'programs' => $exams,
            'streams' => $streams,
            'levels' => $levels,
            'totalUniversity' => $totalUniversity,
            'cities' => $cities,
        ]);
    }

    // public function universitiesGetByCountryFilter(Request $request)
    // {
    //     $courseLevel = $request->courseLevel;
    //     $courseLevelArray = explode(',', @$courseLevel);  
    //     $program = $request->program;
    //     $stream = $request->stream;
    //     $universityType = $request->universityType;
    //     $universityTypeArray = explode(',', $universityType);

    //     $universities_id = Universities::Select('id')->where('country_id', $request->country_id)->get()->toArray();

    //     $query = Course::select('university_id');

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

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

    //     $data = $query->groupBy('university_id')
    //                 ->get()
    //                 ->toArray();

    //     $country_url = Country::Select('url')->where('id',$request->country_id)->first()->toArray();
    //     $universityIds = array_column($data, 'university_id');
    //     $querys = Universities::whereIn('id', $universityIds)->with('courses');

    //     if (!empty($universityTypeArray)) {
    //         $querys->whereIn('university_type', $universityTypeArray);
    //     }
    //     $university = $querys->get()->toArray();
    //     dd($university);

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

    //     foreach ($levels as $level) {
    //         // Check if the name exists in the $courseLevelArray
    //         if (in_array($level->name, $courseLevelArray)) {
    //             $level->status = true;
    //         } else {
    //             $level->status = false;
    //         }
    //     }

    //     return response()->json([
    //         'university' => $university,
    //         'country_url' => $country_url,
    //         'programs' => $exams,
    //         'streams' => $streams,
    //         'levels' => $levels,
    //     ]);
    // }

    // public function universitiesGetByCountryFilter(Request $request)
    // {

    //     $country_url = '';
    //     $page = $request->input('page', 1);
    //     $limit = $request->input('limit', 8);

    //     $courseLevel = $request->courseLevel;
    //     $courseLevelArray = explode(',', $courseLevel ?? '');  

    //     $exam = $request->exam;
    //     $examArray = explode(',', $exam);

    //     $stream = $request->stream;
    //     $streamArray = explode(',', $stream);

    //     $universityType = $request->universityType;
    //     $universityTypeArray = explode(',', $universityType);

    //     $rank = $request->rank;
    //     $rank = intval($rank);

    //     $city = $request->city;
    //     $cityArray = explode(',', $city);

    //     if(!$request->country_id){
    //         $city_id = Universities::select('city_id')->groupBy('city_id')->get()->pluck('city_id')->toArray();
    //         $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
    //         $query = Universities::select('id');
    //     }else{
    //         $query = Universities::where('country_id', $request->country_id);
    //         $city_id = Universities::select('city_id')->where('country_id',$request->country_id)->groupBy('city_id')->get()->pluck('city_id')->toArray();
    //         $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
    //         $country_url = Country::select('url','symbol')->where('id', $request->country_id)->first();
    //     }

    //     $universities_id = $query->pluck('id')->toArray();
    //     $query = Course::select('university_id');

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

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

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

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

    //     $data = $query->groupBy('university_id')
    //     ->get()
    //     ->pluck('university_id')
    //     ->toArray();

    //     $universityIds = $data;
    //     $query = Universities::whereIn('id', $universityIds)->where('status', 1)->with(['courses:id,university_id,Amount,Currency,InrAmount,SatRequired,GmatRequired,ActRequired,GreRequired,IeltsRequired,ToeflRequired,PteRequired,DETRequired,Intakes','countries']);

    //     if (!empty($universityType)) {
    //         $query->whereIn('university_type', $universityTypeArray);
    //     }
    //     if (!empty($rank)) {
    //         $query->where(function ($query) use ($rank) {
    //             $query->where('qs_ranking', '<=', $rank)
    //                 ->WhereNotNull('qs_ranking');
    //         });
    //     }

    //     if (!empty($city)) {
    //        $query->whereIn('city_id',$cityArray);
    //     }

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

    //     $university = $query->skip(($page - 1) * $limit)
    //     ->take($limit)
    //     ->get()
    //     ->toArray();

    //     $totalUniversity = $query->count();

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

    //     foreach ($levels as $level) {
    //         // Check if the name exists in the $courseLevelArray
    //         if (in_array($level->course_level, $courseLevelArray)) {
    //             $level->checked = true;
    //         } else {
    //             $level->checked = false;
    //         }
    //     }

    //     foreach ($streams as $stream) {
    //         // Check if the name exists in the $courseLevelArray
    //         if (in_array($stream->id, $streamArray)) {
    //             $stream->checked = true;
    //         } else {
    //             $stream->checked = false;
    //         }
    //     }

    //     foreach ($cities as $city) {
    //         // Check if the name exists in the $courseLevelArray
    //         if (in_array($city->id, $cityArray)) {
    //             $city->checked = true;
    //         } else {
    //             $city->checked = false;
    //         }
    //     }
    //     return response()->json([
    //         'university' => $university,
    //         'country_url' => $country_url,
    //         'programs' => $exams,
    //         'streams' => $streams,
    //         'levels' => $levels,
    //         'cities' => $cities,
    //         'totalUniversity' => $totalUniversity,
    //     ]);

    // }

    public function universitiesGetByCountryFilter(Request $request)
    {

        $country_url = '';
        $page = $request->input('page', 1);
        $limit = $request->input('limit', 8);

        $courseLevel = $request->courseLevel;
        $courseLevelArray = explode(',', $courseLevel ?? '');

        $exam = $request->exam;
        $examArray = explode(',', $exam);

        $stream = $request->stream;
        $streamArray = explode(',', $stream);

        $universityType = $request->universityType;
        $universityTypeArray = explode(',', $universityType);

        $rank = $request->rank;
        $rank = intval($rank);

        $city = $request->city;
        $cityArray = explode(',', $city);

        $query = Universities::where('status', 1)->with(['courses:id,university_id,Amount,Currency,InrAmount,SatRequired,GmatRequired,ActRequired,GreRequired,IeltsRequired,ToeflRequired,PteRequired,DETRequired,Intakes', 'countries']);

        if (!$request->country_id) {

            $city_id = Universities::select('city_id')->groupBy('city_id')->get()->pluck('city_id')->toArray();
            $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
        } else {
            $query->where('country_id', $request->country_id);

            $city_id = Universities::select('city_id')->where('country_id', $request->country_id)->groupBy('city_id')->get()->pluck('city_id')->toArray();
            $cities = City::select('id', 'name')->whereIn('id', $city_id)->get();
            $country_url = Country::select('url', 'symbol')->where('id', $request->country_id)->first();
        }

        if (!empty($courseLevel)) {
            $query->whereHas('courses', function ($query) use ($courseLevelArray) {
                $query->whereIn('course_level', $courseLevelArray);
            });
        }

        if (!empty($stream)) {
            $query->whereHas('courses', function ($query) use ($streamArray) {
                $query->whereIn('study_area_id', $streamArray);
            });
        }

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

        if (!empty($rank)) {
            $query->where(function ($query) use ($rank) {
                $query->where('qs_ranking', '<=', $rank)
                    ->where('qs_ranking', '>', 0);
            });
        }

        if (!empty($city)) {
            $query->whereIn('city_id', $cityArray);
        }

        if (!empty($universityType)) {
            $query->whereIn('university_type', $universityTypeArray);
        }

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

        if (!empty($request->intake) && $request->intake != 'undefined') {
            $query->whereHas('courses', function ($query) use ($request) {
                $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('name', 'fsgvsfbvsDFb');
                }
            }
        }

        if ($request->MinValue != null && $request->MaxValue != null) {
            $sliderMinValue = $request->MinValue;
            $sliderMaxValue = $request->MaxValue;
            if ($request->currency != 'INR') {
                $query->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                    $query->select(DB::raw('avg(Amount) as average_amount'))
                        ->havingRaw('average_amount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                });
            } else {
                $query->whereHas('courses', function ($query) use ($sliderMinValue, $sliderMaxValue) {
                    $query->select(DB::raw('avg(InrAmount) as average_inr_amount'))
                        ->havingRaw('average_inr_amount BETWEEN ? AND ?', [$sliderMinValue, $sliderMaxValue]);
                });
            }
        }

        $university = $query->skip(($page - 1) * $limit)
            ->take($limit)
            ->get()
            ->toArray();

        $totalUniversity = $query->count();

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


        foreach ($levels as $level) {
            // Check if the name exists in the $courseLevelArray
            if (in_array($level->course_level, $courseLevelArray)) {
                $level->checked = true;
            } else {
                $level->checked = false;
            }
        }

        foreach ($streams as $stream) {
            // Check if the name exists in the $courseLevelArray

            if (in_array($stream->id, $streamArray)) {
                $stream->checked = true;
            } else {
                $stream->checked = false;
            }
        }

        foreach ($cities as $city) {
            // Check if the name exists in the $courseLevelArray
            if (in_array($city->id, $cityArray)) {
                $city->checked = true;
            } else {
                $city->checked = false;
            }
        }
        return response()->json([
            'university' => $university,
            'country_url' => $country_url,
            'programs' => $exams,
            'streams' => $streams,
            'levels' => $levels,
            'cities' => $cities,
            'totalUniversity' => $totalUniversity,
        ]);
    }

    // public function universitiesGetByCountry(Request $request)
    // {
    //     if (!empty($request->country_id)) {
    //         $querys = Universities::query()->select('id', 'name', 'address', 'headerImageDesktop', 'url')->where('status', 1)->with('review', 'courses');
    //         $querys->withCount('courses');

    //         if ($request->country_id) {
    //             $querys->where('country_id', $request->country_id);
    //         }

    //         if (!empty($request->universities_search)) {
    //             $querys->where('name', 'LIKE', "%$request->universities_search%")
    //                 ->orWhere('email', 'LIKE', "%$request->universities_search%");
    //         }

    //         $universities = $querys->whereNotNull('sorting')->paginate(6);

    //         $universitiesArray = $universities->map(function ($university) {
    //             $universityArray = $university->toArray();
    //             $universityArray['totel_star_rating'] = 0;

    //             if (!empty($universityArray['review'])) {
    //                 $ratingTotel = (count($universityArray['review']) * 5);
    //                 $count_review = 0;

    //                 foreach ($universityArray['review'] as $r_value) {
    //                     $count_review = $count_review + $r_value['star_rating']; 
    //                 }

    //                 $universityArray['totel_star_rating'] = ratingCalculate($count_review, $ratingTotel);          
    //             }

    //             return $universityArray;
    //         })->all();

    //         $paginationLinks = $universities->appends(request()->query())->links();
    //         $paginationLinks = str_replace('/universities/by/country?', '/uk?', $paginationLinks->toHtml());
    //         $universitiesArray['paginationLinks'] = $paginationLinks;

    //     } else {
    //         $universitiesArray = [];
    //     }

    //     return response()->json(['universities' => $universitiesArray]);
    // }  


    public function reviewGetByCountry(Request $request)
    {

        // dd($request->all());
        // if(!empty($request->country_id)){
        //     $universityIds = University::where('country_id', $request->country_id)->pluck('id')->toArray();
        //     // dd($universityIds);
        //     // dd($universityIds);


        //     if(!empty($universityIds)){
        //         $querys = Review::query()->select('id', 'name', 'address', 'comments' ,'star_rating', 'display_date', 'created_at','images',)->where('category_id', 32)->orderBy('display_date','DESC');
        //         if ($universityIds) {
        //             $querys->whereIn('page_id', $universityIds);
        //         }
        //         if (!empty($request->rating_search)) {
        //             $querys->where('star_rating', $request->rating_search);
        //         }
        //         $reviews = $querys->get()->toArray();
        //     }else{
        //         $reviews = [];
        //     }


        // }else{
        //     $reviews = [];
        // }
        $reviews = [];
        if (!empty($request->country_id)) {
            $querys = Review::query()->select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images',)->where('category_id', 34)->where('page_id', $request->country_id)->orderBy('display_date', 'DESC');
            if (!empty($request->rating_search)) {
                $querys->where('star_rating', $request->rating_search);
            }
            $reviews = $querys->get()->toArray();
        }


        // dd($reviews);

        return response()->json($reviews);
    }


    public function leadfrom(Request $request)
    {        
        $currentUrl = @$_COOKIE['web_journey'];

        if($currentUrl){
            $currentUrl = json_encode($currentUrl);
            setcookie('web_journey', '', time() - 3600, '/');
            unset($_COOKIE['web_journey']);
        }

        $lead = new Lead;
        $lead->name = $request->input('name');
        $lead->email = $request->input('email');
        $lead->source_url = @$currentUrl ? @$currentUrl : null;
        $lead->phone = $request->input('number');
        $lead->country_id = $request->input('country');
        $lead->url =  $request->input('url');
        $lead = $lead->save();
        $data = [
            'success' => true,
            'message' => 'Successfully Saved'
        ];

        return response()->json($data);
    }


    public function newBlogDetails(Request $request, $blogType, $url)
    {

        $categories = Category::select('id', 'name')->where('type', 'page')->where('url', $blogType)->where('parent_id', 15)->first();
        $all_blog_categories_ids = Category::where('parent_id', 15)->pluck('id')->toArray();
        if (!empty($all_blog_categories_ids)) {
            $latest_blog = Page::select('id', 'header_title', 'category_id', 'url')->whereIn('category_id', $all_blog_categories_ids)->with(['category'])->latest()->published()->take(4)->get();
        } else {
            $latest_blog = null;
        }
        if (empty($categories)) abort(404);
        if (!empty($categories)) {
            $pages_categories = Page::whereRaw('BINARY url = ?', [$url])->where('category_id', $categories->id)->published()->first();
            if (!empty($pages_categories->tag_id)) {
                $tag_ids = explode(",", $pages_categories->tag_id);
                $tags = Tag::whereIn('id', $tag_ids)->get()->toArray();
            } else {
                $tags = [];
            }

            if (!empty($pages_categories->comments)) {
                $pages_categories->commentsCount =  count($pages_categories->comments);
            } else {
                // $pages_categories->comments = [];
                // $pages_categories->comments = 0;
            }
        }
        if (empty($pages_categories)) abort(404);
        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $populars = Page::whereIn('category_id', $category_id)->where('url', '!=', $pages_categories->url)->with('category')->published()->latest()->take(3)->get();
        $related_blogs = Page::where('category_id', $categories->id)->where('url', '!=', $url)->published()->with('category')->latest()->get();


        return view('website.' . $this->device . '.pages.new-blog-details', compact('pages_categories', 'tags', 'latest_blog', 'related_blogs', 'populars'));
    }


    // public function city(Request $request)
    // {
    //     return view('website.pages.city');
    // }


    public function pageFormDataComment(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'comment' => 'required|max:2500|min:2',
            'page_id' => 'required',
        ]);

        if ($validator->fails()) {

            return [
                'status' => 0,
                'msg' => 'The given data was invalid.',
                'errors' => $validator->errors(),
            ];
        }


        $comment = new PageComment();
        $comment->page_id = $request->page_id;
        if (auth('user')->check()) {
            $comment->name = auth('user')->user()->name;
            $comment->email = auth('user')->user()->email;
            $comment->phone = auth('user')->user()->phone;
            $comment->created_by =  auth('user')->user()->id;
            
        } else {
            $comment->name = $request->name;
            $comment->email = $request->email;
            $comment->phone = $request->phone;
        }

        $comment->comment = $request->comment;
        $comment->user_type = "user";
        $comment->url = $request->url;
        $comment->status = 0;
        $comment->save();

        if (!empty($comment)) {      

            $currentUrl = @$_COOKIE['web_journey'];

            if($currentUrl){
                $currentUrl = json_encode($currentUrl);
                setcookie('web_journey', '', time() - 3600, '/');
                unset($_COOKIE['web_journey']);
            }          
            $lead = new Lead;
            $lead->source_url = @$currentUrl ? @$currentUrl : null;
            $lead->name = $comment->name;
            $lead->email = $comment->email;
            $lead->phone = $request->input('phone');
            $lead->country_id = $request->input('country');            
            $lead->url = $comment->url;
            $lead = $lead->save();

            return ['status' => 1, 'msg' => 'Comment Submit Successfully'];
        }
        return ['status' => 0, 'msg' => 'Data Not save in Comment Data'];
    }


    // public function parent_category(Request $request){

    //     // qury to get category data parent_cat = 0 and url = "consultancy";
    //     // template_name
    //     $template_name = 'blog1';

    //     return $this->$template_name($request);

    // }

    // function child_category() {

    // }

    // function consultancyPage(){
    //     echo "consultancyPage";
    //     // die;
    // }

    // public function blog1($request)
    // {
    //     // $blog = Page::all();
    //     // $category ? $category : '';
    //     $popular = Page::orderBy('id', 'desc')->take(4)->with('category')->get();
    //     $news = Page::where('category_id', 35)->take(4)->get();
    //     $university = Page::where('category_id', 42)->take(5)->get();
    //     $visa = Page::where('category_id', 41)->take(4)->get();
    //     $finance = Page::where('category_id', 38)->take(1)->get();
    //     // die("1");

    //     // $blogCategory = Page::where('url', $category)->all();
    //     // return $blog;
    //     return view('website.pages.blog', compact(['news','university','visa','finance','popular']));
    // }


    public function consultancy()
    {
        $addresses = Address::with('page')->get();
        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();
        return view('website.' . $this->device . '.pages.Consultancy', compact('addresses', 'blogs'));
    }

    // public function consultancyCountry($country)
    // {
    //         $country = Page::where('url',$country)->where('category_id', 45)->published()->first();
    //         if(!empty($country)){
    //             return view('website.pages.consultancyCountry', compact(['country']));
    //         }
    //         abort(404);
    // }

    public function consultancyCountry()
    {
        $addresses = Address::with('page')->get();
        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();
        return view('website.' . $this->device . '.pages.consultancyCountry', compact('addresses', 'blogs'));
    }
    // public function booksession()
    // {
    //         return view('website.pages.booksession');
    // }

    public function consultancyCity($country, $city)
    {
        $name = $city;
        $country = Category::where('url', $country)->where('parent_id', 47)->first();        
        if ($country) {
            $city = Page::where('url', $city)->where('category_id', $country->id)->published()->with('faq', 'address')->first();
            if (empty($city) || empty($country)) abort(404);
            $address = Address::where('page_id', $city->id)->get();
            if (!empty(@$address[0]->address) && isset($address[0]->lat) && isset($address[0]->long)) {
                $addresses2 = '';
            } else {
                $addresses2 = Address::with('page')->get();
            }
            $nearbyCity = Page::where('category_id', $country->id)->where('url', '!=', $name)->published()->get();

            $tags = '';
            if (!empty($address)) {
                $tags = explode(",", @$address[0]->local_areas);
            }
            $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
            $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images')->where('category_id', 111)->where('page_id', $city->id)->orderBy('display_date', 'DESC')->get();
            $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();
            return view('website.' . $this->device . '.pages.city', compact(['city', 'address', 'reviews', 'tags', 'nearbyCity', 'blogs', 'addresses2']));
        }
    }

    // public function UserMail()
    // {
    //     $users = User::all();
    //     foreach($users as $user){
    //         $data = array('data'=>$user);
    //             Mail::send('mails.userMail', $data, function($message) use($user)  {
    //                $message->to($user->email, $user->name)->subject
    //                   ('Unlock Your IELTS Success @Gradding.com!');
    //                $message->from('contact@gradding.com','Gradding Team');
    //             });
    //     }
    //     return view('website.pages.index');
    // }

    public function scholership()
    {
        return view('website.' . $this->device . '.pages.scholership');
    }

    public function programData(Request $request)
    {
        $courses = CourseCategory::where('name', 'LIKE', '%' . $request->searchData . '%')->get()->toArray();
        return response()->json([
            'status' => true,
            'course' => $courses
        ]);
    }

    // public function filtersData(Request $request)
    // {
    //     $filter = Course::where('university_id',$request->id)->with('university','level','category')->get();
    //     dd($filter);
    //     $level = CourseLevel::all();
    //     $category = CourseCategory::all();
    // }
    public function searchFinder(Request $request, $slug, $country = null)
    {
       

        if ($slug == 'university' || $slug == 'courses' || $slug == 'scholarship') {
        } else {
            abort(404);
        }

        if ($country == null) {
            $country = '';
        } else {
            switch ($country) {

                case 'study-in-usa':
                    $country = 233;
                    break;

                case 'study-in-uk':
                    $country = 79;
                    break;

                case 'study-in-canada':
                    $country = 39;
                    break;

                case 'study-in-australia':
                    $country = 15;
                    break;

                case 'study-in-hungary':
                    $country = 100;
                    break;

                case 'study-in-malta':
                    $country = 146;
                    break;

                case 'study-in-germany':
                    $country = 59;
                    break;

                case 'study-in-italy':
                    $country = 110;
                    break;

                case 'study-in-france':
                    $country = 75;
                    break;

                default:
                    // Handle default case (if any)
                    break;

            }
        }

        $count = [];
        // $count['ukUni'] = Universities::where('country_id', 79)->where('status', 1)->count();
        // $count['usUni'] = Universities::where('country_id', 233)->where('status', 1)->count();
        // $count['auUni'] = Universities::where('country_id', 15)->where('status', 1)->count();
        // $count['caUni'] = Universities::where('country_id', 39)->where('status', 1)->count();
        // $count['huUni'] = Universities::where('country_id', 100)->where('status', 1)->count();
        // $count['mtUni'] = Universities::where('country_id', 146)->where('status', 1)->count();

        // $count['ukCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 79);
        // })->count();
        // $count['usCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 233);
        // })->count();
        // $count['auCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 15);
        // })->count();
        // $count['caCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 39);
        // })->count();
        // $count['huCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 100);
        // })->count();
        // $count['mtCourse'] = Course::whereIn('university_id', function ($query) {
        //     $query->select('id')
        //         ->from('universities')
        //         ->where('country_id', 146);
        // })->count();

        // $universities = Universities::where('status', 1)->where('recommended', 1)->where('robots', 'index, follow')->with('courses')->take(4)->get();
        // $courses = Course::where('status', 1)->where('name', 'like', '%mba%')->whereNotNull('Amount')->with('university.countries')->take(3)->get();

        $category_id = Category::Select('id')->where('parent_id', 15)->get()->toArray();
        $blogs = Page::whereIn('category_id', $category_id)->with('category')->published()->latest()->take(7)->get();

        return view('website.' . $this->device . '.pages.search', compact(['slug', 'count', 'blogs', 'country']));

        // if ($slug == "University") {
        //     $query = Universities::with('countries')
        //     $query->where('name', 'like', '%' . $request['search'] . '%');

        //     // Get the total count of universities without pagination.
        //     $result['university_count'] = $query->count();

        //     if ($result['university_count'] > 10) {
        //         // Apply pagination to the query builder only when there are more than 10 universities.
        //         $universities = $query->paginate(10); // Paginate the results with 10 items per page.
        //         $result['university'] = $universities;
        //         $result['showPagination'] = true;
        //     } else {
        //         // When there are 10 or fewer universities, don't paginate.
        //         $result['university'] = $query->get();
        //         $result['showPagination'] = false;
        //     }

        //     $result['slug'] = $slug;
        //     return view('website.' . $this->device . '.pages.search', compact(['result']));
        // }

        //  else if ($slug == "Scholarship") 
        //  {
        //     $result['scholarship'] = [];
        //     $result['scholarship_count'] = 0;
        //     $result['slug']=  $slug;
        //     return view('website.' . $this->device . '.pages.search',compact(['result']));
        // } 

        // else if ($slug == "Courses")
        //  {
        //     // dd($request['search']);
        //       $result['courses'] = Course::with('university')
        //       ->where('name', 'like', '%' . $request['search'] . '%')
        //       ->get();
        //       $result['courses_count'] = $result['courses']->count(); // Calculate the count
        //       $result['slug']=  $slug;
        //     return view('website.' . $this->device . '.pages.search',compact(['result']));            
        // }

        //     return view('website.' . $this->device . '.pages.search-finder');
        // }    

        // return view('website.'.$this->device.'.pages.search-finder');
    }

    // public function coursesGetByCountry(Request $request)
    // {
    //     $university_ids = Universities::select('id')->where('country_id',$request->country_id)->get()->toArray();
    //     $courses = Course::whereIn('university_id', $university_ids)->with('university')->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);
    //         }
    //     }
    //     $university = Universities::select('name','id')->where('country_id',$request->country_id)->get()->toArray();
    //     $levels = CourseLevel::all();
    //     $streams = Stream::all();
    //     $programs = CourseCategory::all();
    //     $specializations = Specialization::all();
    //     $country_url = Country::Select('url')->where('id',$request->country_id)->first()->toArray();
    //     return response()->json([
    //         "courses" => $courses,
    //         "country_url" => $country_url,
    //         'specializations' => $specializations,
    //         'programs' => $programs,
    //         'streams' => $streams,
    //         'levels' => $levels,
    //         'university' => $university,
    //     ]);
    // }


    public function coursesGetByCountry(Request $request)
    {
        // dd($request->all());
        $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->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');
                }
            }
        }

        if ($request->MinValue != null && $request->MaxValue != null) {
            $sliderMinValue = $request->MinValue;
            $sliderMaxValue = $request->MaxValue;
            if ($request->currency != 'INR' && $sliderMaxValue <= 100000) {
                $query->whereBetween('Amount', [$sliderMinValue, $sliderMaxValue]);
            } else {
                $query->whereBetween('InrAmount', [$sliderMinValue, $sliderMaxValue]);
            }
        }

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

        $count = $query->count();

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

        $amountColumn = $request->currency != 'INR' ? 'Amount' : 'InrAmount';
        $courses = $query->with('university.countries')
            ->orderByRaw($amountColumn . ' IS NOT NULL DESC')
            ->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');
                }
            }
        }
        if ($request->MinValue != null && $request->MaxValue != null) {
            $sliderMinValue = $request->MinValue;
            $sliderMaxValue = $request->MaxValue;
            if ($request->currency != 'INR' && $sliderMaxValue <= 100000) {
                $query->whereBetween('Amount', [$sliderMinValue, $sliderMaxValue]);
            } else {
                $query->whereBetween('InrAmount', [$sliderMinValue, $sliderMaxValue]);
            }
        }


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

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

        // For Course Level
        $courseLevel = $request->courseLevel;
        $courseLevelArray = [];
        if (isset($courseLevel) && $courseLevel) {
            $courseLevelArray = explode(',', @$courseLevel);
        }

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

        // For Exams
        $exams = $request->exam;
        $examArray = [];
        if (isset($exams) && $exams) {
            $examArray = explode(',', @$exams);
        }

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

        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');
                }
            }
        }
        // if (!empty($duration)) {
        //     $durationArray = explode(',', $duration); 

        //     $query->where(function ($query) use ($durationArray) {
        //         foreach ($durationArray as $duration) {
        //             $query->orWhereBetween('durationValue', [$duration - 12, $duration]);
        //         }
        //     });
        // }
        // dd($query->toSql());

        if ($request->MinValue != null && $request->MaxValue != null) {
            $sliderMinValue = $request->MinValue;
            $sliderMaxValue = $request->MaxValue;
            if ($request->currency != 'INR' && $sliderMaxValue <= 100000) {
                $query->whereBetween('Amount', [$sliderMinValue, $sliderMaxValue]);
            } else {
                $query->whereBetween('InrAmount', [$sliderMinValue, $sliderMaxValue]);
            }
        }

        $courseCounts = $query->count();
        $amountColumn = $request->currency != 'INR' ? 'Amount' : 'InrAmount';
        $courses = $query
            ->with('university.countries')
            ->orderByRaw($amountColumn . ' IS NOT NULL DESC')
            ->take($limit)
            ->get();

        // dd($query->toSql(), $query->getBindings());

        $levels = Course::select('course_level')->groupBy('course_level')->get();
        $streams = StudyArea::select('name', 'id')->get();
        $exams = Exam::select('name', '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
        ]);
    }


    public function subscribeWebinar(Request $request, $webinar_id, $user_id)
    {
        $webinar_id = base64_decode($webinar_id);
        $user_id = base64_decode($user_id);
        $candidate = Candidate::find($user_id);
        if ($candidate) {
            $webuser = $candidate->id;
            $currentWebinarIds = $candidate->webinar_ids;
            $currentWebinarIdsArray = explode(',', $currentWebinarIds);
            if (!in_array($webinar_id, $currentWebinarIdsArray)) {
                $newWebinarIds = $currentWebinarIds ? $currentWebinarIds . ',' . $webinar_id : $webinar_id;
                Candidate::where('id', $user_id)->update(['webinar_ids' => $newWebinarIds]);
            }

            $findwebinar = InterestedCandidatesWebinar::where('candidate_id', $webuser)
                ->where('webinar_id', $webinar_id)
                ->first();

            if ($findwebinar) {
                // Update the existing record if found
                $findwebinar->update([
                    'candidate_id' => $webuser,
                    'webinar_id' => $webinar_id,
                ]);
            } else {
                // Create a new record if not found
                $Interestedwebinar = new InterestedCandidatesWebinar;
                $Interestedwebinar->candidate_id =  $webuser;
                $Interestedwebinar->webinar_id = $webinar_id;
                $Interestedwebinar->save();
            }
        }
        return view('website.' . $this->device . '.pages.registration-page');
    }


    // public function moveqsranking(Request $request)
    // {
    //     $rankings = Universities::select('ranking_data','id','qs_ranking')->get();
    //     foreach($rankings as $key => $ranking){
    //         $newQsRankings = json_decode($ranking->ranking_data);
    //             // if($key == 5){
    //             //     dd($newQsRankings);
    //             // }
    //         if(!empty($newQsRankings)){
    //             $newQsRankings = $newQsRankings->universityRanks;
    //             // dd($newQsRankings);
    //             if(!empty($newQsRankings)){
    //                 foreach ($newQsRankings as $newQsRanking) {
    //                     if ($newQsRanking->rankingName == 'World University Ranking') {
    //                         $ranking->qs_ranking = $newQsRanking->rank;
    //                         $ranking->save();
    //                         break;
    //                     }
    //                 }
    //             }
    //         }
    //     }
    // }


    public function media()
    {
        $page_categories = Page::Select('quick_links', 'links_desc', 'mobile_link_desc', 'meta_title', 'meta_description', 'meta_keywords', 'robots')->where('category_id', 60)->first();
        return view('website.' . $this->device . '.pages.media', compact('page_categories'));
    }

    public function mediaContent(Request $request, $tabValue, $mediaLoad)
    {
        if (!empty($tabValue) && !empty($mediaLoad)) {
            if ($tabValue == 'print_coverage') {
                $mediaEntries = Media::where('category', 'print_coverage')->where('featured', '1')->latest('date')->get();
            }
            if ($tabValue == 'press-rel') {
                $mediaEntries = Media::where('category', 'press_release')->where('featured', '1')->latest('date')->take($mediaLoad)->get();
            }
            if ($tabValue == 'auth-art') {
                $mediaEntries = Media::where('category', 'authored_article')->where('featured', '1')->latest('date')->take($mediaLoad)->get();
            }
            if ($tabValue == 'social-med') {
                $mediaEntries = Media::where('category', 'social_media_coverage')->where('featured', '1')->latest('date')->take($mediaLoad)->get();
            }
            return response()->json([
                'mediaEntries' => $mediaEntries,
            ]);
        }
    }

    public function mediaReleases(Request $request, $tabValue, $limit)
    {
        if (!empty($tabValue) && !empty($limit)) {
            if ($tabValue == 'press-rel') {
                $latestRelease = Media::where('category', 'press_release')->where('featured', '1')->take($limit)->skip(3)->get();
            }
            if ($tabValue == 'auth-art') {
                $latestRelease = Media::where('category', 'authored_article')->where('featured', '1')->take($limit)->skip(3)->get();
            }
            if ($tabValue == 'social-med') {
                $latestRelease = Media::where('category', 'social_media_coverage')->where('featured', '1')->take($limit)->skip(3)->get();
            }
            return response()->json([
                'latestRelease' => $latestRelease,
            ]);
        }
    }

    public function startJourney(Request $request)
    {
        $streams = StudyArea::all();
        return view('website.desktop.pages.start-journey', compact(['streams']));
    }

    public function temporarySuccess()
    {
        return view('website.desktop.pages.payment.Success');
    }

    public function intakeByCountry(Request $request)
    {
        $intakes = Country::select('intakes', 'name')->where('id', $request->country)->first();
        $name = $intakes->name;
        $intakes = explode(',', @$intakes->intakes);
        return response()->json([
            'status' => 1,
            'intakes' => $intakes,
            'name' => $name,
        ]);
    }

    public function getCountry(Request $request)
    {
        $countries = Country::select('id', 'name')->get();
        return response()->json([
            'status' => 1,
            'countries' => $countries,
        ]);
    }

    public function stateByCountry(Request $request)
    {
        $states = State::select('id', 'name')->where('country_id', $request->country)->get();

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

    public function cityByState(Request $request)
    {
        $cities = City::select('id', 'name')->where('state_id', $request->state)->get();
        return response()->json([
            'status' => 1,
            'cities' => $cities,
        ]);
    }

    public function testPreparation(Request $request)
    {
        $pages = '';
        $reviews = '';
        $blogs = "";
        $path = $request->path();
        $category = Category::where('url',$path)->where('type','page')->first();
        $pages = Page::where('category_id', $category->id)->where('status','published')->first();        
        if (empty($pages)) abort(404);

        $reviewCategory = Category::where('url', $path)->where('type', 'review')->first();
        if (!empty($reviewCategory)) {
            $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images',)->where('category_id', $reviewCategory->id)->orderBy('display_date', 'DESC')->get();
        }
        $blogs = Page::where('category_id', 37)->latest()->published()->take(7)->get();
        return view('website.' . $this->device . '.testPreparation.testPreparation', compact(['pages', 'reviews', 'blogs']));
    }

    public function testPreparationExamCategories($url)
    {

        $plans = '';
        $pages = '';
        $reviews = '';
        $faqs = '';
        $blogs = "";

        $pages = Page::where('url',$url)->where('status','published')->first();
        if (empty($pages)) abort(404);

        // Blogs
        $tag_id = TagTranslation::where('name', strtoupper($url))->pluck('tag_id');

        if (!empty($tag_id)) {
            $blogs = Page::orWhereRaw("FIND_IN_SET(?, tag_id)", $tag_id[0])->latest()->published()->take(7)->get();
        }

        // Reviews
        $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images')->where('category_id', 111)->where('page_id', $pages->id)->orderBy('display_date', 'DESC')->get();

        // Faq
        $faqs = Faq::select('question', 'answer', 'category_id')->where('page_id', $pages->id)->where('category_id', 48)->get();

        if (!empty($pages->plan_id)) {
            $planIds = explode(',', $pages->plan_id);
            $plans = Plan::whereIn('id', $planIds)->get();
        }

        return view('website.' . $this->device . '.testPreparation.exam-categories', compact(['pages', 'reviews', 'blogs', 'faqs', 'plans']));
    }

    public function testPreparationExamPackages($url, $coaching)
    {
        $plans = '';
        $pages = '';
        $reviews = '';
        $faqs = '';
        $blogs = "";

        $category_id = Category::where('url',$url)->where('type','page')->pluck('id')->first();
        if(!empty($category_id)){
            $subCategoryId = Category::where('parent_id',$category_id)->pluck('id');
            if(!empty($subCategoryId)){
                $pages = Page::whereIn('category_id',$subCategoryId)->where('url', $coaching)->where('status','published')->first();
            }
        }
        if (empty($pages)) abort(404);

        // Blogs
        $tag_id = TagTranslation::where('name', strtoupper($url))->pluck('tag_id');
        if (!empty($tag_id)) {
            $blogs = Page::orWhereRaw("FIND_IN_SET(?, tag_id)", $tag_id[0])->latest()->published()->take(7)->get();
        }

        // Reviews
        $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images')->where('category_id', 111)->where('page_id', $pages->id)->orderBy('display_date', 'DESC')->get();

        // Faq        
        $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 48)->where('page_id', $pages->id)->get();         

        if (!empty($pages->plan_id)) {
            $planIds = explode(',', $pages->plan_id);
            $plans = Plan::whereIn('id', $planIds)->get();
        }

        if ($coaching == 'coaching') {
            return view('website.' . $this->device . '.testPreparation.exam-details', compact(['pages', 'reviews', 'blogs', 'faqs', 'plans']));
        }else {
            return view('website.' . $this->device . '.testPreparation.exam-categories', compact(['pages', 'reviews', 'blogs', 'faqs', 'plans']));
        }
    }

    public function testPreparationCourseDetails($url, $courseDetail)
    {

        $plan = '';
        $pages = '';
        $reviews = '';
        $faqs = '';
        $blogs = "";

        $category_id = Category::where('url',$url)->where('type','page')->pluck('id')->first();
        if(!empty($category_id)){
            $subCategoryId = Category::where('parent_id',$category_id)->where('type','page')->pluck('id');
            if(!empty($subCategoryId)){
                $pages = Page::whereIn('category_id',$subCategoryId)->where('url', $courseDetail)->where('status','published')->first();
            }
        }
        if (empty($pages)) abort(404);
        
        if($pages->category->url == 'city-page'){
            $name = $courseDetail;            
            $country = 'in';
            $country = Category::where('url', $country)->where('parent_id', 47)->first();
            if ($country) {
                $city = $pages;
                if (empty($city) || empty($country)) abort(404);
                $address = Address::where('page_id', $city->id)->get();
                if (!empty(@$address[0]->address) && isset($address[0]->lat) && isset($address[0]->long)) {
                    $addresses2 = '';
                } else {
                    $addresses2 = Address::with('page')->get();
                }
                $nearbyCity = Page::where('category_id', $country->id)->where('url', '!=', $name)->published()->get();

                $tags = '';
                if (!empty($address)) {
                    $tags = explode(",", @$address[0]->local_areas);
                }
                
                $tag_id = TagTranslation::where('name', strtoupper($url))->pluck('tag_id');
                if (!empty($tag_id)) {
                    $blogs = Page::orWhereRaw("FIND_IN_SET(?, tag_id)", $tag_id[0])->latest()->published()->take(7)->get();
                }
                $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images')->where('category_id', 111)->where('page_id', $city->id)->orderBy('display_date', 'DESC')->get();
                $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 48)->where('page_id', $city->id)->get();
                
                return view('website.' . $this->device . '.testPreparation.city', compact(['city', 'address', 'tags', 'nearbyCity', 'blogs', 'addresses2','reviews']));
            }
        }else{
            // Blogs
            $tag_id = TagTranslation::where('name', strtoupper($url))->pluck('tag_id');
            if (!empty($tag_id)) {
                $blogs = Page::orWhereRaw("FIND_IN_SET(?, tag_id)", $tag_id[0])->latest()->published()->take(7)->get();
            }

            // Reviews
            $reviews = Review::select('id', 'name', 'address', 'comments', 'star_rating', 'display_date', 'created_at', 'images')->where('category_id', 111)->where('page_id', $pages->id)->orderBy('display_date', 'DESC')->get();

            // Plan
            if (!empty($pages->plan_id)) {
                $plan = Plan::where('id', $pages->plan_id)->first();
            }

            // Faq
            $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 48)->where('page_id', $pages->id)->get();

            return view('website.' . $this->device . '.testPreparation.course-details', compact(['pages', 'reviews', 'blogs', 'faqs', 'plan']));
        }        
    }

    public function testPreparationChangeTab($exam, $courseDetail)
    {
        $faqs = '';
        if($courseDetail == 'about'){
            $pages = Page::where('url',$exam)->where('status','published')->first();
            
            // FAQ
            if (!empty($pages)) {
                $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 48)->where('page_id', $pages->id)->get();
            }
        }else{
            $category_id = Category::where('url',$exam)->where('type','page')->pluck('id')->first();
            $subCategoryId = Category::where('parent_id',$category_id)->pluck('id');
            $pages = Page::whereIn('category_id',$subCategoryId)->where('url', $courseDetail)->where('status','published')->first();
        
            // FAQ
            if (!empty($pages)) {
                $faqs = Faq::select('question', 'answer', 'category_id')->where('category_id', 48)->where('page_id', $pages->id)->get();             
            }
        }

        if (!empty($pages)) {
            $response = [
                'message' => "Page Fetched Succesfully",
                'status' => 1,
                'pages' => $pages,
                'faqs' => $faqs
            ];
            $response_code = 200;
        } else {
            $response = [
                'message' => "Page Not Found",
                'status' => 0
            ];
            $response_code = 200;
        }
        return response()->json($response, $response_code);
    }

    public function testPreparationAddNotes(Request $request)
    {
        $validate = Validator::make($request->all(), [
            'examType' => 'required',
            'pursuingType' => 'required',
            'durationType' => 'required',
        ]);
        if ($validate->fails()) {
            $response = [
                'message' => $validate->errors(),
                'status' => 0
            ];
            $response_code = 403;
        } else {
            $candidate = auth()->user()->candidate;
            $newNotes = [
                [
                    "auth_id" => 1,
                    "auth_name" => "System",
                    "notes" =>
                    "lead note : " . $request->examType . ',<br> ' . $request->pursuingType . ',<br> ' . $request->durationType
                ],
            ];

            $notes = json_decode($candidate->notes, true);
            if (!is_array($notes)) {
                $notes = [];
            }

            $mergedNotes = array_merge($notes, $newNotes);

            $candidate->update(['notes' => json_encode($mergedNotes)]);

            $response = [
                'message' => 'Lead updated succesfully',
                'status' => 1
            ];
            $response_code = 200;
        }
        return response()->json($response, $response_code);
    }

    public function visitingCard(Request $request)
    {
        return view('website.mobile.pages.visiting-card');
    }

    public function genericCard(Request $request)
    {
        return view('website.mobile.pages.generic-card');
    }

    public function qrCard(Request $request)
    {
        return view('website.mobile.pages.visiting-qr');
    }

    public function listening_test()
    {
        return view('website.desktop.mock-test.ielts-listening-test-1');
    }

    public function reading_test()
    {
        return view('website.desktop.mock-test.ielts-reading');
    }

    public function writing_test()
    {
        return view('website.desktop.mock-test.ielts-writing');
    }


    public function listening_test_save(Request $request)
    {
        // view()
        $data = $request->all();
        $html = '<table>';
        foreach ($data['name'] as $key => $val) {
            $html .= '<tbody><td> Question is ' . $key . ' and Answer is: ' . $val . ' </td></tbody>';
        }
        $html .= '</table>';

        Mail::send([], $data, function ($message) use ($html) {
            $message->to('dishu.bhatt@gradding.com')
                ->subject('Test Subject')
                ->from('contact@gradding.com', 'Gradding Team')
                ->setBody($html, 'text/html');
        });
        return 'Your answer is submited successfully';
    }

    public function visa()
    {
        return view('website.' . $this->device . '.visa.visa');
    }

    public function visaCountry()
    {
        return view('website.' . $this->device . '.visa.visa-country-page');
    }

    public function testPreparationRegister()
    {
        $streams = StudyArea::all();
        return view('website.desktop.testPreparation.register', compact(['streams']));
    }

    public function readingExam()
    {
        return view('website.desktop.pages.reading-exam');
    }
    public function writingExam()
    {
        return view('website.desktop.pages.writing-exam');
    }
    public function listeningExam()
    {
        return view('website.desktop.pages.listening-exam');
    }
    public function speakingExam()
    {
        return view('website.desktop.pages.speaking-exam');
    }


    public function otpSent(Request $request)
    {

        $jsonData = $request->jsonData;
        $jsonData = json_decode($jsonData);

        $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 : ''
        ];


        if (!empty($jsonData) && is_object($jsonData)) {
            $planner = [
                'examRequire' => isset($jsonData->examRequire[0]) ? $jsonData->examRequire[0] : null,
                'timeDuration' => isset($jsonData->timeDuration[0]) ? $jsonData->timeDuration[0] : null,
                'purpose' => isset($jsonData->purpose[0]) ? $jsonData->purpose[0] : null,
                'highedu' => isset($jsonData->highedu[0]) ? $jsonData->highedu[0] : null,
                'exam' => isset($jsonData->exam[0]) ? $jsonData->exam[0] : null,
                'grade_type' => isset($jsonData->grade_type) ? $jsonData->grade_type : null,
                'grade' => isset($jsonData->grade) ? $jsonData->grade : null,
                'test_score' => isset($jsonData->test_score) ? $jsonData->test_score : null,
                'reason' => isset($jsonData->reason) ? $jsonData->reason : null,
                'exam_date' => isset($jsonData->exam_date) ? $jsonData->exam_date : null,
            ];
            if($planner['exam_date'] != null){
                $planner['exam_date'] = date("Y-m-d",strtotime($planner['exam_date']));
            } 
            session()->put('planner', $planner);
        }


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

        $user = session()->get('userdata');
        if (empty($user)) {
            $user = session()->get('userLogged');
        }
        $planner = session()->get('planner');

        // Create the notes array
        $notes = [
            [
                "auth_id" => 1,
                "auth_name" => "System",
                "notes" =>
                "Slot Time : " . $request->book_slot
            ],
        ];

        $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'],
                'name' => $user['name'],
                'last_name' => $user['last_name'],
                'country' => $user['country'],
                'source' => $user['source'],
                'auth_type' => 'phone',
                'stages' => 'Test Preparation',
                'service_id' => 12,
            ]);

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

            if (!empty($candidate)) {
                // $candidate->highest_education = @$planner['highedu'];
                $candidate->lock_profile = Carbon::now()->addDays(3);
                $candidate->notes = json_encode($notes);
                $candidate->save();
            }


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

            CandidateTestPreparation::create([
                'candidate_id' => @$candidate->id,
                'test_name' => @$planner['exam'],
                'test_score' => @$planner['test_score'],
                'test_taken' => @$planner['examRequire'],
                'test_date' => @$planner['timeDuration'],
                'test_purpose' => @$planner['purpose'],
                'exam_date' => @$planner['exam_date'],
                'purpose_reason' => @$planner['reason'],
            ]);

            sendOtp($request->phone);

            $currentUrl = @$_COOKIE['web_journey'];
            if($currentUrl){
                $currentUrl = json_encode($currentUrl);
                setcookie('web_journey', '', time() - 3600, '/');
                unset($_COOKIE['web_journey']);
            }
            $lead = new Lead();
            $lead->name = $request->name . ' ' . $request->last_name;
            $lead->source_url = @$currentUrl ? @$currentUrl : null;
            $lead->phone = $request->phone;
            $lead->description = json_encode($notes);
            $lead->country_id = $request->country;
            $lead->source = $request->source;
            $lead->url = $request->url;
            $lead->user_id = $request->user_id;
            $lead->save();

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

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

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


    public function ieltsDemoClass(Request $request)
    {
        return view('website.desktop.testPreparation.ielts-demo-class');
    }

    public function certificateVerification()
    {
        return view('website.desktop.pages.certificate-verification');
    }


    public function indianStates()
    {
        $states = State::select('id', 'name')->where('country_id', 103)->get();

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

    public function cityFinder(Request $request)
    {
        $cities = Page::select('title')->where('category_id', 46)->where('status', 'published')->pluck('title')->toArray();

        $selectedCity = $request->city_name;

        $user = User::where('phone', $request->phone)->where('country', $request->country)->first();
        if (!$user) {

            $user = new User();
            $user->name = $request->name;
            $user->country = $request->country;
            $user->country_code = $request->country_code;
            $user->phone = $request->phone;
            $user->source = $request->source;
            $user->service_id = 12;
            $user->stages = 'Test Preparation';
            $user->save();
        }

        $candidate = Candidate::where('user_id', $user->id)->first();
        if ($candidate) {
            $candidate->country_id = 103;
            $candidate->city_id = $request->city;
            $candidate->state_id = $request->state;
            $candidate->save();
        }

        $currentUrl = @$_COOKIE['web_journey'];

        if($currentUrl){
            $currentUrl = json_encode($currentUrl);
            setcookie('web_journey', '', time() - 3600, '/');
            unset($_COOKIE['web_journey']);
        }

        $lead = new Lead();
        $lead->name = $request->name;
        $lead->source_url = @$currentUrl ? @$currentUrl : null;
        $lead->phone = $request->phone;
        $lead->country_id = $request->country;
        $lead->user_id = $user->id;
        $lead->source = $request->source;
        $lead->url = $request->url;
        $lead->city = $request->city;
        $lead->save();


        // Function to find the nearest city
        function findNearestCity($selectedCity, $cities)
        {
            // Check if the selected city exists in the array
            if (in_array($selectedCity, $cities)) {
                return $selectedCity;
            }

            // Find the nearest city using Levenshtein distance
            $minDistance = PHP_INT_MAX;
            $nearestCity = '';

            foreach ($cities as $city) {
                $distance = levenshtein($selectedCity, $city);

                if ($distance < $minDistance) {
                    $nearestCity = $city;
                    $minDistance = $distance;
                }
            }

            return $nearestCity;
        }

        $nearestCity = findNearestCity($selectedCity, $cities);

        if ($user && $nearestCity && $lead) {
            return response()->json([
                'status' => 1,
                'selectedCity' => $selectedCity,
                'nearestCity' => $nearestCity
            ]);
        }

        return response()->json([
            'status' => 0,
            'selectedCity' => @$selectedCity,
            'nearestCity' => @$nearestCity,
            'msg' => 'Something Went Wrong'
        ]);
    }
}