<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\User;
use App\HomePage;
use App\DoctorsHomePage;
use App\PageContent;
use App\PageModule;
use Storage;
use Auth;
use Carbon\Carbon;
use Config;
use DB;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Support\Facades\Validator;
use Illuminate\Database\QueryException;
use App\ClientLogo;
use App\Library\S3Library;
use Throwable;
use App\Http\Resources\UserCollection;

class HomePageController extends Controller
{
    public function updateBanner(Request $request, S3Library $S3Library)
    {
        try {
            $rules = [               
                'banner_image' => 'required',   
            ];
            $messages = [
                'banner_image.required' => __('digimed_validation.form_validation_error.banner_image_required'),
                
            ];
            $validator = Validator::make($request->all(), $rules, $messages);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());
            } 

            $bannerImage = HomePage::firstOrNew(['id' => 1]);

            if ($request->hasFile('banner_image')) {
                $file = $request->file('banner_image');
                $uploadPath = 'digimed/images/home-page/banner/1/';

                $uploadedImage = $S3Library->fileUpload(true, 'jpeg|JPEG|jpg|JPG|png|PNG|gif|svg', true, $file, $uploadPath);
               
                if ($uploadedImage['code'] == 500) {
                    return response()->json([
                        'code' => 500,
                        'message' => __('digimed_validation.image_upload_error', ['error' => $uploadedImage['msg']]),
                    ], 500);
                }

                if ($uploadedImage['code'] == 200) {
                    $bannerImage->banner_image = $uploadedImage['data'];
                }
            }

            $bannerImage->save();

            return self::sentResponse(200, [], __('digimed_validation.success_response.banner_image_success'));
        }catch(Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    // Fetch Banner
    public function fetchBannerImage(Request $request)
    {
        try {
            
            $bannerImage = HomePage::where('id',1)->first();
            if (!$bannerImage) {
                $data[] = [
                    'id' => '',
                    'banner_image' => '',
                ];
            } else {

                // Build the response as an array
                $data[] = [
                    'id' => $bannerImage->id,
                    'banner_image' => $bannerImage->banner_image,
                ];
            }
        
            // $data['banner_image'] = $bannerImage->banner_image;
            return self::sentResponse(200,$data, __('digimed_validation.success_response.data_fetch_success'));

        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }


    public function uploadClientLogo(Request $request, S3Library $S3Library)
    {
        try {
            $rules = [               
                'logo' => 'required',
                'title' => 'required'   
            ];
            $messages = [
                'logo.required' => __('digimed_validation.form_validation_error.lab_logo_required'),
                'title.required'=> __('digimed_validation.form_validation_error.title_required'),
            ];
            $validator = Validator::make($request->all(), $rules, $messages);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());
            } 
                  
            if ($request->hasFile('logo')) {
                   
                $files = $request->file('logo'); // Multiple file input
                $titles = explode(',',$request->title);
                
                foreach ($files as $key => $file) { 
                                       
                    $uploadPath = 'digimed/images/clients/logo/1/';
                    $uploadedDoc = $S3Library->fileUpload(true, 'jpeg|JPEG|jpg|JPG|png|PNG|gif|svg|pdf|PDF|txt|doc|DOC|docx|DOCX', true, $file, $uploadPath);
                      
                    if ($uploadedDoc['code'] === 500) {
                        DB::rollback();
                        return self::sentResponse(500, $uploadedDoc['data'], $uploadedDoc['msg']);
                    }
        
                    if ($uploadedDoc['code'] === 200) {                    
                        $clientLogo = new ClientLogo();
                        $clientLogo->logo = $uploadedDoc['data'];
                        $clientLogo->title = $titles[$key];
                  
                        $clientLogo->save();
                    }
                }
                
            }
            return self::sentResponse(200, [], __('digimed_validation.success_response.client_logo_store_success'));
    
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    //delete Image document
    public function deleteClientLogoDocument(Request $request)
    {
        try {
            $rules = [               
                'id' => 'required',
               
            ];
            $messages = [
                'id.required' => __('digimed_validation.form_validation_error.upload_doc_id_req'),
               
            ];
            $validator = Validator::make($request->all(), $rules, $messages);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());   
            } 
            $clientLogo = ClientLogo::find($request->id);
            if (!$clientLogo) {
                return self::sentResponse(201, [], __('digimed_validation.error_response.records_not_found'));
            }
         
            if(Config::get('filesystems.default') == "s3") {
                Storage::disk('s3')->delete('digimed/images/clients/logo/1/'.$clientLogo['logo']);
            } else {
                Storage::delete('digimed/images/clients/logo/1/'.$clientLogo['logo']);
            }

            if($clientLogo->delete()){
                return self::sentResponse(200, [], __('digimed_validation.success_response.data_delete_success'));               
            }

        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    //Fetch client logos
    public function fetchClientLogo(Request $request, S3Library $S3Library)
    {
        try {
                            
            $clientLogo = ClientLogo::select('id', 'title', 'logo')->whereNull('deleted_at')->get();
            
            if ($clientLogo->isEmpty()) {
                return self::sentResponse(201, [], __('digimed_validation.error_response.records_not_found'));
            }

            return self::sentResponse(200, $clientLogo->toArray(), __('digimed_validation.success_response.data_fetch_success'));
    
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    //Doctors Home Page

    public function updateDoctor(Request $request, S3Library $S3Library)
    {
    try {
        // Validation Rules
        $rules = [               
            'id' => 'sometimes|integer',
            'name' => 'required',
            'rating' => 'required',
            'specialization' => 'required',
            // 'doctor_image' => 'nullable|file|mimes:jpeg,jpg,png,gif,svg',
            'language_spoken' => 'required'   
        ];
        
        $messages = [
            'name.required' => __('digimed_validation.form_validation_error.doctor_name_req'),
            'specialization.required' => __('digimed_validation.form_validation_error.specialization_req'),
            // 'doctor_image.required' => __('digimed_validation.form_validation_error.doctor_image_req'),
            'language_spoken.required' => __('digimed_validation.form_validation_error.language_spoken_req'),
        ];
        
        // Validate the Request
        $validator = Validator::make($request->all(), $rules, $messages);
        
        if ($validator->fails()) {
            return self::errorResponse(422, $validator->errors()->all());
        }

        // Check if ID exists and fetch or create a new record
        $doctorImage = DoctorsHomePage::updateOrCreate(
            ['id' => $request->id], // Search condition
            [
                'name' => $request->name,
                'specialization' => $request->specialization,
                'language_spoken' => $request->language_spoken,
                'rating' => $request->rating, // Default rating
            ]
        );

        // Handle Doctor Image Upload
        if ($request->hasFile('doctor_image')) {
            $file = $request->file('doctor_image');
            $uploadPath = 'digimed/images/home-page/doctor_image/';

            $uploadedImage = $S3Library->fileUpload(
                true,
                'jpeg|JPEG|jpg|JPG|png|PNG|gif|svg',
                true,
                $file,
                $uploadPath
            );

            if ($uploadedImage['code'] == 500) {
                return response()->json([
                    'code' => 500,
                    'message' => __('digimed_validation.image_upload_error', ['error' => $uploadedImage['msg']]),
                ], 500);
            }

            if ($uploadedImage['code'] == 200) {
                $doctorImage->doctor_image = $uploadedImage['data'];
                $doctorImage->save(); // Save the updated image path
            }
        }

        return self::sentResponse(200, [], __('digimed_validation.success_response.doctors_details_success'));

    } catch (Exception | Throwable | QueryException $e) {
        return self::sentResponse(500, [], $e->getMessage());
    }
}


    //list doctors
    public function fetchDoctorsHomePage(Request $request, S3Library $S3Library)
    {
        try {

            // $doctorHomePage = DoctorsHomePage::select('id', 'name', 'specialization','doctor_image','rating','language_spoken')->whereNull('deleted_at')->get();
            
            // if ($doctorHomePage->isEmpty()) {
            //     return self::sentResponse(201, [], __('digimed_validation.error_response.records_not_found'));
            // }

            $limit = $request->limit ? $request->limit : 10;
            $doctors = User::role('doctor')->where('status', '2')->where('landing_feature','yes')->limit($limit)->get();

            return new UserCollection($doctors, 200, 'doctors', __('digimed_validation.success_response.data_fetch_success'));

            // return self::sentResponse(200, $doctorHomePage->toArray(), __('digimed_validation.success_response.data_fetch_success'));
    
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function fetchDoctorDetailHomePage(UserIdRequest $request)
    {
        try {

            $doctor = User::find($request->user_id);

            return new UserResource($doctor, 200, __('digimed_validation.success_response.data_fetch_success'));
            
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    //delete Image document
    public function deleteDoctorsHomePage(Request $request)
    {
        try {
            $rules = [               
                'id' => 'required',
            ];
            $messages = [
                'id.required' => __('digimed_validation.form_validation_error.doctor_id_req'),
            ];
            $validator = Validator::make($request->all(), $rules, $messages);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());   
            } 
            $doctorsHomePage = DoctorsHomePage::find($request->id);
            if (!$doctorsHomePage) {
                return self::sentResponse(201, [], __('digimed_validation.error_response.records_not_found'));
            }
         
            if(Config::get('filesystems.default') == "s3") {
                Storage::disk('s3')->delete('digimed/home-page/doctor_image/'.$doctorsHomePage['doctor_image']);
            } else {
                Storage::delete('digimed/home-page/doctor_image/'.$doctorsHomePage['doctor_image']);
            }

            if($doctorsHomePage->delete()){
                return self::sentResponse(200, [], __('digimed_validation.success_response.data_delete_success'));               
            }

        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function pageContent(Request $request)
    {
        try {

            $validator = Validator::make($request->all(), [ 
                'type' => 'required|in:text,image',             
                'key' => 'required_if:type,text',
                'file' => 'required_if:type,image',
                'value' => 'required_if:type,text',
            ]);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());
            }

            $page = PageContent::where('key', $request->key)->first();

            if(!$page) {
                $page = new PageContent();
                $page->key = $request->key;
                $page->page = $request->page;
                $page->section = $request->section;
                $page->type = $request->type;
            }

            if($request->type == 'image') {
                if ($request->hasFile('file')) {
                    $file = $request->file('file');
                    $uploadPath = 'images/landing/'.$request->key.'/';
                    Storage::disk('public')->putFileAs($uploadPath, $file, $file->getClientOriginalName());
                    $page->value = $file->getClientOriginalName();
                } else {
                    return self::sentResponse(500, [], __('digimed_validation.error_response.image_upload_faild_try'));
                }
            } else {
                $page->value = $request->value;
            }
            $page->save();

            return self::sentResponse(200, [], __('digimed_validation.success_response.data_store_success'));
            
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function pageContentList(Request $request)
    {
        try {

            $paginate = $request->count_per_page ? $request->count_per_page : 10;
            $pageNumber = $request->page ? $request->page : 1;
            $search_key = $request->search ? $request->search : '';
            $list_type = $request->list_type ? $request->list_type : 'list';

            $sort_by_col = (isset($request->sort_by)) ? $request->sort_by : 'id';
            $data_order_by = $request->order_by;
            $orderBy = $data_order_by ? strtoupper($data_order_by) : strtoupper('asc');

            $list = PageContent::whereNotNull('id');

            if(!empty($search_key)) {
                $list = $list->where(function($q) use($search_key){
                    $q->where('page', 'LIKE', "%{$search_key}%");
                    $q->orWhere('section', 'LIKE', "%{$search_key}%");
                    $q->orWhere('key', 'LIKE', "%{$search_key}%");
                });
            }

            if($sort_by_col) {
                $list = $list->orderBy($sort_by_col, $orderBy);
            }

            if($list_type == 'paginate') {
                return self::sentResponse(200, $list->paginate($paginate), __('digimed_validation.success_response.data_fetch_success'));
            } else {
                return self::sentResponse(200, $list->get(), __('digimed_validation.success_response.data_fetch_success'));
            }
        } catch (Exception $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function pageModule(Request $request)
    {
        try {

            $validator = Validator::make($request->all(), [              
                'page' => 'required',
                'section' => 'required',
                'is_enabled' => 'required|in:yes,no',
            ]);

            if ($validator->fails()) {
                return self::errorResponse(422, $validator->errors()->all());  
            }

            $page = PageModule::where('page', $request->page)->where('section', $request->section)->first();

            if(!$page) {
                $page = new PageModule();
                $page->page = $request->page;
                $page->section = $request->section;
            }
            
            $page->is_enabled = $request->is_enabled;
            $page->save();

            return self::sentResponse(200, [], __('digimed_validation.success_response.data_store_success'));
            
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    public function pageModuleList(Request $request)
    {
        try {

            $paginate = $request->count_per_page ? $request->count_per_page : 10;
            $pageNumber = $request->page ? $request->page : 1;
            $search_key = $request->search ? $request->search : '';
            $list_type = $request->list_type ? $request->list_type : 'list';

            $sort_by_col = (isset($request->sort_by)) ? $request->sort_by : 'id';
            $data_order_by = $request->order_by;
            $orderBy = $data_order_by ? strtoupper($data_order_by) : strtoupper('asc');

            $list = PageModule::whereNotNull('id');

            if(!empty($search_key)) {
                $list = $list->where(function($q) use($search_key){
                    $q->where('page', 'LIKE', "%{$search_key}%");
                    $q->orWhere('section', 'LIKE', "%{$search_key}%");
                });
            }

            if($sort_by_col) {
                $list = $list->orderBy($sort_by_col, $orderBy);
            }

            if($list_type == 'paginate') {
                return self::sentResponse(200, $list->paginate($paginate), __('digimed_validation.success_response.data_fetch_success'));
            } else {
                return self::sentResponse(200, $list->get(), __('digimed_validation.success_response.data_fetch_success'));
            }
        } catch (Exception $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }
}