<?php

namespace App\Http\Controllers\Auth_Api;

use App\Http\Controllers\Controller;
use App\Jobs\sendemail;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Crypt;
use Illuminate\Support\Facades\Auth;
use Tymon\JWTAuth\Facades\JWTAuth;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Illuminate\Support\Facades\Hash;
use App\Models\Webinars;
use Carbon\Carbon;
use App\Models\Candidate;
use App\Models\CandidateDestination;
use App\Models\InterestedCandidatesWebinar;
use App\Models\Lead;
use App\Models\Service;
use App\Models\Setting;
use App\Models\WebsiteSetting;

class RegisterController extends Controller
{
    protected $device;

    public function __construct()
    {
        $this->device = session('device');
    }

    public function verify_otp($token,$from)
    {
        return view('auth_api.verify')->with('token',$token)->with('from',$from);
    }
    public function register($token=null)
    {
        if($token!=null){
            return view('auth_api.register')->with('token',$token);
        }
        if (auth('user')->check())
            return redirect('/dashboard');
        else
            return view('auth_api.login');
    }
    public function forgot_password($from,$token=null)
    {
        if($from !== 'phone' && $from !== 'email')
        abort(404);
    
        if($token!=null){
            return view('auth_api.forgot_password')->with('token',$token)->with('from', $from);
        }
        return view('auth_api.forgot_password')->with('from', $from);
    }
    public function confirm_password($token)
    {
        return view('auth_api.confirm_password')->with('token',$token);
    }
    public function welcome($token,$web_token)
    {
        return view('auth_api.welcome')
        ->with('token', $token)
        ->with('web_token', $web_token);
    }
    public function reg_login($encrypted)
    {
        try {
            $decrypted = Crypt::decryptString($encrypted);
        } catch (\Illuminate\Contracts\Encryption\DecryptException $e) {
            abort(404);
        }
    
        $user = User::find($decrypted);
    
        if (!$user) {
            abort(404);
        }
    
        Auth::login($user);
    
        $token = JWTAuth::fromUser($user);
    
        $token_data = ['name' => $user->name];
        $token_data = base64_encode(serialize($token_data));
        $web_token = Crypt::encryptString($token_data);
    
        return redirect()->route("dashboard.profile");
        // return view('auth_api.welcome')->with('token', $token)->with('web_token', $web_token);
    }


    public function eventRegister($eventId){

        // if (auth('user')->check())
        //     return redirect('/candidate/settings');
        // else
            return view('auth_api.eventRegister', compact(['eventId']));

    }

    public function influencerRegister(){

        // if (auth('user')->check())
        //     return redirect('/candidate/settings');
        // else
            return view('auth_api.influencerRegister');

    }

    public function userEventRegister1(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => ['required', 'string', 'max:255'],
            'email' => [
                'required',
                'email',
                Rule::unique('users', 'email')->where(function ($query) {
                    return $query->whereNull('deleted_at');
                }),
            ],
            'phone' => [
                'required',
                Rule::unique('users', 'phone')->where(function ($query) {
                    return $query->whereNull('deleted_at');
                }),
            ],
            'country' => ['required'],
            // Add more validation rules as needed
        ]);
    
        if ($validator->fails()) {
            return response()->json([
                'status' => 0,
                'msg' => 'Validation failed',
                'errors' => $validator->errors(),
            ],500);
        }
    
        $password = rand(1000,9999);
        $user = new User;
        $user->name = $request->name;
        $user->last_name = $request->last_name;
        $user->email = $request->email;
        $user->phone = $request->phone;
        $user->role = $request->role;
        $user->country = $request->country;
        $user->country_code = $request->country_code;
        $user->alt_iso2 = $request->iso2;
        $user->source = $request->source;
        $user->password = Hash::make($password);
        $user->service_id = $request->interest == 'Test Prepration' ? 12 : null;
        $user->stages = $request->interest == 'Test Prepration' ? 'Test Preparation' : null;
        $user->save();

        $candidate = Candidate::where('user_id', $user->id)->first();
        if(!empty($candidate)){
            $candidate->birth_date = $request->birth_date;
            $candidate->lock_profile = Carbon::now()->addDays(3);
            $candidate->save();
            
            if($request->interest !== '' && $request->interest !== 'Test Prepration'){
                CandidateDestination::create([
                    'candidate_id' => $candidate->id,
                    'preferred_program' => $request->interest,
                ]);
            }
    
            $webinar_id = $request->eventId;
            $webinar = Webinars::whereRaw("FIND_IN_SET('$webinar_id', tracking_code) > 0")->latest()->first();
            if($webinar){
                InterestedCandidatesWebinar::create([
                    'candidate_id' => $candidate->id,
                    'webinar_id' => $webinar->id,
                ]);
            }
        }


        $template = 'event_register';
        $sendTo = str_replace([' ','+'],'',$user->country_code.$user->phone);

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

        if($user && $candidate){
            return response()->json([
                'status' => 1,
                'msg' => 'User Register Successfully',
            ]);
        }
        return response()->json([
            'status' => 0,
            'msg' => 'Something Went Wrong',
        ]);
    }

    public function userEventRegister(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => ['required', 'string', 'max:255'],
            'email' => [
                'required',
                'email',
                Rule::unique('users', 'email')->where(function ($query) {
                    return $query->whereNull('deleted_at');
                }),
            ],
            'phone' => [
                'required',
                Rule::unique('users', 'phone')->where(function ($query) {
                    return $query->whereNull('deleted_at');
                }),
            ],
            'country' => ['required'],
            // Add more validation rules as needed
        ]);
    
        if ($validator->fails()) {
            return response()->json([
                'status' => 0,
                'msg' => 'Validation failed',
                'errors' => $validator->errors(),
            ],500);
        }
    
        $password = rand(1000,9999);
        $user = new User;
        $user->name = $request->name;
        $user->last_name = $request->last_name;
        $user->email = $request->email;
        $user->phone = $request->phone;
        $user->role = $request->role;
        $user->country = $request->country;
        $user->country_code = $request->country_code;
        $user->alt_iso2 = $request->iso2;
        $user->source = $request->source;
        $user->password = Hash::make($password);
        $user->service_id = $request->interest == 'Test Prepration' ? 12 : null;
        $user->stages = $request->interest == 'Test Prepration' ? 'Test Preparation' : 'Inquiry';
        $user->save();

        $candidate = Candidate::where('user_id', $user->id)->first();
        if(!empty($candidate)){
            $candidate->birth_date = $request->birth_date;
            $candidate->lock_profile = Carbon::now()->addDays(3);
            $candidate->save();
            
            if($request->interest !== '' && $request->interest !== 'Test Prepration'){
                CandidateDestination::create([
                    'candidate_id' => $candidate->id,
                    'preferred_program' => $request->interest,
                ]);
            }
    
            $webinar_id = $request->eventId;
            $webinar = Webinars::whereRaw("FIND_IN_SET('$webinar_id', tracking_code) > 0")->latest()->first();
            if($webinar){
                InterestedCandidatesWebinar::create([
                    'candidate_id' => $candidate->id,
                    'webinar_id' => $webinar->id,
                ]);
            }
        }

        $sendTo = str_replace([' ','+'],'',$user->country_code.$user->phone);
        if($request->influencer != ""){
            $template = 'welcome_message_adyboyy';
            $user_id = Crypt::encryptString($user->id);
            $url = json_encode(['url' => '/dashboard']);
            $url = base64_encode($url);
    
            sendWhatsapp([
                "template" => $template,
                "sendTo" => $sendTo,
                "name" => "$user->name",
                "password" => "$password",
                "user_id" => "$user->id",
                "link" => "wp/$user_id/$url",
            ]);

        }else{

            $template = 'event_register';
            $sendTo = str_replace([' ','+'],'',$user->country_code.$user->phone);

            sendWhatsapp([
                "template" => $template,
                "sendTo" => $sendTo,
                "name" => "$user->name",
                "password" => "$password",
                "user_id" => "$user->id",
            ]);
        }

        if($user && $candidate){
            return response()->json([
                'status' => 1,
                'msg' => 'User Register Successfully',
            ]);
        }
        return response()->json([
            'status' => 0,
            'msg' => 'Something Went Wrong',
        ]);
    }

    public function testPreparationEvent()
    {
        return view('auth_api.testPrepationEventRegister');
    }

    public function testPreparationRegister(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => ['required', 'string', 'max:255'],

            'phone' => ['required'],
            'country' => ['required'],
            'slot' => ['required'],
            // 'date' => ['required'],
            // Add more validation rules as needed
        ]);
    
        if ($validator->fails()) {
            return response()->json([
                'status' => 0,
                'msg' => 'Validation failed',
                'errors' => $validator->errors(),
            ],500);
        }

        $user = User::where('phone', $request->phone)->where('country', $request->country)->first();
        if(!$user)
        {
            $password = rand(1000,9999);
            $user = new User;
            $user->name = $request->name;
            $user->last_name = $request->last_name;
            $user->email = $request->email;
            $user->phone = $request->phone;
            $user->country = $request->country;
            $user->country_code = $request->country_code;
            $user->alt_iso2 = $request->iso2;
            $user->source = 'Meta Ads';
            $user->password = Hash::make($password);
            $user->stages = 'Test Preparation';
            $user->service_id = 12;
            $user->save();
       
            // Create the notes array
            $notes = [
                [
                    "auth_id" => 1,
                    "auth_name" => "System",
                    "notes" => 
                        "Slot Time : ". $request->slot
                ],
            ];
    
            $candidate = Candidate::where('user_id', $user->id)->first();
            if(!empty($candidate)){
                $candidate->lock_profile = Carbon::now()->addDays(3);
                $candidate->notes = json_encode($notes);
                $candidate->campaign_name = 'Free Walk-in Saturdays';
                $candidate->save();
            }
    
    
            $template = 'register_walk_in_saturday';
            $sendTo = str_replace([' ','+'],'',$user->country_code.$user->phone);
            $link = Crypt::encryptString($user->id);
            $user_id = Crypt::encryptString($user->id);
            $url = json_encode(['url' => '/dashboard']);
            $url = base64_encode($url);
    
            $currentUrl = @$_COOKIE['web_journey'];

            if($currentUrl){
                $currentUrl = json_encode($currentUrl);
                setcookie('web_journey', '', time() - 3600, '/');
                unset($_COOKIE['web_journey']);
                $user->source_url = @$currentUrl ? @$currentUrl : null;
                $user->update();                
            }

            sendWhatsapp([
                "template" => $template,
                "sendTo" => $sendTo,
                "name" => "$user->name",
                "password" => "$password",
                "user_id" => "$user->id",
                "link" => "wp/$user_id/$url",
            ]);

        } else {


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

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

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

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

            if(!empty($candidate)){
                $candidate->notes = json_encode($mergedNotes);
                $candidate->campaign_name = 'Free Walk-in Saturdays';
                $candidate->save();
            }
        }
        
        $lead = new Lead();
        $lead->name = $request->name . ' ' . $request->last_name;
        $lead->phone = $request->phone;
        $lead->source = 'Meta Ads';
        $lead->url = $request->url;
        $lead->country_id = $request->country;
        $lead->user_id = $user->id;
        $lead->description = json_encode($notes);        

        $lead->save();


        // $template = 'welcome-mail';
        // $subject = 'Welcome to Gradding.com';
        // $data = $user;
        // $website_setting = WebsiteSetting::first();
        // $email = $request->input('email');
        // $setting = Setting::first();
        // dispatch(new sendemail($email, $template, $subject, $data, $setting, $website_setting, $password));

        if($user && $lead){
            return response()->json([
                'status' => 1,
                'msg' => 'Seat Booked Successfully',
            ]);
        }
        return response()->json([
            'status' => 0,
            'msg' => 'Something Went Wrong',
        ]);
    }

    public function qrScan(){     
        if($this->device == 'mobile'){
            return view('auth_api.qrscan');
        }else{
            abort(404);
        }
    }

    public function jecrc(){     
        return view('auth_api.jecrc');        
    }

    public function jecrcLogin(Request $request){

        [$country_name, $country_code] = explode('@#$?',$request->country_code);
        
        $userData = User::where('phone', $request->phone)->orWhere('alternate_phone', $request->phone)->where('country_code', $request->country_code)->first();
        if($userData){

            $userData->partner = 'JECRC';
            $userData->update();

            return response()->json([
                'status' => 1,
                'msg' => 'User Already Exists',
            ]);
        }else{
            $pin = str_pad(rand(0, 9999), 4, '0', STR_PAD_LEFT);

            $userData = User::create([
                'phone' => $request->phone,
                'country_code' => $country_code,
                'password' => Hash::make($pin),
                'name' => $request->name,
                'last_name' => $request->last_name,
                'country' => $country_name,
                'partner' => 'JECRC',
            ]);

            auth()->login($userData);

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

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

            return response()->json([
                'status' => 1,
                'msg' => 'User Register Successfully',
            ]);
        }
    }
}