<?php
namespace App\Http\Services;

use App\Models\User;
use App\Models\Locker;
use App\Models\SanctumToken;
use App\Models\UserBoxInventory;
use App\Models\EmailToken;
use App\Models\UserSocialize;
use App\Http\Services\UserCreditService;
use App\Http\Services\EmailService;
use Auth;
use Hash;
use Illuminate\Validation\ValidationException;
use Queriplex;
use Pylon\Exceptions\BadRequestException;
use Twilio\Rest\Client;
use Carbon\Carbon;

class AuthService
{
    public function __construct(
		UserCreditService $userCreditService,
		EmailService $emailService
	)
	{
		$this->userCreditService = $userCreditService;
		$this->emailService = $emailService;
	}

	public function login(Array $request)
	{
        $credentials = [
            "password" => $request['password']
        ];

        if(isset($request['email']))
        {
            $credentials["email"] = $request['email'];
        }
        else if(isset($request['login']))
        {
            if(filter_var($request['login'], FILTER_VALIDATE_EMAIL))
            {
                $credentials["email"] = $request['login'];
            }
            else
            {
                $credentials["unique_id"] = $request['login'];
            }
        }

		if (Auth::attempt($credentials)) {
            $is_mobile_platformm = in_array( SanctumToken::getPlatformId($request['platform']), SanctumToken::getMobilePlatforms());
            if($is_mobile_platformm && !in_array(Auth::user()->role_id,[ User::ROLE_CUSTOMER ]) && !isset($request['terminal_id'])){
                throw (new BadRequestException("Role Access Denied", 403))
                    ->withErrorType("ROLE_ACCESS_DENIED");
            }

            if(isset($request['terminal_id']))
            {
                $locker = Locker::where('terminal_id', $request['terminal_id'])->firstOr(function(){
                    throw ValidationException::withMessages([
                        "terminal_id" => "Terminal ID is unavailable.",
                    ]);
                });
                
                if(Auth::user()->id != $locker->owner_id && !Auth::user()->isSuperAdmin())
                {
                    throw (new BadRequestException("Locker ownership mismatched!", 403))
                        ->withErrorType("LOCKER_LOGIN_ACCESS_DENIED");
                }
            }

            $token = Auth::user()->createToken($request['device_name'], $request['platform']);

            if( isset($request['fcm_token']) ){
                Auth::user()->fcmTokens()->updateOrCreate([
                    'token' => $request['fcm_token'],
                ],[
                    'token' => $request['fcm_token'],
                ]);
            }

            return $token;
        }

        throw ValidationException::withMessages([
            'email' => ['The provided credentials are incorrect.'],
            'login' => ['The provided credentials are incorrect.']
        ]);
	}

    public function byPassLogin(Array $request)
    {
        $user = Queriplex::make(User::query())
            ->withFilters($request, [
                "id" => "id",
                "username" => "full_name",
                "email" => "email",
            ])->apply();

        $result = $user->whereNotIn('role_id',[ User::ROLE_SUPER_ADMIN, User::ROLE_AA_ADMIN ])
            ->first();
    
        if ( $result && Auth::guard()->loginUsingId($result->id)) {

            $token = Auth::user()->createToken($request['device_name']);
            return $token;
        }

        throw new BadRequestException("Failed to by pass login.");
    }

    public function register(Array $request)
    {
        if(isset($request['code']))
            $this->checkPhoneVerification($request);

        $user = new User();
        $user->full_name = $request['full_name'];
        $user->unique_id = User::computedUniqueId($request['role_id']);
        $user->email = $request['email'];
        $user->mobile_num = $request['mobile_num'];
        $user->gender = $request['gender'] ?? null;
		$user->address = $request['address'] ?? null;
		$user->city = $request['city'] ?? null;
		$user->postcode = $request['postcode'] ?? null;
		$user->state = $request['state'] ?? null;
        $user->role_id = User::ROLE_CUSTOMER;
        $user->password = Hash::make($request['password']);
        $user->phone_verified_at = now();
        $user->save();

        $this->userCreditService->userRegisterFreeCredit($user->id);

        if(isset($request['device_name'])){
            Auth::guard()->loginUsingId($user->id);
            $token = Auth::user()->createToken($request['device_name'], $request['platform']);

            if( isset($request['fcm_token']) ){
                Auth::user()->fcmTokens()->updateOrCreate([
                    'token' => $request['fcm_token'],
                ],[
                    'token' => $request['fcm_token'],
                ]);
            }

            return $token;
        }

        return true;
    }

    public function user()
    {
        $user = Auth::user();
        $user['partnerPackage'] = $user->partnerPackage;
        $user['isPartner'] = $user->isPartner();
        $user['isSuperAdmin'] = $user->isSuperAdmin();
        $user['isCustomer'] = $user->isCustomer();

        if(!$user->isSuperAdmin()){
            $user->getCreditAmount();
        }

        return [
            "version" => 1,
            "user" => $user,
        ];
    }

    public function logout()
    {
        return Auth::user()->currentAccessToken()->delete();
    }

    public function editAuthPassword(Array $request)
    {
        
        $user = Auth::user();

        // check current password
        if ($user->isContainOldPassword() && !Hash::check($request['current_password'], $user->password)){
            throw ValidationException::withMessages([
                "current_password" => "Current Password is invalid.",
            ]);
        }

        // see if old and new password are equal
        if (Hash::check($request['password'], $user->password)){
            throw ValidationException::withMessages([
                "password" => "New password cannot be the same as current password.",
            ]);
        }

        $user->password = Hash::make($request['password']);
        $user->save();

        $user->tokens()->delete();

        return true;
    }

    public function initPhoneVerification($mobile_num)
    {
        try{
            $token = config('services.twilio.twilioAuth');
            $twilio_sid = config('services.twilio.twilioSid');
            $twilio_verify_sid = config('services.twilio.twilioVerifySid');
            $twilio = new Client($twilio_sid, $token);
            $message = $twilio->verify->v2->services($twilio_verify_sid)
                ->verifications
                ->create($mobile_num, "sms");
            return $message->status;
        }
        catch(\Exception $e){
            throw $e;
        }
    }

    public function checkPhoneVerification(Array $request)
    {
        $token = config('services.twilio.twilioAuth');
        $twilio_sid = config('services.twilio.twilioSid');
        $twilio_verify_sid = config('services.twilio.twilioVerifySid');
        $twilio = new Client($twilio_sid, $token);
        try{
            $verification_check = $twilio->verify->v2->services($twilio_verify_sid)
                                    ->verificationChecks
                                    ->create([
                                        'code' => $request['code'], 
                                        'to' => $request['mobile_num']
                                        ]);
        }
        catch(\Exception $e){
            if($e->getCode() == 20404)
            {
                throw (new BadRequestException("Invalid verification code."))
                    ->withErrorType("INVALID_VERIFICATION_CODE");
            }
            else if($e->getCode() == 60202)
            {
                throw (new BadRequestException("Max check attempt reached, please try again 15 minutes later."))
                    ->withErrorType("MAX_CHECK_ATTEMPT_REACHED");
            }
        }
        
        if($verification_check->valid)
        {
            return true;
        }

        throw (new BadRequestException("Invalid verification code."))
            ->withErrorType("INVALID_VERIFICATION_CODE");
    }

    public function updateMobileNum(Array $request)
    {
        
        $user = $request['user'];

        // check if user already has phone number
        // if($user->mobile_num != NULL && $user->mobile_num != '')
		// 	throw (new BadRequestException("User already has phone number."))
		// 		->withErrorType("User already has phone number.");

        if($this->checkPhoneVerification($request))
        {
            UserBoxInventory::where("collector_num", $user->mobile_num)
            ->update(["collector_num" => $request['mobile_num']]);
            
            $user->mobile_num = $request['mobile_num'];
            $user->phone_verified_at = now();
            $user->save();
        }

        return $user;
    }

    public function updateFcmToken(Array $request)
    {
        $user = $request['user'];

        $user->fcmTokens()->updateOrCreate([
            'token' => $request['fcm_token'],
        ],[
            'token' => $request['fcm_token'],
        ]);

        return $user;
    }

    public function initEmailVerification(Array $request)
    {
        $user = $request['user'];

        $code = mt_rand(100000,999999);
        
        $expired_at = Carbon::now();

        $expired_at = $expired_at->addMinutes(5);

        $email_token = new EmailToken();
        $email_token->email = $request['email'];
        $email_token->token = $code;
        $email_token->type = EmailToken::UPDATE_EMAIL;
        $email_token->expired_at = $expired_at;
		$email_token->save();

		$this->emailService->send_email_verification($user, $request['email'], $code);

        return true;
    }

    public function checkEmailVerification(Array $request)
    {
        $email_token = EmailToken::where("expired_at", ">", Carbon::now())
        ->where("email", $request["email"])
        ->where("token", $request["code"])
        ->first();

        if($email_token)
        {
            $email_token->expired_at = Carbon::now();
            $email_token->save();

            return true;
        }

        throw (new BadRequestException("Invalid verification code."))
            ->withErrorType("INVALID_VERIFICATION_CODE");
    }

    public function updateEmail(Array $request)
    {
        
        $user = $request['user'];

        // check if user already has phone number
        // if($user->mobile_num != NULL && $user->mobile_num != '')
		// 	throw (new BadRequestException("User already has phone number."))
		// 		->withErrorType("User already has phone number.");

        if($this->checkEmailVerification($request))
        {
            $user->email = $request['email'];
            $user->save();
        }

        return $user;
    }

    public function deleteAccount(Array $request)
	{
        $user = $request['user'];

        $credentials = [
            "password" => $request['password'],
            "email" => $user->email,
        ];

        if(Hash::check($request['password'], $user->password))   
        {
    
            $user->full_name = $user->id . "_" . $user->full_name . "_deleted";
            $user->unique_id = $user->id . "_" . $user->unique_id . "_deleted";
            $user->email = $user->id . "_" . $user->email . "_deleted";
            $user->mobile_num = $user->id . "_" . $user->mobile_num . "_deleted";
            $user->ic_num = $user->id . "_" . $user->ic_num . "_deleted";
            $user->save();
    
            UserSocialize::where("user_id", $user->id)->delete();
    
            $user->tokens()->delete();
            
            $user->delete();
            return true;
        }
        
        throw ValidationException::withMessages([
            'password' => ['The provided credentials are incorrect.'],
        ]);
	}

}