<?php

namespace App\Http\Controllers\Admin;

use App\AdditionalFile;
use App\Credit;
use App\CreditHistory;
use App\Currency;
use App\DataTables\AdminTopClientDataTable;
use App\DataTables\AdminUserDataTable;
use App\DataTables\AdminUserPaymDataTable;
use App\DataTables\ClientRegistrationDataTable;
use App\DataTables\ResellerUserDataTable;
use App\DataTables\ResellerUserPaymDataTable;
use App\Http\Controllers\Controller;
use App\Network;
use App\Role;
use App\Tools\SmsTools;
use App\User;
use App\UserCurrency;
use App\UserNetwork;
use App\UserSenderId;
use Carbon\Carbon;
use Illuminate\Http\Request;

use App\Http\Requests;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;

class UserController extends Controller
{
    public function user_networks($user_id) {
        $user = User::findOrFail($user_id);
        $data = [];
        foreach (Network::with('country')
                     ->orderBy('country_id')
                     ->orderBy('nice_name')
                     ->get( ) as $record) {
            $existing = $user->user_networks()->where([
                ['network_id', '=', $record->id],
                ['country_id', '=', $record->country_id]
            ])->first();
            $data[] = [
                'id' => $record->id,
                'full_name' => $record->full_name,
                'nice_name' => $record->nice_name,
                'code' => $record->code,
                'country_id' => $record->country_id,
                'country' => $record->country->name,
                'prefix' => $record->prefix,
                'sms_price' => empty($existing) ? $record->sms_price : $existing->sms_price
            ];
        }
        return view('admin.users.user_networks', ['data'=>$data, 'user'=>$user]);
    }

    public function edit_user_network($user_id, $id) {
        $user = User::findOrFail($user_id);
        $global_network = Network::findOrFail($id);
        $user_network = $user->user_networks()
                             ->where('network_id', $global_network->id)
                             ->where('country_id', $global_network->country_id)
                             ->first();
        $record = [
            'id' => $global_network->id,
            'full_name' => $global_network->full_name,
            'nice_name' => $global_network->nice_name,
            'code' => $global_network->code,
            'country_id' => $global_network->country_id,
            'country' => $global_network->country->name,
            'prefix' => $global_network->prefix,
            'sms_price' => empty($user_network) ? $global_network->sms_price : $user_network->sms_price
        ];

        return view('admin.users.edit_user_network', [
            'user' => $user,
            'record' => $record
        ]);

    }

    public function update_user_network(Request $request, $user_id, $id) {
        $this->validate($request, [
            'sms_price' => 'required|numeric'
        ]);

        $user = User::findOrFail($user_id);
        $global_network = Network::findOrFail($id);
        $user_network = $user->user_networks()
            ->where('network_id', $global_network->id)
            ->where('country_id', $global_network->country_id)
            ->first();

        $new_price = (float)$request['sms_price'];
        if(!empty($new_price)) {
            if(!empty($user_network)) {
                $user_network->update(['sms_price'=>$new_price]);
            } else {
                if((float)$new_price !== (float)$global_network->sms_price) {
                    $user->user_networks()->create([
                       'network_id'  => $global_network->id,
                        'country_id' => $global_network->country_id,
                        'sms_price' => $new_price
                    ]);
                }
            }
        } else {
            return redirect()->back()->withInput()->withErrors(array('error' => 'The network price is invalid'));
        }

        $request->session()->flash('success', 'The user network price was successfully updated!');
        return redirect()->route('admin.users.networks', ['user_id'=>$user->id]);
    }

    public function index(AdminUserDataTable $dataTable) {
        return $dataTable->render('admin.users.index');
    }

    public function new_user() {
        $roleId = Role::where('name', 'reseller')->firstOrFail()->id;
        $resellers = User::where('role_id', $roleId)->get(['id', 'full_name']);
        $currencies = Currency::orderBy('default', 'desc')->orderBy('name', 'asc')->get(['id','name']);
        return view('admin.users.new', [
            'resellers' => $resellers,
            'currencies' => $currencies
        ]);
    }

    public function get_currency_abbr() {
        return ['value'=>Currency::findOrFail(request()->get('id'))->abbr];
    }

    public function post_new_user(Request $request) {
        $this->validate($request, [
            'contact_person' => 'required|max:255',
            'username' => 'required|min:4|max:50|unique:users,username,NULL,id,deleted_at,NULL|unique:stanbic_users,username,NULL,id,deleted_at,NULL',
            'email' => 'required|email|unique:users,email',
            'phone_number' => 'required|digits_between:9,16',
            'password' => 'required|min:6',
            'password_confirmation' => 'same:password',
            'price' => 'required|numeric',
            'email_price' => 'required|numeric',
            'credited' => 'present|numeric',
            'role' => 'required',
            'currency_id' => 'required|exists:currencies,id',
            'reseller_id' => 'required_if:role,user'
        ]);

        $username = $request->get('username');
        $existingCredit = Credit::whereUsername($username)->first();
        if(!empty($existingCredit)) {
            return back()->withInput($request->all())->withErrors(['username'=>'The username has already been taken!']);
        }

        $reseller = null;
        if($request['role']=='user') {
            $reseller = User::findOrFail($request['reseller_id']);
        }

        //get first name and last name
        $inputs = $request->all();
        $owner = Auth::user();
        $parts = explode(" ", $request['contact_person']);
        $inputs['first_name'] = array_pop($parts);
        $inputs['last_name'] = implode(" ", $parts);
        $inputs['full_name']= $request['contact_person'];
        $inputs['created_by'] = !empty($reseller) ? $reseller->username : $owner->username;
        $inputs['must_change_password'] = 1;
        $inputs['pass'] = $request['password'];
        $inputs['status'] = 'active';

        //format the phone number
        $inputs['phone_number'] = SmsTools::format_gh_number($request->get('phone_number'));

        //encrypt the password
        $inputs['password'] = bcrypt($request['password']);
        $inputs['role_id'] = Role::where('name', $request['role'])->firstOrFail()->id;


        DB::beginTransaction();
        //create the client
        $user = User::create($inputs);

        //credit new client
        if(empty($reseller)) {
            $user->credit()->create([
                'username' => $user->username,
                'price' => $request['price'],
                'email_price' => $request['email_price'],
                'credit_alloted' => $request['credited'],
                'old_bal' => 0,
                'new_bal' => $request['credited'],
                'credit_used' => 0,
                'credited' => 0,
                'updated_by' => $owner->username
            ]);

            //update payment history
            if ($request['credited'] > 0) {
                $user->creditHistory()->create([
                    'date_credited' => Carbon::now()->toDateTimeString(),
                    'username' => $user->username,
                    'price' => $request['price'],
                    'credit_alloted' => $request['credited'],
                    'old_bal' => 0,
                    'new_bal' => $request['credited'],
                    'credit_used' => 0,
                    'credited' => 0,
                    'credited_by' => $owner->username,
                    'comments' => $user->username . ' has been credited by ' . $owner->username . ' with ' . $request['credited']
                ]);
            }
        } else {
            $cred_add = $request['credited'];
            $price = $request['price'];
            $email_price = $request['email_price'];
            $reseller_credit = $reseller->credit;
            $reseller_price = $reseller_credit->price;
            $reseller_email_price = $reseller_credit->email_price;
            //check price validity
            if($price < $reseller_price) {
                return redirect()->back()->withInput()->withErrors(array('error' => 'The SMS price should be at least '.$reseller_price));
            }
            if ($email_price < $reseller_email_price) {
                return redirect()->back()->withInput()->withErrors(array('error' => 'The email price should be at least '.$reseller_email_price));
            }

            //deduct owner
            $credit_to_be_deductued_from_reseller = $cred_add;
            $reseller_new_bal = $reseller_credit->new_bal;
            if ($reseller_new_bal < $credit_to_be_deductued_from_reseller) {
                return redirect()->back()->withInput()->withErrors(array('error' => 'You do not have enough balance to perform this operation'));
            }

            $reseller->creditHistory()->create([
                'date_credited' => Carbon::now()->toDateTimeString(),
                'username' => $reseller->username,
                'price' => $reseller_credit->price,
                'credit_alloted' => $reseller_credit->credit_alloted,
                'old_bal' => $reseller_credit->new_bal,
                'new_bal' => $reseller_credit->new_bal - $credit_to_be_deductued_from_reseller,
                'credit_used' => $reseller_credit->credit_used + $credit_to_be_deductued_from_reseller,
                'credited' => -($credit_to_be_deductued_from_reseller),
                'credited_by' => $owner->username,
                'comments' => $owner->username.' has credited user '.$inputs['username'].' with '.$cred_add
            ]);
            $reseller_credit->credit_used += $credit_to_be_deductued_from_reseller;
            $reseller_credit->old_bal = $reseller_credit->new_bal;
            $reseller_credit->new_bal -= $credit_to_be_deductued_from_reseller;
            $reseller_credit->updated_by = $owner->username;
            $reseller_credit->save();

            //credit new client
            $user->credit()->create([
                'username' => $user->username,
                'price' => $price,
                'email_price' => $email_price,
                'credit_alloted' => $cred_add,
                'old_bal' => 0,
                'new_bal' => $cred_add,
                'credit_used' => 0,
                'credited' => 0,
                'updated_by' => $owner->username
            ]);

            //update payment history
            if($cred_add>0) {
                $user->creditHistory()->create([
                    'date_credited' => Carbon::now()->toDateTimeString(),
                    'username' => $user->username,
                    'price' => $price,
                    'credit_alloted' => $cred_add,
                    'old_bal' => 0,
                    'new_bal' => $cred_add,
                    'credit_used' => 0,
                    'credited' => 0,
                    'credited_by' => $owner->username,
                    'comments' => $user->username.' has been credited by '.$owner->username.' with '.$cred_add
                ]);
            }
        }
        //set currency
        $currency = Currency::findOrFail($request->get('currency_id'));
        if(!$currency->default) {
            UserCurrency::create([
                'currency_id'=>$currency->id, 'user_id'=>$user->id
            ]);
            foreach (Network::all() as $record) {
                $existing = $user->user_networks()->where([
                    ['network_id', '=', $record->id],
                    ['country_id', '=', $record->country_id]
                ])->first();
                if(empty($existing)) {
                    $user->user_networks()->create([
                        'network_id' => $record->id,
                        'country_id' => $record->country_id,
                        'sms_price' => $price
                    ]);
                } else {
                    $existing->update([
                        'network_id' => $record->id,
                        'country_id' => $record->country_id,
                        'sms_price' => $price
                    ]);
                }
            }
        }
        DB::commit();

        //Send email notification to user
        $m_email = 'support@npontu.com';
        if(!empty($m_email)) {
            //prepare data to pass to email view
            $data = [
                'username' => $request['username'],
                'password' => $request['password'],
                'full_name' => $inputs['full_name'],
            ];
            if(!empty($reseller)) {
                if($reseller->email=='albert.ngumba1@cellulant.com'){
                    $data['admin_mail'] ='servicedesk@cellulant.com';
                }else{
                    $data['admin_mail'] = $reseller->email;
                }

                $data['loginUrl'] = route('login', ['name'=>$reseller->username]);
                $data['org'] = (!empty($reseller->organisation) ? $reseller->organisation: ' the SMS Platform');


                //send email notification to clent
                Mail::send('emails.reseller_reg_msg', $data, function ($m) use ($inputs, $reseller) {
                    $m_email = 'support@npontu.com';
                    $m->from($m_email, !empty($reseller->organisation) ? $reseller->organisation: 'SMS Platform');
                    $m->to($inputs['email'], $inputs['full_name']);
                    $m->subject('Welcome to '.(!empty($reseller->organisation) ? $reseller->organisation: ' the SMS Platform').'!');
                });
                $organisation = (!empty($owner->organisation) ? $owner->organisation: 'the SMS Platform');
                $msg = "Hello {$inputs['first_name']}, 
Your account with $organisation has been successfully created. 
Your username is: {$request['username']} and your password is: {$request['password']}. Thank you";

            } else {
                //prepare data to pass to email view
                $data['loginUrl'] = route('reseller.login', ['name'=>$request['username']]);
                //send email notification to clent
                Mail::send('emails.registration_msg', $data, function ($m) use ($request) {
                    $m_email = 'support@npontu.com';
                    $m->from($m_email, 'MTN MESSENGER');
                    $m->to($request['email'], $request['full_name']);
                    $m->subject('Welcome to MTN MESSENGER!');
                });
                $msg = "Hello {$inputs['first_name']}, 
Your account with MESSENGER has been successfully created. 
Your username is: {$request['username']} and your password is: {$request['password']}. Thank you";
            }

            // send sms to client
            try
            {
                @SmsTools::send_internal_sms($inputs['phone_number'], $msg);
            } catch (\Exception $ex){}
        }

        $request->session()->flash('success', 'The new user was successfully added!');
        return redirect()->route('admin.users');
    }

    public function new_user_payment($id) {
        $record = User::findOrFail($id);
        return view('admin.users.new_user_payment', ['record'=>$record]);
    }

    public function mark_payment_as_paid($id) {
        $record = CreditHistory::findOrFail($id);
        $record->status = 'paid';
        $record->save();
        session()->flash('success', 'The payment has been marked as paid');
        return redirect()->back();
    }

    public function post_user_payment(Request $request, $id) {
        $user = User::with('credit')->findOrFail($id);
        $user_credit = $user->credit;

        $this->validate($request, [
            'credited' => 'required|numeric',
            'status' => 'required'
        ]);

        //get first name and last name
        $owner = Auth::user();

        DB::beginTransaction();
        $cred_add = (double)$request['credited'];
        $price = (double) $user_credit->price;

        //update payment history
        if($cred_add>0) {
            $user->creditHistory()->create([
                'status' => $request['status'],
                'date_credited' => Carbon::now()->toDateTimeString(),
                'username' => $user->username,
                'price' => $user_credit->price,
                'credit_alloted' => $user_credit->credit_alloted + $cred_add,
                'old_bal' => $user_credit->new_bal,
                'new_bal' => $user_credit->new_bal + $cred_add,
                'credit_used' => $user_credit->credit_used,
                'credited' => $cred_add,
                'credited_by' => $owner->username,
                'comments' => $user->username.' has been credited by '.$owner->username.' with '.$cred_add
            ]);
        }

        //credit new client
        $user->credit()->update([
            'credit_alloted' => $user_credit->credit_alloted + $cred_add,
            'old_bal' => $user_credit->new_bal,
            'new_bal' => $user_credit->new_bal + $cred_add,
            'credited' => $cred_add,
            'updated_by' => $owner->username
        ]);

        DB::commit();

        //send email to client
        try
        {
            $m_email = 'support@npontu.com';
            if(!empty($m_email)) {
                //prepare data to pass to email view
                $data = [
                    'currency' => $user->currency,
                    'amount' => $request['credited'],
                    'credited_by' => Auth::user()->username,
                    'full_name' => $user->full_name,
                    'org' => ''
                ];
                //send email notification to clent
                Mail::send('emails.credit_account_msg', $data, function ($m) use ($user) {
                    $m_email = 'support@npontu.com';
                    $m->from($m_email, 'MTN MESSENGER');
                    $m->to($user->email, $user->full_name);
                    $m->cc('support@npontu.com', 'Npontu Support Team');
                    $m->cc('finance@npontu.com', 'Npontu Finance Team');
                    //$m->replyTo('support@npontu.com', 'Npontu Support Team');
                    $m->subject('Your account has been credited!');
                });

            }
        }
        catch (\Exception $ex){}

        $request->session()->flash('success', 'The user account was successfully credited!');
        return redirect()->route('admin.users.payments', ['id'=>$id]);
    }

    public function lock_user($id) {
        $record = User::findOrFail($id);

        $record->is_locked = !$record->is_locked;
        $record->save();


        $data = [
            'body' => $record->is_locked ? 'Your account has been locked please contact support for further enquires' : 'Your have now been granted access on MTN MESSENGER',
            'email'=> $record->email,
            'username'=> $record->username,
            'subject' =>  $record->is_locked ? 'Access Denied ' : 'Access Granted',
        ];

        //send email notification to client
        Mail::send('emails.access', $data, function ($m) use ($data) {
            $m->from('npontualph@gmail.com', 'MESSENGER');
            $m->replyTo('support@npontu.com', 'Npontu Support');
            $m->to($data['email'], $data['username']);
            $m->subject($data['subject']);
        });

            $msg = "Hello {$record->full_name}, 
{$data['body']}";

            $this->sendSms($msg,$record->phone_number);


        session()->flash('success', 'The user was successfully '.($record->is_locked ? 'locked':'unlocked!'));
        return redirect()->route('admin.users', ['id'=>$id]);
    }

    public function user_payments($id, AdminUserPaymDataTable $dataTable) {
        $record = User::findOrFail($id);
        return $dataTable->render('admin.users.payment', ['record'=> $record]);
    }

    public function registration_report(ClientRegistrationDataTable $dataTable) {
        return $dataTable->render('admin.report.registrations');
    }

    public function top_clients(Request $request) {
        $results    = ['detail' => [], 'summary' => []];
        $user       = Auth::user();
        $from_date  = new Carbon('first day of this month');
        $to_date    = new Carbon('last day of this month');
        $type = 'reseller';

        if (strtoupper($request->method()) == 'POST')
        {
            $data = $request->request;

            $start      = $data->get('from_date');
            $end        = $data->get('to_date');
            $type       = !empty($data->get('type')) ? $data->get('type') : $type;

            if ($from_date != null && $to_date != null)
            {
                $from_date  = Carbon::parse($start)->toDateTimeString();
                $to_date    = Carbon::parse($end)->addDay(1)->toDateTimeString();
            }

            $roleId = strtolower($type) == 'reseller' ?
                Role::where('name', 'reseller')->firstOrFail()->id :
                Role::where('name', 'user')->firstOrFail()->id ;

            $qresult = DB::table('sms_log')
                ->leftJoin('users', 'users.id', '=', 'sms_log.user_id')
                ->leftJoin('credits as rev', 'rev.user_id', '=', 'sms_log.user_id')
                ->leftJoin('credits as prf', 'prf.username', '=', 'users.created_by')
                ->select(DB::raw("client, sms, page, cprice, rprice, cprice - rprice as profit"))
                ->select(DB::raw("users.full_name as client, count(sms_log.id) as sms,
              sum(sms_log.sms_count) as page, sum(sms_log.sms_count * rev.price) as cprice, 
              sum(sms_log.sms_count * prf.price) as rprice"))
                ->whereBetween('submit_date', [$from_date, $to_date])
                ->where('users.role_id', '=', $roleId)
                ->groupBy(['client','users.full_name'])->get()->all();

            $pages          = array_sum(array_column($qresult, 'page'));
            $client_sales   = array_sum(array_column($qresult, 'cprice'));
            $reseller_sales = array_sum(array_column($qresult, 'rprice'));
            $profits        = number_format($client_sales - $reseller_sales, 2);

            $results['summary'] = [
                'pages' => $pages,
                'client_sales' => $client_sales,
                'reseller_sales' => $reseller_sales,
                'profits' => $profits
            ];

            foreach ($qresult as $item)
            {
                $profit         = $item->cprice - $item->rprice;
                $profit_share   = @($profit / $profits) === false ? 0.00 : @($profit / $profits)  * 100;
                $traffic_share  = @($item->page / $pages) === false ? 0.00 : @($item->page / $pages) * 100;

                $results['detail'][] = (object) [
                    'client'            => $item->client,
                    'sms'               => number_format($item->sms),
                    'page'              => number_format($item->page),
                    'cprice'            => number_format($item->cprice, 2),
                    'rprice'            => number_format($item->rprice, 2),
                    'profit'            => number_format($profit, 2),
                    'traffic_share'     => number_format($traffic_share, 2),
                    'profit_share'      => number_format($profit_share, 2)
                ];
            }
        }

        return  view('admin.report.top_clients', [
            'from_date' => date('d-m-Y', strtotime($from_date)),
            'to_date' => date('d-m-Y', strtotime($to_date)),
            'results' => $results
        ]);
    }

    public function edit_user($id) {
        $record = User::with(['credit','userCurrency'])->findOrFail($id);
        $files  = AdditionalFile::query()->where('user_id',$id)->get();
        $sender_id = UserSenderId::query()->where('user_id',$id)->get();
        $currencies = Currency::orderBy('default', 'desc')->orderBy('name', 'asc')->get();
        return view('admin.users.edit', [
            'record'=>$record,
            'currencies'=>$currencies,
            'files'=>$files,
            'sender_ids'=>$sender_id,
        ]);
    }

    public function update_user_sender_id(Request $request,$id)
    {

        try {

       $find = UserSenderId::query()->find($id);
       $user = User::query()->find($find->user_id);
       $organisationName=$user->organisation;
       $userName=$user->username;
       $data = $request->all();


       $msg1 = "Hello $organisationName, your sender ID {$find->sender_id} has been approved on account with username $userName.";
       $msg2 =  "Hello $organisationName, your sender ID {$find->sender_id} has been disapproved on account with username $userName. Reason : {$request->comment}";


        $content = [

            'body'     =>  $request->status == 1 ? $msg1 : $msg2,
            'email'    =>  $user->email,
            'username' =>  $user->username,
            'subject'  =>  $request->status == 1 ? 'SENDER ID APPROVAL' : ($request->status == 2 ? 'SENDER ID REJECTION' : 'SENDER ID PENDING APPROVAL'),

        ];


           if($data['status'] == 2 && empty($data['comment']))
               return redirect()->back()->withErrors('Rejection should not go without a comment');

           $data['status'] = $request->status;

           $find->update($data);
       }
       catch (\Exception $ex){
           return redirect()->back()->withErrors('Sorry request could not be processed, contact support for assistance');
       }


        try {
            Mail::send('emails.sender_id', $content, function ($m) use ($content) {
                $m->from('npontualph@gmail.com', 'MESSENGER');
                $m->replyTo('support@npontu.com', 'Npontu Support');
                $m->to($content['email'], $content['username']);
                $m->subject($content['subject']);
            });
        } catch (\Exception $ex){
        }


        $msg = "Hello {$user->full_name},
{$content['body']}";

        $this->sendSms($msg,$user->phone_number);

       return redirect()->back()->with('success','Client sender id successfully reviewed');

    }


    public function update_user(Request $request, $id) {
        $this->validate($request, [
            'contact_person' => 'required|max:255',
            'password' => 'present',
            'password_confirmation' => 'same:password',
            'email' => 'required|email|unique:users,email,'.$id,
            'phone_number' => 'required|digits_between:9,16',
            'price' => 'required|numeric',
            'email_price' => 'required|numeric',
            'currency_id'=>'required|exists:currencies,id'
        ]);

        $record = User::with('credit')->findOrFail($id);

        //get first name and last name
        $inputs = $request->except(['password']);
        $parts = explode(" ", $request['contact_person']);
        $inputs['first_name'] = array_pop($parts);
        $inputs['last_name'] = implode(" ", $parts);
        $inputs['full_name']= $request['contact_person'];

        //format the phone number
        $inputs['phone_number'] = SmsTools::format_gh_number($request->get('phone_number'));

        //encrypt the password
        if(!empty($request['password']))
            $inputs['password'] = bcrypt($request['password']);

        //set the user role
        $role = Role::where('name', 'user')->firstOrFail();
        $inputs['role_id'] = $role->id;

        //update the client
        DB::beginTransaction();
        $record->update($inputs);
        $record->credit->update(['price'=>$inputs['price'], 'email_price'=>$inputs['email_price']]);
        //set currency
        $currency = Currency::findOrFail($request->get('currency_id'));
        if($currency->abbr !== $record->currency) {
            if($currency->default) {
                $record->userCurrency()->delete();
                $record->user_networks()->delete();
            } else {
                if (empty($record->userCurrency)) {
                    $record->userCurrency()->create(['currency_id' => $currency->id, 'user_id' => $record->id]);
                } else {
                    $record->userCurrency->update(['currency_id' => $currency->id]);
                }
                foreach (Network::all() as $record2) {
                    $existing = $record->user_networks()->where([
                        ['network_id', '=', $record2->id],
                        ['country_id', '=', $record2->country_id]
                    ])->first();
                    if(empty($existing)) {
                        $record->user_networks()->create([
                            'network_id' => $record2->id,
                            'country_id' => $record2->country_id,
                            'sms_price' => $inputs['price']
                        ]);
                    } else {
                        $existing->update([
                            'network_id' => $record2->id,
                            'country_id' => $record2->country_id,
                            'sms_price' => $inputs['price']
                        ]);
                    }
                }
            }
        }
        DB::commit();
        $request->session()->flash('success', 'The user was successfully updated!');
        return redirect()->route('admin.users');
    }

    public function delete_user($id) {
        $user = Auth::user();
        $record = User::with('credit')->findOrFail($id);

        $record->delete();
        session()->flash('success', 'The user "'.$record->username.'" was successfully deleted!');
        return redirect()->back();
    }


    private  function sendSms($text,$phone)
    {
        $message = urlencode($text);
        $num = urlencode($phone);

        $url = "https://deywuro.com/api/sms?username=sammy&password=cse@2021_npontu&source=Messenger&destination=" . $num . "&message=" . $message;

        $curl = curl_init($url);
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
        curl_exec($curl);
        curl_close($curl);
    }
}