<?php

namespace App\Http\Controllers\zendesk;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;


use Carbon\Carbon;
use App\Models\User;
use App\Models\Skill;
use App\Models\JobRole;
use App\Models\Candidate;
use App\Models\Education;
use App\Models\Experience;
use App\Models\Profession;
use App\Models\ContactInfo;
use Illuminate\Support\Str;

use App\Models\SkillTranslation;
use App\Models\CandidateLanguage;
use Illuminate\Support\Facades\DB;
use Modules\Location\Entities\City;

use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Modules\Location\Entities\State;
use Modules\Location\Entities\Country;
use App\Http\Requests\CandidateRequest;
use Modules\Language\Entities\Language;
use App\Models\Setting;
use App\Notifications\CandidateCreateApprovalPendingNotification;
use Illuminate\Support\Facades\Notification;
use App\Notifications\CandidateCreateNotification;
use App\Notifications\UpdateCompanyPassNotification;
use App\Models\Documents;
use App\Models\DocumentSubcategory;
use Illuminate\Support\Facades\Storage;
use App\Models\DocumentCategory;

use App\Models\Countries;
use App\Models\CandidateEducation;
use App\Models\CandidateDestination;
use App\Models\Followup;
use App\Models\CandidateExam;
use App\Models\Admin;
use App\Models\Source;
use App\Models\Lead;

class zendeskController extends Controller
{
    public function index()
    {
        dd('index');
    }
    public function candidateIndex(Request $request)
    {

        $admin_list = Admin::select('id','name')->where('id', '!=', 1)->get()->toArray();
        // dd($admin_list);
        $query = Candidate::withCount('appliedJobs')->with('user', 'jobRole', 'followup');

        // verified status
        if ($request->has('ev_status') && $request->ev_status != null) {
            $ev_status = null;
            if ($request->ev_status == 'true') {
                $query->whereHas('user', function ($q) use ($ev_status) {
                    $q->whereNotNull('email_verified_at');
                });
            } else {
                $query->whereHas('user', function ($q) use ($ev_status) {
                    $q->whereNull('email_verified_at');
                });
            }
        }

        $query->whereHas('user', function ($q) use ($request) {
            if ($request->has('name')) {
                $fullName = $request->input('name');
                $q->where(function ($innerQuery) use ($fullName) {
                    $innerQuery->whereRaw("CONCAT_WS(' ', name, middle_name, last_name) LIKE ?", ["%$fullName%"])
                               ->orWhere('email', 'LIKE', "%$fullName%");
                });
            }
    
            if (!empty($request->input('email'))) {
                $q->where('email', 'LIKE', '%' . $request->email . '%');
            }
    
            if (!empty($request->input('source'))) {
                $q->where('source', $request->source);
            }

            if (!empty($request->input('stages'))) {
                $q->where('stages', $request->stages);
            }
    
            if (!empty($request->input('phone'))) {
                $q->where('phone', 'LIKE', '%' . $request->phone . '%');
            }

            if (!empty($request->input('daterange'))) {
                $dates = explode(' - ', $request->input('daterange'));
                $startDate = Carbon::createFromFormat('m/d/Y', $dates[0])->startOfDay();
                $endDate = Carbon::createFromFormat('m/d/Y', $dates[1])->endOfDay();
                $q->whereBetween('created_at', [$startDate, $endDate]);
            }

            if (!empty($request->input('daterange_activity'))) {
                $dates_activity = explode(' - ', $request->input('daterange_activity'));
                $startDate_activity = Carbon::createFromFormat('m/d/Y', $dates_activity[0])->startOfDay();
                $endDate_activity = Carbon::createFromFormat('m/d/Y', $dates_activity[1])->endOfDay();
                $q->whereBetween('last_activity_date', [$startDate_activity, $endDate_activity]);
            }

            if (!empty($request->input('country'))) {
                $q->where('country', 'LIKE', '%' . $request->input('country') . '%');
            }
          
        
        });

            if (!empty($request->input('followUp'))) {
                $followupValue = $request->input('followUp');
                if ($followupValue == "no_followUp") {
                    $query->whereDoesntHave('followup');
                } elseif ($followupValue == "all") {
                    $query->whereHas('followup', function ($q) {
                        $q->whereNotNull('id');
                    });
                }
                
                // $query->whereHas('followup', function ($q) use ($followupValue) {
                //     // if ($followupValue == "all") {
                //     //     $q->whereNotNull('id');
                //     // } elseif ($followupValue == "no_followUp") {
                //     //     $q->whereNull('id');
                //     // }
                // });
            }
        

        if ($request->keyword && $request->keyword != null) {

            $query->whereHas('user', function ($q) use ($request) {

                $q->where('name', 'LIKE', "%$request->keyword%")
                    ->orWhere('email', 'LIKE', "%$request->keyword%")
                    ->orWhere('phone', 'LIKE', "%$request->keyword%");
            });
        }

        if ($request->sort_by == 'latest') {
            $query->latest();
        } else if ($request->sort_by == 'latestUpdate') {
            $query->latest("updated_at");
        } else if ($request->sort_by == 'oldest' ) {
            $query->oldest();
        } else if ($request->sort_by == 'oldestUpdate') {
            $query->oldest("updated_at");
        // } else if ($request->sort_by == 'last_activity_date') {  
        //     $query->whereHas('user', function ($q) use ($request) {
        //         $q->orderByDesc('last_activity_date');
        //         // $q->orderBy('last_activity_date', 'DESC');
        //         // $q->orderBy('last_activity_date', 'DESC');
        //         // $q->orderBy('last_activity_date', 'DESC');
        //         // $q->latest("last_activity_date");
        //     });    
        // } else {
        } else if ($request->sort_by == 'last_activity_date') {
            $query->orderByDesc(function ($q) {
                $q->select('last_activity_date')
                    ->from('users')
                    ->whereColumn('candidates.user_id', 'users.id')
                    ->whereNull('users.deleted_at')
                    ->orderBy('last_activity_date')
                    ->limit(1);
            });
        } else {
            $query->latest();
        }

        $candidates = $query->paginate(20)->withQueryString();
        $sourcesData = Source::distinct('name')->with("source")->where("parent_id",null)->get();

        return view('zendesk.candidate.index', compact('candidates','sourcesData', 'admin_list'));
    }


////////////////////////candidat create/////////////////////////////
        public function candidateCreates()
        {
            $data['countries'] = Country::all();
            $data['job_roles'] = JobRole::all();
            $data['professions'] = Profession::all();
            $data['experiences'] = Experience::all();
            $data['educations'] = Education::all();
            $data['skills'] = Skill::all();
            $data['candidate_languages'] = CandidateLanguage::all(['id', 'name']);
            $data['sourcesData'] = Source::distinct('name')->with("source")->where("parent_id",null)->get();
            $data['countries'] = Countries::all('id', 'name');
            // $data['states'] = State::all('id','name');
            // $data['citys'] = City::all('id','name');

            $data['admin_list'] = Admin::where('id', '!=', 1)
            ->whereHas('roles', function ($query) {
                $query->where('name', 'Lead Manager');
            })
            ->get()->toArray();
            

            return view('zendesk.candidate.create', $data);
        }


        public function userCreate($request)
        {
            $request->validate([
                'username' => 'unique:users,username',
                'email' => 'unique:users,email'
            ]);
    
            $data['country'] = null;
            $data['country_code'] = null;
            if (!empty($request->input('country_id'))) {
                $countryData = explode('@#$?', $request->input('country_id'));
                $country = $countryData[0];
                $data['country'] = $country;
                if (!empty($country)) $data['country'] = $country;
    
                $code = $countryData[1];
                if (!empty($code)) $data['country_code'] = $code;
            }
    
            $assign_to = null;
            if(!empty($request->assign_to)){
                $assign_to = $request->assign_to;
            }
    
            $password = $request->password ?? Str::random(8);
    
            $data = User::create([
                'role' => 'candidate',
                'name' => $request->name,
                'username' => Str::slug('K' . $request->name . '122'),
                'email' => $request->email,
                'email_verified_at' => now(),
                'password' => Hash::make($password),
                'remember_token' => Str::random(10),
                'secondary_email' => $request->secondary_email,
                'alternate_phone' => $request->alternate_phone,
                'middle_name' => $request->middle_name,
                'last_name' => $request->last_name,
                'phone' => $request->phone,
                'country' => $data['country'],
                'country_code' => $data['country_code'],
                'stages' => $request->stages,
                'assign_to' => $assign_to,
                'source'  => $request->source
    
            ]);
    
            return [$password, $data];
        }
        public function candidateCreate($request, $data)
        {
            if (!empty($request->birth_date)) {
                $dateTime = Carbon::parse($request->birth_date);
                $date = $request['birth_date'] = $dateTime->format('Y-m-d H:i:s');
            } else {
                $date = null;
            }
    
    
            $candidate = Candidate::where('user_id', $data[1]->id)->first();
    
            $candidate->update([
                "role_id" => $request->role_id,
                "profession_id" => $request->profession_id,
                "experience_id" => $request->experience,
                "education_id" => $request->education,
                "gender" => $request->gender,
                "website" => $request->website,
                "bio" => $request->bio,
                "marital_status" => $request->marital_status,
                "birth_date" => $date,
                "address" => $request->address,
                "passport_number" => $request->passport_number,
                "student_category" => $request->student_category,
                // "country_id" => $request->country_id, 
                "state_id" => $request->state_id,
                "city_id" => $request->city_id,
                "notes" => $request->notes,
    
                
            ]);
    
    
            if(!empty($request->qua)){
           
                foreach ($request->qua as $qua) {
                    $candidateEducation = CandidateEducation::create([
                        'candidate_id' => $candidate->id,
                        'qualification' => $qua['qualification'],
                        'institute_name' => $qua['institute_name'],
                        'education_board' => $qua['education_board'],
                        'passing_year' => $qua['passing_year'],
                        'grade_percentage' => $qua['grade_percentage'],
                    ]);
            
                       
                }
    
            }
    
    
            if(!empty($request->language_proficiency_req) == "1"){
            $candidate_exam = CandidateExam::where('candidate_id', $candidate->id)->first();
            $test_taken_dates = null;
            if(!empty($request->test_taken_date)){
               $test_taken_dates = Carbon::parse($request->test_taken_date);
            }
            if ($candidate_exam) {
                $candidate_exam->update([
                    'test_name' => $request->test_name,
                    'test_scores' => $request->test_scores,
                    'test_taken_date' => $test_taken_dates,
                    'language_proficiency_req' => $request->language_proficiency_req,
                ]);
            } else {
                $candidate_exam = CandidateExam::create([
                    'candidate_id' => $candidate->id,
                    'test_name' => $request->test_name,
                    'test_scores' => $request->test_scores,
                    'test_taken_date' => $test_taken_dates,
                    'language_proficiency_req' => $request->language_proficiency_req,
                ]);
            }
            }
    
    
            $candidate_destination = CandidateDestination::where('candidate_id', $candidate->id)->first();
            $preferred_country_ids =  NULL;
             if(!empty($request->preferred_country)){
                $preferred_country_ids = implode(",", $request->preferred_country);
            }
            if ($candidate_destination) {
                $candidate_destination->update([
                    "candidate_id" => $request->candidate_id,
                    "preferred_country" => $preferred_country_ids,
                    "preferred_city" => $request->preferred_city,
                    "preferred_state" => $request->preferred_city,
                    "preferred_program" => $request->preferred_program,
                    "preferred_course" => $request->preferred_course,
                    "intake" => $request->intake,
                ]);
            } else {
                $candidate_destination = CandidateDestination::create([
                    "candidate_id" => $candidate->id,
                    "preferred_country" => $preferred_country_ids,
                    "preferred_city" => $request->preferred_city,
                    "preferred_state" => $request->preferred_city,
                    "preferred_program" => $request->preferred_program,
                    "preferred_course" => $request->preferred_course,
                    "intake" => $request->intake,
                ]);
            }

            // cv
            if ($request->cv) {
                $pdfPath = "/file/candidates/";
                $pdf = pdfUpload($request->cv, $pdfPath);
    
                $candidate->update([
                    "cv" => $pdf,
                ]);
            }
            // dd($data);
            // image
            if ($request->image) {
                $path = 'images/candidates';
                $image = uploadImage($request->image, $path);
            } else {
                //$image = createAvatar($data[1]->name, 'uploads/images/candidate');
                $image = null;
            }
    
            $candidate->update(["photo" => $image]);
    
            // skills
            $skills = $request->skills;
            if ($skills) {
                $skillsArray = [];
    
                foreach ($skills as $skill) {
                    $skill_exists = Skill::where('id', $skill)->orWhere('name', $skill)->first();
    
                    if (!$skill_exists) {
                        $select_tag = Skill::create(['name' => $skill]);
                        array_push($skillsArray, $select_tag->id);
                    } else {
                        array_push($skillsArray, $skill);
                    }
                }
    
                $candidate->skills()->attach($skillsArray);
            }
    
            // languages
            $candidate->languages()->attach($request->languages);
    
            return $candidate;
        }
    
        public function candidateStore(CandidateRequest $request)
        {
        
    
            try {
    
            if ($request->image) {
                $request->validate([
                    'image' =>  'image|mimes:jpeg,png,jpg,gif'
                ]);
            }
            if ($request->cv) {
                $request->validate([
                    "cv" => "mimetypes:application/pdf",
                ]);
            }
    
            $data = $this->userCreate($request);
            $candidate = $this->candidateCreate($request, $data);
            $user = $data[1];
            $password = $data[0];
    
            // Location
            // updateMap($candidate);
    
            // if mail is configured
            if (checkMailConfig()) {
                $candidate_account_auto_activation_enabled = Setting::where("candidate_account_auto_activation", 1)->count();
    
                // if candidate activation enabled, send account created mail
                // else, send will be activated mail.
                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));
                }
            }
    
            flashSuccess(__('candidate_created_successfully'));
            return redirect()->route('zendesk.candidateIndex');
            } catch (\Throwable $th) {
                return redirect()->back()->with('error', config('app.debug') ? $th->getMessage() : 'Something went wrong');
            }
        }
    
////////////////////////End candidat create/////////////////////////////

////////////////////////candidat edit/////////////////////////////
    public function candidatEdit(Candidate $candidate)
    {
        
        $admin_list = Admin::where('id', '!=', 1)
        ->whereHas('roles', function ($query) {
            $query->where('name', 'Lead Manager');
        })
        ->get()->toArray();
        $user = User::with('contactInfo')->findOrFail($candidate->user_id);
        $contactInfo = ContactInfo::where('user_id', $user->id)->first();
        $job_roles = JobRole::all();
        $professions = Profession::all();
        $experiences = Experience::all();
        $educations = Education::all();
        $skills = Skill::all();
        $candidate_languages = CandidateLanguage::all(['id', 'name']);
        $candidate->load('skills', 'languages:id,name', 'educations', 'destination', 'candidate_exam');
        $sourcesData = Source::distinct('name')->with("source")->where("parent_id",null)->get();
        $candidate_exams = CandidateExam::all();
        // dd($candidate);
        $countries = Countries::all('id', 'name');
        // $states = State::all('id','name');
        // $citys = City::all('id','name');
        $followups = Followup::latest()->where('user_id', $candidate->user_id)->get();

        return view('zendesk.candidate.edit', compact(
            'contactInfo',
            'countries',
            'followups',
            'candidate',
            'user',
            'job_roles',
            'professions',
            'experiences',
            'educations',
            'skills',
            'candidate_languages',
            'admin_list',
            'sourcesData'
        ));
    }


    public function candidateUpdate(Request $request, Candidate $candidate)
    {
        // dd($request->all());

        $request->validate([
            'name' => 'required',
            'email' => 'required|email|unique:users,email,' . $candidate->user_id,
        ]);


        if (!empty($request->birth_date)) {
            $dateTime = Carbon::parse($request->birth_date);
            $date = $request['birth_date'] = $dateTime->format('Y-m-d H:i:s');
        } else {
            $date = null;
        }
        $data['country'] = null;
        $data['country_code'] = null;
        if (!empty($request->input('country_id'))) {
            $countryData = explode('@#$?', $request->input('country_id'));
            $country = $countryData[0];
            $data['country'] = $country;
            if (!empty($country)) $data['country'] = $country;

            $code = $countryData[1];
            if (!empty($code)) $data['country_code'] = $code;
        }
        $user = User::FindOrFail($candidate->user_id);
        //////////////////////assign_to////////////////////////////////
            $assign_to = null;
            if(!empty($request->assign_to)){
                $assign_to = $request->assign_to;
            }else{
                $assign_to = $user->assign_to;
            }
        ///////////////////////////assign_to///////////////////////////////    
        $user->update([
            'name' => $request->name,
            'email' => $request->email,
            'secondary_email' => $request->secondary_email,
            'alternate_phone' => $request->alternate_phone,
            'middle_name' => $request->middle_name,
            'last_name' => $request->last_name,
            'phone' => $request->phone,
            'country' => $data['country'],
            'country_code' => $data['country_code'],
            'stages' => $request->stages,
            'assign_to' => $assign_to,
            'source'  => $request->source
        ]);

        $candidate->update([
            "role_id" => $request->role_id,
            'profession_id' => $request->profession,
            'experience_id' => $request->experience,
            'education_id' => $request->education,
            'gender' => $request->gender,
            'website' => $request->website,
            'bio' => $request->bio,
            "marital_status" => $request->marital_status,
            "birth_date" => $date,
            "address" => $request->address,
            "passport_number" => $request->passport_number,
            "student_category" => $request->student_category,
            // "country_id" => $request->country_id, 
            "state_id" => $request->state_id,
            "city_id" => $request->city_id,
            "notes" => $request->notes,

        ]);

        // password change
        if ($request->password) {
            $request->validate([
                'password' => 'required',
            ]);
            $user->update([
                'password' => Hash::make($request->password),
            ]);
        }

        // image
        if ($request->image) {
            $request->validate([
                'image' =>  'image|mimes:jpeg,png,jpg,gif'
            ]);

            $old_photo = $candidate->photo;
            if (file_exists($old_photo)) {
                if ($old_photo != 'backend/image/default.png') {
                    unlink($old_photo);
                }
            }
            $path = 'images/candidates';
            $image = uploadImage($request->image, $path);

            $candidate->update([
                "photo" => $image,
            ]);
        }
        // cv
        if ($request->cv) {
            $request->validate([
                "cv" => "mimetypes:application/pdf",
            ]);
            $pdfPath = "/file/candidates/";
            $pdf = pdfUpload($request->cv, $pdfPath);

            $candidate->update([
                "cv" => $pdf,
            ]);
        }

        if(!empty($request->qua)){
                $quaIds = array_column($request->qua, 'id');
                CandidateEducation::where('candidate_id', $candidate->id)
                ->whereNotIn('id', $quaIds)
                ->delete();
            foreach ($request->qua as $qua) {
                $candidateEducation = CandidateEducation::firstOrNew(['id' => $qua['id']]);
        
                $candidateEducation->fill([
                    'candidate_id' => $candidate->id,
                    'qualification' => $qua['qualification'],
                    'institute_name' => $qua['institute_name'],
                    'education_board' => $qua['education_board'],
                    'passing_year' => $qua['passing_year'],
                    'grade_percentage' => $qua['grade_percentage'],
                ]);
        
                $candidateEducation->save();
            }

        }
      

        // if($request->language_proficiency_req === "1"){
            $candidate_exam = CandidateExam::where('candidate_id', $candidate->id)->first();
            $test_taken_dates = null;
                if(!empty($request->test_taken_date)){
                   $test_taken_dates = Carbon::parse($request->test_taken_date);
                }
            if ($candidate_exam) {
                $candidate_exam->update([
                    'test_name' => $request->test_name,
                    'test_scores' => $request->test_scores,
                    'test_taken_date' => $test_taken_dates,
                    'language_proficiency_req' => $request->language_proficiency_req,
                ]);
            } else {
                $candidate_exam = CandidateExam::create([
                    'candidate_id' => $candidate->id,
                    'test_name' => $request->test_name,
                    'test_scores' => $request->test_scores,
                    'test_taken_date' =>  $test_taken_dates,
                    'language_proficiency_req' => $request->language_proficiency_req,
                ]);
            }
        // }


        $candidate_destination = CandidateDestination::where('candidate_id', $candidate->id)->first();
        $preferred_country_ids =  NULL;
        if(!empty($request->preferred_country)){
           $preferred_country_ids = implode(",", $request->preferred_country);
        }
        if ($candidate_destination) {
            $candidate_destination->update([
                "preferred_country" => $preferred_country_ids,
                "preferred_city" => $request->preferred_city,
                "preferred_state" => $request->preferred_city,
                "preferred_program" => $request->preferred_program,
                "preferred_course" => $request->preferred_course,
                "intake" => $request->intake,
            ]);
        } else {
            $candidate_destination = CandidateDestination::create([
                "candidate_id" => $candidate->id,
                "preferred_country" => $preferred_country_ids,
                "preferred_city" => $request->preferred_city,
                "preferred_state" => $request->preferred_city,
                "preferred_program" => $request->preferred_program,
                "preferred_course" => $request->preferred_course,
                "intake" => $request->intake,
            ]);
        }

     
        // skills
        $skills = $request->skills;
        DB::table('candidate_skill')->where('candidate_id', $candidate->id)->delete();

        if ($skills) {
            $skillsArray = [];

            foreach ($skills as $skill) {
                $skill_exists = SkillTranslation::where('skill_id', $skill)->orWhere('name', $skill)->first();

                if (!$skill_exists) {
                    $select_tag = Skill::create(['name' => $skill]);

                    $languages = Language::all();
                    foreach ($languages as $language) {
                        $select_tag->translateOrNew($language->code)->name = $skill;
                    }
                    $select_tag->save();

                    array_push($skillsArray, $select_tag->id);
                } else {
                    array_push($skillsArray, $skill_exists->id);
                }
            }

            $candidate->skills()->attach($skillsArray);
        }

        // languages
        $candidate->languages()->sync($request->languages);

        if ($request->password) {
            // make Notification /
            $data[] = $user;
            $data[] = $request->password;
            $data[] = 'Candidate';

            checkMailConfig() ? Notification::route('mail', $user->email)->notify(new UpdateCompanyPassNotification($data)) : '';
        }
        flashSuccess(__('candidate_updated_successfully'));
        // return back();
        return redirect()->route('zendesk.candidateIndex');
    }


//////////////////////////////////////end candidat edit/////////////////////////////////////////////////////////

    public function candidateGetLeadBy(Request $request)
    {
        $data = Lead::FindOrFail($request->id);
    
        if($data){
            $data['country_name'] = NULL;
            $data['country_code'] = NULL;
            if (!empty($data->country_id)) {
                $country_array = explode("@#$?", $data->country_id);
                $data['country_name'] = reset($country_array);
                $data['country_code'] = end($country_array);
            }
            $data['on_description'] =!empty($data->description)? json_decode($data->description):[];   
            return response()->json(['status'=>1, 'data'=> $data]);
        }
        return response()->json(['status'=>0, 'data'=> null]);
       
    
    }
    public function customerFolloup(Request $request, $id)
    {

        $followup = new Followup();
        $followup->user_id = $id;
        $followup->comment = $request->comment;
        $followup->type = $request->type;
        $followup->follow_up_status = $request->follow_up_status;
        $followup->priority = $request->priority;
        $followup->followup_up = $request->followup_up;
        if (!empty($request->datetime)) {
            $followup->datetime = Carbon::parse($request->datetime);
        }
        $followup->admin_id = 0;
        $followup->save();

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


}