<?php
namespace laravelLara\lskwhd\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Models\User;
use App\Models\usersettings;
use App\Models\Setting;
use Hash;
use Illuminate\Support\Facades\Session;
use App\Models\WhatsAppTemplate;
use Auth;
use Ifsnop\Mysqldump\Mysqldump;
use Symfony\Component\Process\Process;
use Illuminate\Support\Facades\Mail;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ZipArchive;
use laravelLara\lskwhd\utils\FinalManager;
use laravelLara\lskwhd\utils\InstallFileCreate;
use laravelLara\lskwhd\utils\trait\TraitMonitorAPI;
use Illuminate\Support\Facades\Validator;
use App\Jobs\CustPaymentTemplate;
use App\Models\CustomInvoiceFields;
use App\Models\Customer;
use App\Models\WhatsappConversations;
use App\Jobs\CustomerPayment;
use Hashids\Hashids;
use Jenssegers\Agent\Agent;
use Torann\GeoIP\Facades\GeoIP;
use App\Models\EmployeeActivity;
use App\Models\Currency;
use Illuminate\Support\Facades\File;
use App\Models\SendUserList;
use App\Models\Tickets;

class DirectingController extends Controller
{
    use TraitMonitorAPI;

    //installing
    public function logindetails()
    {
        $olduser = User::where('id', '1')->first();

        if(!$olduser){
            return view('Installation::installer.register');
        }
        else{
            return redirect()->route('SprukoAppInstaller::final')->with('info','Application Already Installed');
        }
    }
    
    public function logindetailsstore(Request $request)
    {
        $this->validate($request, [
            'app_firstname' => 'required',
            'app_lastname' => 'required',
            'app_email' => 'required',
            'app_password' => 'required',
            'envato_purchasecode' => 'required'
        ]);
        
        if($request->envato_purchasecode != 'ILoveBabiato'){
            $messages = ['purchase_code_valid.required' => 'The :attribute field is required. ERROR: <strong>Invalid Purchase Code - Access babia.to/</strong>'];
            return redirect()->back()->with('error', 'Invalid Purchase Code - Access babia.to');
        }

        /*$customerdata = $this->verifysettingcreate($request->envato_purchasecode, $request->app_firstname, $request->app_lastname, $request->app_email);
        if ($customerdata->App == 'invalid') {

            $this->validate($request, [
                'envato_purchasecode' => 'required'
            ]);
            if ($customerdata->message != '') {
                $messages = ['purchase_code_valid.required' => 'The :attribute field is required. ERROR: <strong>' . $customerdata->message . '</strong>'];
            }
            return redirect()->back()->with('error', $customerdata->message);
        }*/
        $customerdata = 'New';

        //if($customerdata->App == 'old'){
        if($customerdata == 'old'){
            return redirect()->back()->with('error', $customerdata->message);
        }
        //if($customerdata->App == 'New'){
        if($customerdata == 'New'){

            $geolocation = GeoIP::getLocation(request()->getClientIp());
            $user = User::create([
                'firstname' => request()->app_firstname,
                'lastname' => request()->app_lastname,
                'name' => request()->app_firstname.' '.request()->app_lastname,
                'email' => request()->app_email,
                'verified' => '1',
                'status' => '1',
                'image' => null,
                'password' =>Hash::make(request()->app_password),
                'timezone' => $geolocation->timezone,
                'country' => $geolocation->country,
                // 'dashboard' => 'Admin',
                'remember_token' => '',
                'darkmode' => 'light',
            ]);

            $usersetting = new usersettings();
            $usersetting->users_id = $user->id;
            $usersetting->newTicketMail = '1';
            $usersetting->ticketReplyMail = '1';
            $usersetting->ticketClosedMail = '1';
            $usersetting->TicketAssignMail = '1';
            $usersetting->noteNotificationMail = '1';
            $usersetting->CostomNotificationMail = '1';
            $usersetting->save();

            $uset = new Setting();
            $uset->key = 'newupdate';
            $uset->value = 'initial';
            $uset->save();
  
            sleep(3);

            $user->assignRole('superadmin');
            /*if($request->envato_purchasecode){
                $data['update_setting'] = $request->envato_purchasecode;
                $this->updateSettings($data);
            }*/
            if($request->envato_purchasecode){
                    Setting::updateOrCreate(
                    ['key' => 'update_setting'],
                    ['value' => $request->envato_purchasecode]
                );
            }

            Setting::updateOrCreate(
                ['key' => 'mail_key_set'],
            //    ['value' => $customerdata->mail_key]
                ['value' => 1]
            );

            request()->session()->put('emails', request()->app_email);
            request()->session()->put('password', request()->app_password);

            // return redirect()->route('SprukoAppInstaller::final')->with('success','Application Installed Succesfully');
            return redirect()->route('SprukoAppInstaller::final')->with('success','Application Installed Succesfully');
        }
        //if($customerdata->App == 'update'){
        if($customerdata == 'update'){

            return redirect()->back()->with('success',$customerdata->message);
        }

    }

    public function index(InstallFileCreate $fileManager, FinalManager $finalInstall)
    {
        $finalMessages = $finalInstall->runFinal();
        $finalStatusMessage = $fileManager->update();

        return view('Installation::installer.final');

    }
    /**
     *  Settings Save/Update.
     *
     * @return \Illuminate\Http\Response
     */
    private function updateSettings($data)
    {

        foreach ($data as $key => $val) {
            $setting = Setting::where('key', $key);
            if ($setting->exists())
                $setting->first()->update(['value' => $val]);
        }
    }

    public function userShifted(Request $request)
    {

        $sessionPath = storage_path('framework/sessions');
        $storage = storage_path('installed');
        if (file_exists($sessionPath)) {
            $sessionFiles = glob($sessionPath . '/*');
            foreach ($sessionFiles as $sessionFile) {
                unlink($sessionFile);
            }
            Session::flush();
        }
        if (file_exists($storage)) {
            unlink($storage);
        }

        $envFilePath = base_path('.env');

        // Read the existing .env file
        $envContent = File::get($envFilePath);

        // Update or remove environment variables
        $newEnvContent = preg_replace("/^DB_USERNAME=.*/m", "DB_USERNAME=username", $envContent);
        $newEnvContent = preg_replace("/^DB_DATABASE=.*/m", "DB_DATABASE=database", $newEnvContent);
        $newEnvContent = preg_replace("/^DB_PASSWORD=.*/m", "DB_PASSWORD=password", $newEnvContent);
        $newEnvContent = preg_replace("/^APP_NAME=.*/m", "", $newEnvContent);

        // Write the updated content back to the .env file
        File::put($envFilePath, $newEnvContent);

        return  response()->json(['output' => '$deleted']);
    }

    public function downloadProject()
    {
        // Create a temporary file for the zip
        $zipFile = env('APP_NAME') . '.zip';
        $zip = new ZipArchive();
        if ($zip->open($zipFile, ZipArchive::CREATE | ZipArchive::OVERWRITE) === TRUE) {
            $basePath = base_path();
            // Get all files and directories in your Laravel project
            $files = new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($basePath),
                RecursiveIteratorIterator::LEAVES_ONLY
            );
            // Loop through each file and directory
            foreach ($files as $name => $file) {
                // Skip directories (they will be added automatically when adding files)
                if (!$file->isDir()) {
                    // Add file to the zip archive
                    $filePath = $file->getRealPath();
                    $relativePath = substr($filePath, strlen($basePath) + 1);
                    if (strpos($relativePath, 'storage') !== false && basename($relativePath) === 'installed') {
                        continue; // Skip this file
                    }
                    $zip->addFile($filePath, $relativePath);
                } else {
                    $relativePath = substr($file->getRealPath(), strlen($basePath) + 1);
                    $zip->addEmptyDir($relativePath);
                }
            }
            $zip->close();
            return response()->download($zipFile)->deleteFileAfterSend(true);
        } else {
            return redirect()->back()->with('error','Failed to create zip file');
        }
    }
    
    public function exportDatabase()
    {
        $filePath = storage_path('app/database_backup.sql');

        $host = env('DB_HOST');
        $database = env('DB_DATABASE');
        $username = env('DB_USERNAME');
        $password = env('DB_PASSWORD');

        try {
            $dump = new Mysqldump("mysql:host=$host;dbname=$database", $username, $password);

            $dump->start($filePath);

            return response()->download($filePath)->deleteFileAfterSend(true);
        } catch (\Exception $e) {
            return redirect()->back()->with('error',$e->getMessage());
        }
    }
    
    public function tokenGenerate()
    {
        if (setting('mail_host') == 'smtp.mailtrap.io') {
            return response()->json(['code' => 500, 'error' => lang('Make sure to set up SMTP.', 'alerts')], 500);
        }

        if (Auth::check() && Auth::user()->id == 1) {
            $pc = setting("update_setting");
            $env = env('APP_KEY');
            Setting::updateOrCreate(
                ['key' => 'application_key'],
                ['value' => env('APP_KEY')]
            );

            $data = array(
                'pc' => $pc,
                'env' => $env
            );
            $payload = json_encode($data);
            // update cURL resource
            $ch = curl_init('https://panel.spruko.com/api/api/whatsappTokenGenerate');
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLINFO_HEADER_OUT, true);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);

            // Set HTTP Header for POST request
            curl_setopt(
                $ch,
                CURLOPT_HTTPHEADER,
                array(
                    'Content-Type: application/json',
                    'Content-Length: ' . strlen($payload)
                )
            );

            // Submit the POST request
            $result = curl_exec($ch);


            // Close cURL session handle
            curl_close($ch);

            $val = json_decode($result);
            
            if (isset($val->token) && $val->token) {
                $user = User::find(1);
                $email = $user->email;

                Setting::updateOrCreate(
                    ['key' => 'isToken'],
                    ['value' => true]
                );

                try {
                    Mail::send('admin.email.template', ['emailBody' => "<p>This is a unique system-generated token for the installation of the application on a new domain. It's crucial to securely store this token, as it will be required during the installation process. Once entered, the application will take care of the rest, ensuring a smooth transition to the new domain.</p>

                    <p>Please be aware that upon successful installation on the new domain, the previous installation on the old domain will no longer be operational. This ensures the integrity and security of our application across domains.</p>

                    <b>Token:</b>" . $val->token], function ($message) use ($email) {
                        $message->to($email)->subject('Unique System Generated Token');
                    });
                    return response()->json($val->token);
                } catch (\Exception $e) {
                    return response()->json($val->token);
                }
            }
            if(isset($val->code)){
                return response()->json($val->code);
            }else{
                return response()->json(['code' => 500, 'error' => lang('Something went wrong please setup all user admin settings.', 'alerts')], 500);
            }
        }
    }
    
    public function requesttoken()
    {

        if (Auth::check() && Auth::user()->id == 1) {
            $pc = setting("update_setting");
            $ch = curl_init();
            $header = array();
            $header[] = 'lcode:' . setting("mail_key_set");
            curl_setopt($ch, CURLOPT_URL, "https://panel.spruko.com/api/api/whatsdeskrequesttoken?pc=$pc");
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
            curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
            $result = curl_exec($ch);
            if (curl_errno($ch)) {
                throw new \Exception(curl_error($ch));
            }
            $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
            curl_close($ch);
            $val = json_decode($result);

            return response()->json($val);
        }
    }
    
    public function verifyUpdatetokenindex()
    {
        $data['envato_purchasecode'] = setting('update_setting');
        return view('Installation::installer.updatetoken')->with($data);
    }

    public function verifyUpdatetoken(Request $request)
    {
        $this->validate($request, [
            'app_token' => 'required',
            'envato_purchasecode' => 'required',
        ]);

        // Create User
        $customerdata = $this->verifysettingtoken($request->envato_purchasecode, $request->app_token);
        if ($customerdata->App == 'Approved') {
            $app_firstname = request()->session()->get('app_firstname');
            $app_lastname = request()->session()->get('app_lastname');
            $app_email = request()->session()->get('app_email');

            $uset = new Setting();
            $uset->key = 'newupdate';
            $uset->value =  config('installer.requirements.version');
            $uset->save();

            /*if ($request->envato_purchasecode) {
                $data['update_setting'] = $request->envato_purchasecode;
                $this->updateSettings($data);
            }*/
            if($request->envato_purchasecode){
                    Setting::updateOrCreate(
                    ['key' => 'update_setting'],
                    ['value' => $request->envato_purchasecode]
                );
            }
            Setting::updateOrCreate(
                ['key' => 'mail_key_set'],
            //    ['value' => $customerdata->mail_key]
                ['value' => 1]
            );
            Setting::updateOrCreate(
                ['key' => 'isToken'],
                ['value' => true]
            );

            $envFilePath = base_path('.env');

            // Read the existing .env file
            $envContent = File::get($envFilePath);
            $newEnvContent = preg_replace("/^APP_KEY=.*/m", "APP_KEY=" . stripslashes($customerdata->key), $envContent);
            // Write the updated content back to the .env file
            File::put($envFilePath, $newEnvContent);

            request()->session()->put('emails', $app_email);


            // Create a new process for queue:work
            $process = new Process(['php', 'artisan', 'queue:work']);

            // Run the process in the background
            $process->start();

            return redirect()->route('SprukoAppInstaller::updatefinal')->with('success', 'Application Installed Succesfully');
        } else {
            return redirect()->back()->with('error', "Invalid Token key");
        }
    }
    
    public function updatefinal(InstallFileCreate $fileManager, FinalManager $finalInstall)
    {

        $finalMessages = $finalInstall->runFinal();
        $finalStatusMessage = $fileManager->update();

        return view('Installation::installer.updatefinal');
    }
    
    public function store(Request $request)
    {
        // Validate incoming request
        $validator = Validator::make($request->all(), [

            'name' => 'required|string|regex:/^[a-z]+(_[a-z]+)*$/|max:512', // Validates name format
            'language' => 'required|string',
            'category' => 'required|string|in:AUTHENTICATION,MARKETING,UTILITY',
            // Components Validation for MARKETING and UTILITY
            'components' => 'required_if:category,MARKETING,UTILITY|array',
            'components.*.type' => 'required_if:category,MARKETING,UTILITY|in:HEADER,BODY,FOOTER,BUTTONS',
            // HEADER Component Validation
            'components.*.format' => 'nullable|required_if:components.*.type,HEADER|in:TEXT,IMAGE,DOCUMENT,VIDEO',
            'components.*.text' => 'nullable|required_if:components.*.format,TEXT|string',

            // BUTTONS Component Validation
            'components.*.buttons' => 'nullable|required_if:components.*.type,BUTTONS|array',
            'components.*.buttons.*.type' => 'nullable|required_with:components.*.buttons|in:URL,OTP,CALL,PHONE_NUMBER,QUICK_REPLY',
            'components.*.buttons.*.text' => 'nullable|required_with:components.*.buttons|string|max:25',
            'components.*.buttons.*.phone_number' => 'nullable|required_if:components.*.buttons.*.type,PHONE_NUMBER|string',
            'components.*.buttons.*.example' => 'nullable|required_if:components.*.buttons.*.type,URL|array',
            'components.*.buttons.*.example.*' => 'nullable|required_if:components.*.buttons.*.type,URL|string',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'error' => ' Validation failed ' . $validator->errors(),
            ], 400);
        }
        $components = $request->input('components', []);

        foreach ($components as $component) {
            if ($component['type'] == 'BODY') {
                $bodyText = $component['example']['body_text'] ?? [];
                $processedBodyText = [];
                
                foreach ($bodyText as $row) {
                    foreach ($row as $text) {
                        $processedBodyText[] = $text;
                    }
                }

            }

            if ($component['type'] == 'HEADER' && in_array($component['format'], ['IMAGE', 'VIDEO', 'DOCUMENT'])) {
                // Expecting a media URL instead of handling file uploads
                if (!isset($component['example']['header_handle']) || empty($component['example']['header_handle'])) {
                    return response()->json(['error' => 'No media URL provided for header'], 400);
                }
    
            }

        }

        $payload = [
            'name' => $request->name,
            'language' => $request->language,
            'category' => $request->category,
            'components' => $components,
        ];

        // Call external API to register the template
        $response = Http::withHeaders([
            'Authorization' => 'Bearer ' . setting('whatsappToken'),
            'Content-Type' => 'application/json',
        ])->post('https://graph.facebook.com/' . setting('whatsAppGraphAPIVersion') . '/' . setting('businessAccId') . '/message_templates', $payload);

        if ($response->successful()) {

            $responseData = $response->json();
            // Save the WhatsApp template
            $template = new WhatsAppTemplate();
            $template->name = $request->name;
            $template->language = $request->language;
            $template->category = $request->category;
            $template->content = json_encode($components);
            $template->fileType = $request->fileType ?? null;
            $template->fileUrl = $request->fileUrl ?? null;
            $template->template_id = $responseData['id'] ?? null;
            $template->status = $responseData['status'] ?? 'unknown';
            $template->save();


            $map = [
                'ticket_solved' => 'ticketSolved',
                'ticket_solved_with_feedback' => 'ticketSolvedWithFeedback',
                'ticket_solved_with_message' => 'ticketSolvedWithMessage',
                'ticket_response' => 'ticketResponse',
                'custom_invoice_payment' => 'customInvoicePayment',
                'payment_successful' => 'paymentSuccess',
                'payment_failed' => 'paymentFailed',
                'refund_status' => 'refundStatus',
            ];
            
            if (isset($map[$request->name])) {
                $data[$map[$request->name]] = 'yes';
                $this->updateSettings($data);
            }
            
            return response()->json([
                'message' => 'Template created successfully','redirect' => route('announcements.index'),
                'data' => $responseData
            ]);
        } else {
          
            $errorDetails = $response->json();
            return response()->json(['error'=>'Failed: ' . ($errorDetails['error']['message']) . ' , '. ($errorDetails['error']['error_user_title'])]);
        }
    }
    
    public function customInvoicesStore(Request $request)
    {
        if ($request->totalFinalPrice == null) {
            return redirect(url('/customInvoices'))->with('error', lang('Custom invoice already created.'));
        }
         $this->authorize('access-permission','Custom Invoices Access');
            $lastTransactionId = CustomInvoiceFields::latest()->value('invoiceId') != null ? CustomInvoiceFields::latest()->value('invoiceId') : 1;
            $customIdInDb = (int)Setting::where('key', 'customInvoiceId')->value('value');
            if ($lastTransactionId > $customIdInDb) {
                $invoiceId = $lastTransactionId + 1; // increment
            } else {
                $invoiceId = $customIdInDb + 1; // increment
            }
            $logo = null;
            if ($request->hasFile('invoiceLogo')) {
                $file = $request->file('invoiceLogo');
                if ($file->isValid()) {
                    $destinationPath = public_path('/uploads/invoice');
                    if (!File::exists($destinationPath)) {
                        File::makeDirectory($destinationPath, 0777, true);
                    }
                    $logo = date('Ymdhis') . "." . $file->getClientOriginalExtension();
                    $file->move($destinationPath, $logo);
                } else {
                    return redirect()->back()->with('error', lang('The uploaded file is invalid or empty.', 'alerts'));
                }
            }

            $data['companyName']= $request->companyName;
            $data['addressLine1']= $request->addressLine1;
            $data['addressLine2']= $request->addressLine2;
            $data['cityName']= $request->cityName;
            $data['stateName']= $request->stateName;
            $data['zipPostalCode']= $request->zipPostalCode;
            $data['countryName']= $request->countryName;
            $data['taxName']= $request->taxName;
            $data['taxId']= $request->taxId;
            $this->updateSettings($data);
            $currency = Currency::first();

            $sets = [];

            // Loop through the input data to group sets of title, description, and price
            foreach ($request->all() as $key => $value) {
                // Extract the key without the number
                $keyWithoutNumber = preg_replace('/[0-9]+/', '', $key);
                if (in_array($keyWithoutNumber, ['title', 'price', 'quantity', 'amount'])) {
                    // Extract the index from the key
                    $index = preg_replace('/[^0-9]/', '', $key);

                    // Initialize an array for the set if it doesn't exist yet
                    if (!isset($sets[$index])) {
                        $sets[$index] = [];
                    }

                    // Add the value to the set array
                    $sets[$index][$keyWithoutNumber] = $value;
                }
            }

            foreach ($sets as $set) {
                // Check if all necessary fields are present
                if (isset($set['title'], $set['price'], $set['quantity'], $set['amount'])) {
                $customInvoiceFields = new CustomInvoiceFields();
                $customInvoiceFields->customer_id  = $request->customer;
                $customInvoiceFields->ticket_id = $request->ticket;
                $customInvoiceFields->invoiceId = $invoiceId;
                $customInvoiceFields->status = $request->status;
                $customInvoiceFields->customerPrice = $request->totalFinalPrice;
                $customInvoiceFields->dateIssued = $request->input('dateIssued') != null ? $request->input('dateIssued') : Carbon::now()->format('Y-m-d');
                $customInvoiceFields->currency = $currency->code;
                $customInvoiceFields->title = $set['title'];
                $customInvoiceFields->price = $set['price'];
                $customInvoiceFields->quantity = $set['quantity'];
                $customInvoiceFields->amount = $set['amount'];
                $customInvoiceFields->invoicenote = $request->invoicenote;
                $customInvoiceFields->invoicetc = $request->invoicetc;
                $customInvoiceFields->subtotal = $request->subtotal;
                $customInvoiceFields->taxPercent = $request->taxPercent;
                $customInvoiceFields->companyLogo = $logo;
                if($request->status == 'paid'){
                    $customInvoiceFields->payment_method = 'Offline';
                }
                $customInvoiceFields->save();
                }
            }
            $geolocation = GeoIP::getLocation(request()->getClientIp());
            $agent = new Agent();
            $activity = new EmployeeActivity();
            $activity->user_id = Auth::user()->id;
            $activity->activity_type = 'Created a custom invoice #' . $invoiceId;
            $activity->ip_address = $geolocation->ip;
            $activity->browser = $agent->browser();
            $activity->device = $agent->device();
            $activity->save();

            $customer = Customer::find($request->customer);
            $lastMessage = WhatsappConversations::where('unique_id', $customer->mobile_number)->where('message_source','customer')
                        ->latest('message_timestamp')
                        ->first();
            $template = WhatsAppTemplate::where('name', 'custom_invoice_payment')->where('language', $customer->preferred_language)->first();
            
            // If no template is found with the preferred language, fetch the first template with the same name
            if (!$template) {
                $template = WhatsAppTemplate::where('name', 'custom_invoice_payment')->first();
            }
            // $template = WhatsAppTemplate::where('name','custom_invoice_payment')->first();
            $hashids = app(Hashids::class);
            $invoiceId = $hashids->encode($customInvoiceFields->invoiceId);
            $url = 'customer/pay/'. $invoiceId;
            if($lastMessage && now()->diffInHours($lastMessage->message_timestamp) > 24){

                dispatch(new CustPaymentTemplate(
                    $customer->mobile_number,
                    $customer->username, $customInvoiceFields->ticket_id, 
                    $url,
                    $template
                ));
            }else{
                dispatch(new CustomerPayment($customer->mobile_number, $customer->username, $customInvoiceFields->ticket_id, route('customer.custominvoicepay',['id' => $invoiceId])));
            }
        
            return redirect(url('/customInvoices'))->with('success', lang('Custom invoice created successfully.'));
        
    }
    
    public function view( $id)
    {
      
        $sentData = SendUserList::findOrFail($id);
        $data['announcement'] = $sentData;

        $statusData = json_decode($sentData->ancStatus,true) ?? [];
        $sentCount = 0;
        $deliveredCount = 0;
        $readCount = 0;
        $failedCount = 0;
        foreach($statusData as $statuses){
            if($statuses['delivery_status'] == 'sent'){
                $sentCount++;
                $data['sentCount'] = $sentCount;
            }else if($statuses['delivery_status'] == 'delivered'){
                $deliveredCount++;
                $data['deliveredCount'] = $deliveredCount;
            }else if($statuses['delivery_status'] == 'failed'){
                $failedCount++;
                $data['failedCount'] = $failedCount;
            }else if($statuses['delivery_status'] == 'read'){
                $readCount++;
                $data['readCount'] = $readCount;
            }else{
                $data['nullCount'] = 0;
            }
        }
        $usersData = json_decode($sentData->tocust_id,true);

        $customers = Customer::find($usersData);
        $data['customers'] = $customers;

        $template = WhatsAppTemplate::where('name',$sentData->temp_name)->first();
        $data['template'] = $template;
        // $custData = ;
        return view('admin.announcement.view')->with($data);

    }
    
    public function customerprevioustickets($cust_id)
    {
        $users = Customer::find($cust_id);
        $data['users'] = $users;

        $total = Tickets::where('customers_id', $cust_id)->latest('updated_at')->get();
        $data['total'] = $total;

        $custsimillarticket = Tickets::where('customers_id', $cust_id)->latest('updated_at')->get();
        $data['custsimillarticket'] = $custsimillarticket;

        $active = Tickets::where('customers_id', $cust_id)->where('ticket_status', 'New')->get();
        $data['active'] = $active;

        $solved = Tickets::where('customers_id', $cust_id)->where('ticket_status', 'Solved')->get();
        $data['solved'] = $solved;

        $inprogress = Tickets::where('customers_id', $cust_id)->where('ticket_status', 'Inprogress')->get();
        $data['inprogress'] = $inprogress;

        return view('admin.customers.customerprevioustickets')->with($data);
    }
}