<?php

namespace Modules\Customer\Http\Controllers;
use App\Models\Order;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Modules\Customer\Http\Requests\ProfileRequest;
use Modules\Customer\Http\Requests\CreateAddressRequest;
use Modules\Customer\Entities\CustomerAddress;
use Modules\Customer\Rules\MatchOldPassword;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
use App\Traits\ImageStore;
use Illuminate\Support\Facades\File;
use Modules\Customer\Services\CustomerService;
use App\Repositories\UserRepository;
use Brian2694\Toastr\Facades\Toastr;
use Modules\Setup\Entities\Country;
use Exception;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Modules\UserActivityLog\Traits\LogActivity;
use Yajra\DataTables\Facades\DataTables;
use Modules\Subscription\Entities\UserCredit;
use Modules\Subscription\Entities\UserCreditHistory;
use Modules\Customer\Services\AugmentationService;
use Modules\WTIJobBoard\Services\JobRequestCategoriesService;
use Modules\Subscription\Entities\CustomerSubscription;
use Modules\Subscription\Entities\SubscriptionPlan;
use Modules\Customer\Entities\TransferAccountHistory;
use Modules\Customer\Http\Requests\UpdateCompanyInfoRequest;
use Modules\Customer\Entities\UserCompany;
use Modules\Customer\Entities\UserAdditionalContact;

class CustomerController extends Controller
{
    use ImageStore;
    protected $customerService;

    public function __construct(CustomerService  $customerService)
    {
        $this->middleware(['auth','maintenance_mode']);
        $this->middleware(['prohibited_demo_mode'])->only('updatePassword');
        $this->customerService = $customerService;
        $this->categoryService = new JobRequestCategoriesService();
    }

    public function customer_index()
    {   
        new AugmentationService();
        return view('customer::customer');
    }

    public function customer_index_get_data(){

        $customers = $this->customerService->getAll()->get();
        $subscription_plans = SubscriptionPlan::orderBy('order')->get();
        foreach ($subscription_plans as $key => $plan) {

            $total_subscribers = CustomerSubscription::whereRelation('planPrice.plan', 'title', $plan->title)->where('status','active')->count();

            $statistics['subscriptions'][$plan->title] = [
                'plan_image' => $plan->image_url,
                'total_subscribers' => $total_subscribers
            ];   
        }


        $statistics['total_active'] = User::whereHas('role', function($query){
            return $query->where('type', 'customer');
        })->where('is_active',1)->count();
        $statistics['total_inactive'] = User::whereHas('role', function($query){
            return $query->where('type', 'customer');
        })->where('is_active',0)->count();

        $statistics['total_subscribers'] = CustomerSubscription::where('status','active')->count();
        $statistics['total_nonsubscribers'] = $statistics['total_active'] - $statistics['total_subscribers'];

        return response()->json([
            'customers' => $customers,
            'statistics' => $statistics
        ]);
    }


    public function transferHistory()
    {   
        $history = TransferAccountHistory::with(['transferBy.company','transferFrom.company','transferTo.company'])->latest('id')->get();
        return view('customer::transfers')->with('history',$history);
    }


    public function profile(ProfileRequest $request)
    {
         try {
             $customer_id=auth()->user()->id;
             $address_type=$request['address_type'];
             $match_data=['customer_id'=> $customer_id,'address_type' => $address_type];
             $form_data=[
                'name' => $request['name'],
                'address_one'=> $request['address_one'],
                'address_two' => $request['address_two'],
                'email' => $request['email'],
                'phone' => $request['phone'],
                'city' => $request['city'],
                'state' => $request['state'],
                'country' => $request['country'],
                'postal_code' => $request['postal_code']
             ];
             $data=CustomerAddress::updateOrCreate($match_data,$form_data);
             LogActivity::successLog('profile update');
             return response()->json($data);

         } catch (Exception $e) {
             LogActivity::errorLog($e->getMessage());
             Toastr::error(__('common.error_message'));
            return back();
         }
    }


    public function updatePassword(Request $request)
    {
        $request->validate([
            'current_password' => ['required', new MatchOldPassword],
            'new_password' => 'required|min:8',
            'new_password_confirmation' => 'same:new_password',
        ]);
        try {
            User::find(auth()->user()->id)->update(['password'=> Hash::make($request->new_password)]);
            LogActivity::successLog('customer password update');
            return response()->json(__('common.updated_successfully'));
        } catch (Exception $e) {
            LogActivity::errorLog($e->getMessage());
            Toastr::error(__('common.error_message'));
            return back();
        }
    }

    public function create(){
        return view('customer::customers.create');
    }

    public function store(Request $request){
        $request->validate([
            'first_name' => 'required|max:255',
            'last_name' => 'nullable|max:255',
            'email' => ['required', 'string', 'max:255', 'unique:users,email', 'check_unique_phone'],
            'phone' => 'required|max:255',
            'password' => 'required|confirmed|min:8',
            //'referral_code' => ['sometimes', 'nullable', Rule::exists('referral_codes', 'referral_code')->where('status', 1)],
            'is_active' => 'required',
            'storefront' => 'required',
            'company_name' => 'required',
            'brand_name' => 'required',
            'company_address' => 'required',
            'referrer_id' => 'sometimes|nullable|exists:users,id'
        ]);

        
        try{
            $user = $this->customerService->store($request);

            if($user){
                return response()->json([
                    'message' => 'Customer Created Successfully.'
                ]);
            }
            
        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function edit($id){
        $customer = $this->customerService->find($id);
        return view('customer::customers.edit', compact('customer'));
    }

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

        $request->validate([
            'first_name' => 'required|max:255',
            'last_name' => 'nullable|max:255',
            'email' => ['required', 'string', 'max:255', 'unique:users,email,'.$id],
            'phone' => 'required|max:255',
            'password' => 'sometimes|nullable|confirmed|min:8',
            'is_active' => 'sometimes|boolean',
            'referrer_id' => 'sometimes|nullable|exists:users,id'
        ]);

        try{

            $user = $this->customerService->update($request, $id);

            if($user){
                return response()->json([
                    'customer' => $user->load('company','additionalContacts'),
                    'message' => 'Customer Updated Successfully.'
                ]);
            }
        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function updateCompany($id, UpdateCompanyInfoRequest $request)
    {
        try{
            
            $user = $this->customerService->find($id);
            if($user){

                $company = UserCompany::updateOrCreate(
                    [
                        'user_id' => $user->id,
                    ],
                    [
                        'company_name' => $request->company_name,
                        'brand_name' => $request->brand_name,
                        'storefront' => $request->storefront,
                        'company_address' => $request->company_address,
                        'accounts_payable_name' => $request->accounts_payable_name,
                        'accounts_payable_email' => $request->accounts_payable_email,
                        'marketing_contact_name' => $request->marketing_contact_name,
                    ]
                );

                // foreach ($request->additional_contacts as $key => $additional_contact) {

                //     $contact = UserAdditionalContact::updateOrCreate(
                //         [   
                //             'id' => $additional_contact['id'] ?? null
                //         ],
                //         [
                //             'user_id' => $user->id,
                //             'name' => $additional_contact['name'],
                //             'email' => $additional_contact['email'],
                //             'position' => $additional_contact['position'],
                //         ]
                //     );
                // }

                // $contactsId = collect($request->additional_contacts)->pluck('id')->toArray();
                // $user->additionalContacts()
                //     ->whereNotIn('id', $contactsId)
                //     ->delete();

                return response()->json([
                    'customer' => $user->load('company', 'additionalContacts'),
                    'message' => 'Company Updated Successfully.'
                ]);
            }

        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function updateCredits($id, Request $request)
    {
        $request->validate([
            'subscription_credits' => 'required',
            'alacarte_credits' => 'required',
            'notes' => 'nullable'
        ]);

        try {
            
            $data = [];
            $credits = $this->customerService->credits($id);
            $data['subscription_credits'] = $request->subscription_credits + $credits['total_used_credits']['subscription'];
            $data['alacarte_credits'] = $request->alacarte_credits + $credits['total_used_credits']['alacarte'];

            $user_credits = UserCredit::updateOrCreate(
                ['user_id' =>  $id],
                $data
            );

            $updatedCredits = $this->customerService->credits($id);
            UserCreditHistory::create([
                'user_id' => $id,
                'subscription_credits_from' => $credits['total_available_credits']['subscription'],
                'subscription_credits_to' => $updatedCredits['total_available_credits']['subscription'],
                'alacarte_credits_from' => $credits['total_available_credits']['alacarte'],
                'alacarte_credits_to' => $updatedCredits['total_available_credits']['alacarte'],
                'details' => $request->notes
            ]);

            return response()->json([
                'message' => 'Content Credits Updated Successfully.'
            ]);


        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function updateStatus($id, Request $request)
    {
        try {

            $user = $this->customerService->find($id);
            if($user){
                $user->is_active = !$user->is_active;
                $user->save();

                return response()->json([
                    'message' => 'User Active Status Updated Successfully'
                ]);
            }

        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function contact($id, Request $request)
    {
        $request->validate([
            'send_to' => 'required|array',
            'subject' => 'required',
            'reply_to' => 'required|email',
            'message' => 'required'
        ]);

        try {
            
            $sent = $this->customerService->contact($request, $id);

            if($sent){
                return response()->json([
                    'message' => 'Email Successfully Sent!'
                ]);
            }
            
        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }


    public function notes($id, Request $request)
    {
        $request->validate([
            'notes' => 'nullable'
        ]);

        try {
            
            $user = $this->customerService->find($id);
            if($user){
                $user->admin_notes = $request->notes;
                $user->save();

                return response()->json([
                    'message' => 'Notes Successfully Save!'
                ]);
            }
            
        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function transfer($id, Request $request)
    {
        $request->validate([
            'transfer_to' => 'required'
        ]);

        try {

            if($id == $request->transfer_to){
                return response()->json([
                    'message' => 'Cannot Transfer to the same account!'
                ], 500);
            }
            
            $sent = $this->customerService->transfer($request, $id);

            if($sent){
                return response()->json([
                    'message' => 'Account Successfully Transferred!'
                ]);
            }
            
        } catch(Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function destroy(Request $request, $id){
        $result = $this->customerService->destroy($id);
            if($result === true){
                Toastr::success(__('common.deleted_successfully'), __('common.success'));
            }else{
                Toastr::warning(__('hr.deleted_not_possible_for_this_customer'), __('common.warning'));
            }
            return redirect()->route('cusotmer.list_active');
        try{
            $result = $this->customerService->destroy($id);
            if($result === true){
                Toastr::success(__('common.deleted_successfully'), __('common.success'));
            }else{
                Toastr::warning(__('hr.deleted_not_possible_for_this_customer'), __('common.warning'));
            }
            return redirect()->route('cusotmer.list_active');


        }catch(Exception $e){
            LogActivity::errorLog($e->getMessage());
            Toastr::error(__('common.error_message'), __('common.error'));
            return back();
        }
    }

    public function show($id)
    {   
        $data['customer'] = $this->customerService->find($id);
        $data['credits'] = $this->customerService->credits($id);
        $data['credits_history'] = $this->customerService->credits_history($id);
        $data['categories'] = $this->categoryService->all(['active' => 1]);
        $data['subscriptions'] = $this->customerService->subscriptions($id);
        $data['job_requests'] = $this->customerService->jobs($id);
        $data['orders'] = $this->customerService->orders($id);
        $data['referrals'] = $this->customerService->referrals($id);
        $data['members'] = $this->customerService->membersDropdown();
        return view('customer::customer_details', $data);
    }

    public function getOrders($id){
        $customer = $this->customerService->find($id);
        $order = $customer->orders;

        return DataTables::of($order)
            ->addIndexColumn()
            ->addColumn('date', function($order){
                return date(app('general_setting')->dateFormat->format, strtotime($order->created_at));
            })
            ->addColumn('number_of_product',function($order){
                return  getNumberTranslate($order->packages->sum('number_of_product'));

            })
            ->addColumn('total_amount',function($order){
                return  single_price($order->grand_total);

            })
            ->addColumn('order_status', function($order){
                return view('customer::customers.components._show_order_status_td',compact('order'));

            })
            ->addColumn('is_paid', function($order){
                return view('customer::customers.components._show_order_is_paid_td',compact('order'));
            })

            ->addColumn('action',function($order){
                return view('customer::customers.components._show_order_action_td',compact('order'));
            })
            ->rawColumns(['order_status','is_paid','action'])
            ->make(true);
    }

    public function getWalletHistory($id){
        $customer = $this->customerService->find($id);
        $transaction = $customer->wallet_balances;
        return DataTables::of($transaction)
            ->addIndexColumn()
            ->addColumn('date', function($transaction){
                return date(app('general_setting')->dateFormat->format, strtotime($transaction->created_at));
            })
            ->addColumn('user',function($transaction){
                return  $transaction->user->first_name;

            })
            ->addColumn('amount',function($transaction){
                return  single_price($transaction->amount);

            })
            ->addColumn('payment_method', function($transaction){
                return $transaction->GatewayName;

            })
            ->addColumn('approval', function($transaction){
                return view('customer::customers.components._wallet_approval_td',compact('transaction'));
            })
            ->rawColumns(['approval'])
            ->make(true);
    }


    public function updateInfo(Request $request)
    {
                        if (isModuleActive('StaffPortal')) {
                            $ret = app(\Modules\StaffPortal\Services\CommonService::class)->updateInfo($request);
                            if ($ret) {
                                return response()->json($ret);
                            }
                            else {
                                return back();
                            }
                        }
                        
        $request->validate([
            'first_name' => 'required',
            'email' => 'required|email|unique:users,email,'.auth()->user()->id,
            'avatar' => 'nullable|mimes:jpeg,jpg,png,bmp',
            'phone' => 'nullable|unique:users,username,'.auth()->id()
        ]);
        try {
            $user=User::findOrFail(auth()->user()->id);
            $data=[
                'first_name' => $request->first_name,
                'last_name'  => $request->last_name,
                'email'      => $request->email,
                'phone'      => $request->phone,
                'username'      => $request->phone,
                'date_of_birth' => $request->date_of_birth?date('Y-m-d',strtotime($request->date_of_birth)):null,
                'description'  => $request->description
             ];
             $file = $request->file('avatar');
             if ($request->hasFile('avatar')) {
                 if ($user->avatar) {
                     if (File::exists($user->avatar)) {
                          File::delete($user->avatar);
                      }
                 }
                 $data['avatar']=$this->saveImage($file,200,200);
             }
            $user->update($data);
            LogActivity::successLog('update info');
            return response()->json($user);
        } catch (Exception $e) {
            LogActivity::errorLog($e->getMessage());
            Toastr::error(__('common.error_message'), __('common.error'));
            return back();
        }
    }
    public function storeAddress(CreateAddressRequest $request)
    {
        try {
            $data=[
                'customer_id'=>auth()->user()->id,
                'name'=>$request->name,
                //'email'=>$request->email,
                'address'=>$request->address,
                'phone'=>$request->phone,
                'city'=>$request->city,
                'state'=>$request->state,
                'country'=>$request->country,
                'postal_code'=>$request->postal_code
            ];
            if(isset($request->shipping_address)){
                CustomerAddress::where('is_shipping_default',1)->update(['is_shipping_default'=> 0]);
                $data['is_shipping_default'] = 1;
            }
            if(isset($request->billing_address)){
                CustomerAddress::where('is_billing_default',1)->update(['is_billing_default'=> 0]);
                $data['is_billing_default'] = 1;
            }
            if(!is_numeric($request->city)){
                $data['city'] = DB::table('cities')->insertGetId(
                    ['name' => $request->city,'state_id' => $request->state]
                );
            }
            $customer=CustomerAddress::create($data);
            $list=CustomerAddress::where('customer_id',$customer->customer_id)->get();
            if(count($list)<=1){
                $setDefaltData=CustomerAddress::find($customer->id);
                $setDefaltData->is_shipping_default=1;
                $setDefaltData->is_billing_default=1;
                $setDefaltData->save();
            }
            LogActivity::successLog('address added');
            return  $this->loadTableData();
        } catch (Exception $e) {
            LogActivity::errorLog($e->getMessage());
            Toastr::error(__('common.error_message'));
            return back();
        }
    }
    public function updateAddress(CreateAddressRequest $request){
        try {
            $data = [
                'name'=>$request->name,
                //'email'=>$request->email,
                'address'=>$request->address,
                'phone'=>$request->phone,
                'city'=>$request->city,
                'state'=>$request->state,
                'country'=>$request->country,
                'postal_code'=>$request->postal_code
            ];
            if(isset($request->shipping_address)){
                CustomerAddress::where('is_shipping_default',1)->first()->update(['is_shipping_default'=> 0]);
                $data['is_shipping_default'] = 1;
            }
            if(isset($request->billing_address)){
                CustomerAddress::where('is_billing_default',1)->first()->update(['is_billing_default'=> 0]);
                $data['is_billing_default'] = 1;
            }
            if(!is_numeric($request->city)){
                $data['city'] = DB::table('cities')->insertGetId(
                    ['name' => $request->city,'state_id' => $request->state]
                );
            }
            $customer = CustomerAddress::findOrFail($request->address_id);
            $customer->update($data);
            LogActivity::successLog('update address');
            return  $this->loadTableData();
        } catch (Exception $e) {
            LogActivity::errorLog($e->getMessage());
            Toastr::error(__('common.error_message'));
            return back();
        }
    }

    public function setDefaultShipping(Request $request)
    {
       CustomerAddress::where('customer_id',$request->c_id)->update(['is_shipping_default'=> 0]);
       $customer=CustomerAddress::find($request->c_list_id);
       $customer->is_shipping_default=1;
       $customer->save();
       LogActivity::successLog('set default shipping.');
       return  $this->loadTableData();
    }
    public function setDefaultBilling(Request $request)
    {
       CustomerAddress::where('customer_id',$request->c_id)->update(['is_billing_default'=> 0]);
       $customer=CustomerAddress::find($request->c_list_id);
       $customer->is_billing_default = 1 ;
       $customer->save();
       LogActivity::successLog('set default billing.');
       return  $this->loadTableData();
    }

    public function editAddress($c_id){
        try {
            $address=CustomerAddress::findOrFail($c_id);
            $countries = Country::where('status', 1)->orderBy('name')->get();
            if (auth()->user()->role->type != 'customer') {
                return view('backEnd.pages.customer_data._edit_address_form',compact('address', 'countries'));
            }
            else {
                return view(theme('pages.profile.partials._edit_form'),compact('address', 'countries'));
            }

        } catch (Exception $e) {
            LogActivity::errorLog($e->getMessage());

            Toastr::error(__('common.operation_failed'));
            return back();
        }
    }

    public function deleteAddress(Request $request){
        try{
            $addressExist = Order::where('customer_id',auth()->user()->id)->where('customer_shipping_address', $request->id)->orWhere('customer_billing_address', $request->id)->first();
            if (!$addressExist) {
                $customer_address = CustomerAddress::where('id',$request->id)->where('customer_id', auth()->user()->id)->first();
                if($customer_address->is_shipping_default == 1 || $customer_address->is_billing_default == 1){
                    return 'is_default';
                }
                $customer_address->delete();
                LogActivity::successLog('address deleted');
                return $this->loadTableData();
            }else{
                return 'is_used';
            }

        }catch (\Exception $e) {
            LogActivity::errorLog($e->getMessage());
            return $e->getMessage();
        }
    }

    private function loadTableData()
    {
        try {
            $addressList=CustomerAddress::where('customer_id',auth()->user()->id)->get();
            return response()->json([
                'addressList' =>  (auth()->user()->role->type != 'customer') ?(string)view('backEnd.pages.customer_data._table',compact('addressList')) : (string)view(theme('pages.profile.partials._table'),compact('addressList')),
                'addressListForShipping' =>  (auth()->user()->role->type != 'customer') ?(string)view('backEnd.pages.customer_data._shipping_address',compact('addressList')) : (string)view(theme('pages.profile.partials._shipping'), compact('addressList')),
                'addressListForBilling' =>  (auth()->user()->role->type != 'customer') ?(string)view('backEnd.pages.customer_data._billing_address',compact('addressList')) : (string)view(theme('pages.profile.partials._billing'), compact('addressList')),
            ]);

        } catch (\Exception $e) {
            LogActivity::errorLog($e->getMessage());
            return back();
        }
    }

    public function update_active_status(Request $request)
    {
        try {
            $userRepo = new UserRepository;
            $userRepo->statusUpdate($request->all());
            LogActivity::successLog('customer update active status');
            return 1;
        } catch (\Exception $e) {
            LogActivity::errorLog($e->getMessage());
            return 0;
        }
    }
    public function customerBulkUpload()
    {
        try {
            return view('customer::customers.bulk_upload');
        } catch (\Exception $e) {
            LogActivity::errorLog($e->getMessage());
            return 0;
        }
    }
    public function customerBulkUploadStore(Request $request)
    {
        $request->validate([
            'file' => 'required|mimes:csv,txt,xls,xlsx|max:2048'
        ]);
        ini_set('max_execution_time', 0);
        DB::beginTransaction();
        try {
            $this->customerService->BulkUploadStore($request->except('_token'));
            DB::commit();
            Toastr::success(__('common.created_successfully'), __('common.success'));
            LogActivity::successLog('Customer Bluk Upload Successfully.');
            return back();
        } catch (\Exception $e) {
            DB::rollBack();
            if ($e->getCode() == 23000) {
                Toastr::error(__('common.duplicate_entry_is_exist_in_your_file'));
            } else {
                Toastr::error(__('common.error_message'));
            }
            LogActivity::errorLog($e->getMessage());
            return back();
        }
    }
}