<?php

namespace App\Http\Controllers\ProviderAuth;

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

use Tymon\JWTAuth\Exceptions\JWTException;
use App\Notifications\ResetPasswordOTP;

use Auth;
use Config;
use JWTAuth;
use Setting;
use Notification;
use Validator;
use Socialite;
use Twilio;
use Mail;

use App\Provider;
use App\ProviderDevice;
use App\ProviderService;
/*** for street ride.*/
use App\ServiceType;
use App\User;
use App\UserRequests;
use App\Helpers\Helper;
use Carbon\Carbon;
use App\RequestFilter;

class TokenController extends Controller
{
    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */

    public function register(Request $request)
    {
        $this->validate($request, [
                'device_id' => 'required',
                'device_type' => 'required|in:android,ios',
                'device_token' => 'required',
                'first_name' => 'required|max:255',
                'last_name' => 'required|max:255',
                'email' => 'required|email|max:255|unique:providers',
                'mobile' => 'required',
                'password' => 'required|min:6',
            ]);

        try{

            $Provider = $request->all();
            $Provider['password'] = bcrypt($request->password);

            $Provider = Provider::create($Provider);

            // send welcome email here
            if(Setting::get('mail_enable', 0) == 1) {
                $user = $request->all();
                Mail::send('emails.driver-register', ['user' => $user], function ($message) use ($user){
                    $message->to($user['email'], $user['first_name'])->subject(config('app.name').' Driver Registration');
                });
            }

            return $Provider;


        } catch (QueryException $e) {
            if ($request->ajax() || $request->wantsJson()) {
                return response()->json(['error' => 'Something went wrong, Please try again later!'], 500);
            }
            return abort(500);
        }
        
    }

    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */

    public function authenticate(Request $request)
    {
        $this->validate($request, [
                'device_id' => 'required',
                'device_type' => 'required|in:android,ios',
                'device_token' => 'required',
                'email' => 'required|email',
                'password' => 'required|min:6',
            ]);

        Config::set('auth.providers.users.model', 'App\Provider');

        $credentials = $request->only('email', 'password');

        try {
            if (! $token = JWTAuth::attempt($credentials)) {
                return response()->json(['error' => 'The email address or password you entered is incorrect.'], 401);
            }
        } catch (JWTException $e) {
            return response()->json(['error' => 'Something went wrong, Please try again later!'], 500);
        }

        $User = Provider::with('service', 'device')->find(Auth::user()->id);
        $User->access_token = $token;
        $User->currency = Setting::get('currency', '$');
        $User->sos = Setting::get('sos_number', '911');

        if($User->device) {
            /*$checker = ProviderService::where('provider_id',Auth::user()->id)->get()->first();
            if($checker->status !='offline'){
                return response()->json(['error' => 'You are Already logged In'], 401);
            }*/
            ProviderDevice::where('id',$User->device->id)->update([
                'udid' => $request->device_id,
                'token' => $request->device_token,
                'type' => $request->device_type,
            ]);
            
        } else {
            ProviderDevice::create([
                    'provider_id' => $User->id,
                    'udid' => $request->device_id,
                    'token' => $request->device_token,
                    'type' => $request->device_type,
                ]);
        }
    Provider::where('id',$User->id)->update(['login_at' => Carbon::now(),'login_status' =>1]);
        return response()->json($User);
    }

    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */

    public function logout(Request $request)
    {
        try {
            ProviderDevice::where('provider_id', $request->id)->update(['udid'=> '', 'token' => '']);
            ProviderService::where('provider_id',$request->id)->update(['status' => 'offline']);
            Provider::where('id', $request->id)->update(['logout_at' => Carbon::now(),'login_status' =>0]);
            return response()->json(['message' => trans('api.logout_success')]);
        } catch (Exception $e) {
            return response()->json(['error' => trans('api.something_went_wrong')], 500);
        }
    }

 /**
     * Forgot Password.
     *
     * @return \Illuminate\Http\Response
     */


    public function forgot_password(Request $request){

        $this->validate($request, [
                'email' => 'required|email|exists:providers,email',
            ]);

        try{  
            
            $provider = Provider::where('email' , $request->email)->first();

            $otp = mt_rand(100000, 999999);

            $provider->otp = $otp;
            $provider->save();

            Notification::send($provider, new ResetPasswordOTP($otp));

            //sms
            if(Setting::get('sms_enable', 0) == 1) {
                $mobile = $provider->mobile;
                $message = 'Kindly note your OTP : '.$otp.' Regards '.config('app.name'); 
                try {
                        Twilio::message($mobile, $message);
                    } catch ( \Services_Twilio_RestException $e ) {
                        //return $e->getMessage();  
                    }
            }
            return response()->json([
                'message' => 'OTP sent to your email and Mobile!',
                'provider' => $provider
            ]);

        }catch(Exception $e){
                return response()->json(['error' => trans('api.something_went_wrong')], 500);
        }
    }


    /**
     * Reset Password.
     *
     * @return \Illuminate\Http\Response
     */

    public function reset_password(Request $request){

        $this->validate($request, [
                'password' => 'required|confirmed|min:6',
                'id' => 'required|numeric|exists:providers,id'
            ]);

        try{

            $Provider = Provider::findOrFail($request->id);
            $Provider->password = bcrypt($request->password);
            $Provider->save();

            if($request->ajax()) {
                return response()->json(['message' => 'Password Updated']);
            }

        }catch (Exception $e) {
            if($request->ajax()) {
                return response()->json(['error' => trans('api.something_went_wrong')]);
            }
        }
    }

    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */
    public function facebookViaAPI(Request $request) { 

        $validator = Validator::make(
            $request->all(),
            [
                'device_type' => 'required|in:android,ios',
                'device_token' => 'required',
                'accessToken'=>'required',
                'device_id' => 'required',
                'login_by' => 'required|in:manual,facebook,google'
            ]
        );
        
        if($validator->fails()) {
            return response()->json(['status'=>false,'message' => $validator->messages()->all()]);
        }
        $user = Socialite::driver('facebook')->stateless();
        $FacebookDrive = $user->userFromToken( $request->accessToken);
       
        try{
            $FacebookSql = Provider::where('social_unique_id',$FacebookDrive->id);
            if($FacebookDrive->email !=""){
                $FacebookSql->orWhere('email',$FacebookDrive->email);
            }
            $AuthUser = $FacebookSql->first();
            if($AuthUser){ 
                $AuthUser->social_unique_id=$FacebookDrive->id;
                $AuthUser->login_by="facebook";
                $AuthUser->save();  
            }else{   
                $AuthUser["email"]=$FacebookDrive->email;
                $name = explode(' ', $FacebookDrive->name, 2);
                $AuthUser["first_name"]=$name[0];
                $AuthUser["last_name"]=isset($name[1]) ? $name[1] : '';
                $AuthUser["password"]=bcrypt($FacebookDrive->id);
                $AuthUser["social_unique_id"]=$FacebookDrive->id;
                $AuthUser["avatar"]=$FacebookDrive->avatar;
                $AuthUser["login_by"]="facebook";
                $AuthUser = Provider::create($AuthUser);

                if(Setting::get('demo_mode', 0) == 1) {
                    $AuthUser->update(['status' => 'approved']);
                    ProviderService::create([
                        'provider_id' => $AuthUser->id,
                        'service_type_id' => '1',
                        'status' => 'active',
                        'service_number' => '4pp03ets',
                        'service_model' => 'Audi R8',
                    ]);
                }
            }    
            if($AuthUser){ 
                $userToken = JWTAuth::fromUser($AuthUser);
                $User = Provider::with('service', 'device')->find($AuthUser->id);
                if($User->device) {
                    ProviderDevice::where('id',$User->device->id)->update([
                        
                        'udid' => $request->device_id,
                        'token' => $request->device_token,
                        'type' => $request->device_type,
                    ]);
                    
                } else {
                    ProviderDevice::create([
                        'provider_id' => $User->id,
                        'udid' => $request->device_id,
                        'token' => $request->device_token,
                        'type' => $request->device_type,
                    ]);
                }
                return response()->json([
                            "status" => true,
                            "token_type" => "Bearer",
                            "access_token" => $userToken,
                            'currency' => Setting::get('currency', '$'),
                            'sos' => Setting::get('sos_number', '911')
                        ]);
            }else{
                return response()->json(['status'=>false,'message' => "Invalid credentials!"]);
            }  
        } catch (Exception $e) {
            return response()->json(['status'=>false,'message' => trans('api.something_went_wrong')]);
        }
    }

    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */
    public function googleViaAPI(Request $request) { 

        $validator = Validator::make(
            $request->all(),
            [
                'device_type' => 'required|in:android,ios',
                'device_token' => 'required',
                'accessToken'=>'required',
                'device_id' => 'required',
                'login_by' => 'required|in:manual,facebook,google'
            ]
        );
        
        if($validator->fails()) {
            return response()->json(['status'=>false,'message' => $validator->messages()->all()]);
        }
        $user = Socialite::driver('google')->stateless();
        $GoogleDrive = $user->userFromToken( $request->accessToken);
       
        try{
            $GoogleSql = Provider::where('social_unique_id',$GoogleDrive->id);
            if($GoogleDrive->email !=""){
                $GoogleSql->orWhere('email',$GoogleDrive->email);
            }
            $AuthUser = $GoogleSql->first();
            if($AuthUser){
                $AuthUser->social_unique_id=$GoogleDrive->id;  
                $AuthUser->login_by="google";
                $AuthUser->save();
            }else{   
                $AuthUser["email"]=$GoogleDrive->email;
                $name = explode(' ', $GoogleDrive->name, 2);
                $AuthUser["first_name"]=$name[0];
                $AuthUser["last_name"]=isset($name[1]) ? $name[1] : '';
                $AuthUser["password"]=($GoogleDrive->id);
                $AuthUser["social_unique_id"]=$GoogleDrive->id;
                $AuthUser["avatar"]=$GoogleDrive->avatar;
                $AuthUser["login_by"]="google";
                $AuthUser = Provider::create($AuthUser);

                if(Setting::get('demo_mode', 0) == 1) {
                    $AuthUser->update(['status' => 'approved']);
                    ProviderService::create([
                        'provider_id' => $AuthUser->id,
                        'service_type_id' => '1',
                        'status' => 'active',
                        'service_number' => '4pp03ets',
                        'service_model' => 'Audi R8',
                    ]);
                }
            }    
            if($AuthUser){
                $userToken = JWTAuth::fromUser($AuthUser);
                $User = Provider::with('service', 'device')->find($AuthUser->id);
                if($User->device) {
                    ProviderDevice::where('id',$User->device->id)->update([
                        
                        'udid' => $request->device_id,
                        'token' => $request->device_token,
                        'type' => $request->device_type,
                    ]);
                    
                } else {
                    ProviderDevice::create([
                        'provider_id' => $User->id,
                        'udid' => $request->device_id,
                        'token' => $request->device_token,
                        'type' => $request->device_type,
                    ]);
                }
                return response()->json([
                            "status" => true,
                            "token_type" => "Bearer",
                            "access_token" => $userToken,
                            'currency' => Setting::get('currency', '$'),
                            'sos' => Setting::get('sos_number', '911')
                        ]);
            }else{
                return response()->json(['status'=>false,'message' => "Invalid credentials!"]);
            }  
        } catch (Exception $e) {
            return response()->json(['status'=>false,'message' => trans('api.something_went_wrong')]);
        }
    }


    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */

    public function refresh_token(Request $request)
    {

        Config::set('auth.providers.users.model', 'App\Provider');

        $Provider = Provider::with('service', 'device')->find(Auth::user()->id);

        try {
            if (!$token = JWTAuth::fromUser($Provider)) {
                return response()->json(['error' => 'Unauthenticated'], 401);
            }
        } catch (JWTException $e) {
            return response()->json(['error' => 'Something went wrong'], 500);
        }

        $Provider->access_token = $token;

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

    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */

    public function streetride_fare(Request $request){
    
        $this->validate($request,[
                's_latitude' => 'required|numeric',
                's_longitude' => 'required|numeric',
                'd_latitude' => 'required|numeric',
                'd_longitude' => 'required|numeric',
                'service_type' => 'required|numeric|exists:service_types,id',
            ]);

        try{

            $details = "https://maps.googleapis.com/maps/api/distancematrix/json?origins=".$request->s_latitude.",".$request->s_longitude."&destinations=".$request->d_latitude.",".$request->d_longitude."&mode=driving&sensor=false&key=".env('GOOGLE_MAP_KEY');

            $json = curl($details);

            $details = json_decode($json, TRUE);
                
            $meter = $details['rows'][0]['elements'][0]['distance']['value'];
            $time = $details['rows'][0]['elements'][0]['duration']['text'];
            $seconds = $details['rows'][0]['elements'][0]['duration']['value'];

            $unit =Setting::get('distance_unit');
            
            if($unit =='km'){
                $kilometer = $meter/1000;
            }else{
                $base = $meter/1000;
                $kilometer = $base * 0.62137119;
            }

            $kilometer = round($kilometer,2);
            $minutes = $seconds/60;

            $tax_percentage = Setting::get('tax_percentage');
            $sro_levy = Setting::get('sro_levy');
            
            $service_type = ServiceType::findOrFail($request->service_type);
            $current = Carbon::now()->toTimeString();
            $today = Carbon::now();
            if(($today->day == '25' && $today->month == '12') || ($today->day == '26' && $today->month == '12') || ($today->day == '1' && $today->month == '1') || ($today->day == '31' && $today->month == '12' && $current > '18:00:00')){
                $fare_flag = $service_type->p_flag;
                $fare_distance = $service_type->p_distance;
                $fare_booking = $service_type->p_booking;
                $fare_waiting = $service_type->p_waiting;
            }else{
                $currentday = Carbon::now()->format('l');
                if($service_type->p_enable ==2 && ($current > $service_type->p_stime || $current < $service_type->p_etime )){
                    $fare_flag = $service_type->p_flag;
                    $fare_distance = $service_type->p_distance;
                    $fare_booking = $service_type->p_booking;
                    $fare_waiting = $service_type->p_waiting;
                    
                }elseif((($currentday =='Friday' || $currentday=='Saturday') && $current > $service_type->p_stime) || (($currentday=='Saturday' || $currentday=='Sunday') && $current < $service_type->p_etime)){
                    $fare_flag = $service_type->p_flag;
                    $fare_distance = $service_type->p_distance;
                    $fare_booking = $service_type->p_booking;
                    $fare_waiting = $service_type->p_waiting;
                    
                }elseif($current > $service_type->n_stime || $current > $service_type->n_etime){
                    $fare_flag = $service_type->n_flag;
                    $fare_distance = $service_type->n_distance;
                    $fare_booking = $service_type->n_booking;
                    $fare_waiting = $service_type->n_waiting;
                   
                }else{
                    $fare_flag = $service_type->d_flag;
                    $fare_distance = $service_type->d_distance;
                    $fare_booking = $service_type->d_booking;
                    $fare_waiting = $service_type->d_waiting;
                
                } 
            }

            $price = $fare_flag;
            if($kilometer > 1){
                $kilometer1 = $kilometer - 1;
                $price += ($kilometer1 * $fare_distance); 
            }   
            $tax_price = $tax_percentage;
            $total = $price + $sro_levy + $fare_booking;
            
            
            return response()->json([
                    'estimated_fare' => round($total,2), 
                    'distance' => $kilometer,
                    'distance_unit' => $unit,
                    'time' => $time,
                    'tax_price' => $tax_price,
                    'sro_levy' => $sro_levy,
                    'booking_fare' => $fare_booking,
                    'base_price' => $fare_flag,
                    'wallet_balance' => Auth::user()->wallet_balance,
                ]);

        } catch(Exception $e) {
            return response()->json(['error' => trans('api.something_went_wrong')], 500);
        }
    }

/**
     * Show the Street ride trip send.
     *
     * @return \Illuminate\Http\Response
     */

    public function streetride_request(Request $request) {

        $this->validate($request, [
                's_latitude' => 'required|numeric',
                'd_latitude' => 'required|numeric',
                's_longitude' => 'required|numeric',
                'd_longitude' => 'required|numeric',
                'service_type' => 'required|numeric|exists:service_types,id',
                'distance' => 'required|numeric',
                'provider_id' => 'required|numeric',
                   
            ]);

            if(!empty($request->mobile) || !empty($request->email)){
                $mobile = Setting::get('country_code', '+91').$request->mobile;
                $checkmobile = User::where('mobile', $mobile)->first();
                
                if($request->email !=''){
                    $checkemail = User::where('email', $request->email)->first();
                }else{
                    $checkemail = User::where('email', 'sdfasdfdf')->first();
                }

                $mobilecheckcount = count($checkmobile);
                $emailcheckcount = count($checkemail);
                if($mobilecheckcount > 0){
                    $currentuser = $checkmobile;
                }elseif($emailcheckcount > 0){
                    $currentuser = $checkemail;
                }else{
                    $User['email'] = null;
                    $User['mobile'] = null;
                    if(!empty($request->email)){
                        $User['email'] = $request->email;
                    }
                    if(!empty($request->mobile)){
                        $User['mobile'] = Setting::get('country_code', '+91').$request->mobile;
                    }
                    $User['first_name'] = $request->first_name ? : 'Street Ride';
                    $User['last_name'] = $request->last_name ? : 'Client';
                    $User['password'] = null;
                    $User['payment_mode'] = 'CASH';
                    $User['login_by'] = 'manual';
                    $User = User::create($User);
                    $currentuser = $User;
                }
            }else{
                $mobile = Setting::get('country_code', '+91').Setting::get('contact_number', '');
                $User = User::where('mobile', $mobile)->first();
                if($User !=null){
                    $currentuser = $User;
                }else{
                    $currentuser = User::create([
                        'first_name' => 'Street Ride',
                        'last_name' => 'Client',
                        'email' => Setting::get('contact_email', ''),
                        'mobile' => Setting::get('country_code', '+91').Setting::get('contact_number', ''),
                        'password' => '123456789',
                        'payment_mode' => 'CASH',
                        'login_by' => 'manual',
                        'created_by' =>'Street Ride(Driver)'
                    ]);
                }
            }
            
        $checkonline = ProviderService::where('provider_id',$request->provider_id)->first();
        if($checkonline->status == 'offline'){
            return response()->json(['error' => 'Go Online to take trip.'], 500);
        }

       $ActiveDriverRequests = UserRequests::where('provider_id', $request->provider_id)
                ->whereNotIn('status' , ['CANCELLED', 'COMPLETED', 'SCHEDULED'])->count();

        if($ActiveDriverRequests > 0) {
            return response()->json(['error' => 'Already in Trip, Cannot make multiple trip at a time.'], 500);
        }
        
        $latitude = $request->s_latitude;
        $longitude = $request->s_longitude;
        $service_type = $request->service_type;

        try{

            $details = "https://maps.googleapis.com/maps/api/directions/json?origin=".$request->s_latitude.",".$request->s_longitude."&destination=".$request->d_latitude.",".$request->d_longitude."&mode=driving&key=".env('GOOGLE_MAP_KEY');
            $json = curl($details);
            $details = json_decode($json, TRUE);
            $route_key = $details['routes'][0]['overview_polyline']['points'];
            $UserRequest = new UserRequests;
            $UserRequest->booking_id = Helper::generate_booking_id();
            $UserRequest->user_id = $currentuser['id'];
            $UserRequest->current_provider_id = $request->provider_id;
            $UserRequest->service_type_id = $request->service_type;
            $UserRequest->payment_mode = 'CASH';
            
            $UserRequest->status = 'SEARCHING';
            $UserRequest->booking_by = 'STREET';
            $UserRequest->s_address = $request->s_address ? : "";
            $UserRequest->d_address = $request->d_address ? : "";

            $UserRequest->s_latitude = $request->s_latitude;
            $UserRequest->s_longitude = $request->s_longitude;

            $UserRequest->d_latitude = $request->d_latitude;
            $UserRequest->d_longitude = $request->d_longitude;
            $UserRequest->distance = $request->distance;

            $UserRequest->assigned_at = Carbon::now();
            $UserRequest->route_key = '';

            $UserRequest->surge = 0;
            
            $UserRequest->save();

            ProviderService::where('provider_id',$request->provider_id)->update(['status' =>'riding']);
            
            $Filter = new RequestFilter;
            $Filter->request_id = $UserRequest->id;
            $Filter->provider_id = $request->provider_id;
            $Filter->save();

            if($request->ajax()) {
                return response()->json([
                        'message' => 'New request Created!',
                        'request_id' => $UserRequest->id,
                        'current_provider' => $UserRequest->current_provider_id,
                    ]);
            }else{
                return redirect('dashboard');
            }

        }catch (Exception $e) {
            if($request->ajax()) {
                return response()->json(['error' => trans('api.something_went_wrong')], 500);
            }else{
                return back()->with('flash_error', 'Something went wrong while sending request. Please try again.');
            }
        }
    }

}