<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Http\Requests\LabBasicInfoRequest;
use App\Http\Requests\LabContactInfoRequest;
use App\Http\Requests\LabLicenseInfoRequest;
use App\Http\Requests\LabPaymentInfoRequest;
use Illuminate\Support\Facades\Validator;
use App\LabSettingsBasicinfo;
use App\LabSettingsContactinfo;
use App\LabSettingsLicenseinfo;
use App\LabSettingsPaymentinfo;
use Auth;
use App\Lab;
use Carbon\Carbon;
use Config;
use DB;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Database\QueryException;
use App\Library\S3Library;
use Throwable;

class LabSettingController extends Controller
{
    public function updateBasicInfo(LabBasicInfoRequest $request, S3Library $S3Library)
    {
        try {
            /** @var \App\User $user */
            $lab = Lab::where('user_id', auth()->user()->id)->first();
            
            if (!$lab) {
                return response()->json([
                    'code' => 404,
                    'message' => __('digimed_validation.error_response.lab_not_found_msg'),
                ], 404);
            }
    
            $validatedData = $request->validated();
            $logoPath = null;
            $favIconPath = null;
    
            if ($request->hasFile('logo')) {
                $file = $request->file('logo');
                $uploadPath = 'digimed/images/lab-settings-logo/' . $lab->id . '/';
                $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) {
                    $logoPath = $uploadedImage['data'];
                }
            }
    
            if ($request->hasFile('fav_icon')) {
                $file = $request->file('fav_icon');
                $uploadPath = 'digimed/images/lab-settings-favicon/' . $lab->id . '/';
                $uploadedFav = $S3Library->fileUpload(true, 'jpeg|JPEG|jpg|JPG|png|PNG|gif|svg', true, $file, $uploadPath);
                
                if ($uploadedFav['code'] == 500) {
                    return response()->json([
                        'code' => 500,
                        'message' => __('digimed_validation.image_upload_error', ['error' => $uploadedFav['msg']]),
                    ], 500);
                }
                if ($uploadedFav['code'] == 200) {
                    $favIconPath = $uploadedFav['data'];
                }
            }
    
            $basicInfo = LabSettingsBasicinfo::firstOrNew(['lab_id' => $lab->id]);
            $basicInfo->app_name = $request->app_name;
            $basicInfo->logo = $logoPath ?? $basicInfo->logo;
            $basicInfo->fav_icon = $favIconPath ?? $basicInfo->fav_icon;
            $basicInfo->save();
    
            return self::sentResponse(200, [], __('digimed_validation.success_response.lab_basicinfo_success'));
        } catch (Exception | Throwable | QueryException $e) {
            return self::sentResponse(500, [], $e->getMessage());
        }
    }

    //contact info

    public function updateContactInfo(LabContactInfoRequest $request, S3Library $S3Library)
    {
        try {
            /** @var \App\User $user */
           
            $lab = Lab::where('user_id', auth()->user()->id)->first();
            $contactInfo = LabSettingsContactinfo::firstOrNew(['lab_id' => $lab->id]);
          
            $contactInfo->lab_id = $lab->id;
            $contactInfo->email = $request->email;
            $contactInfo->phone_number = $request->phone_number;
            if (isset($request->address2)) {
                $contactInfo->address2 = $request->address2;
            }
            $contactInfo->address1 = $request->address1;
            $contactInfo->city = $request->city;
            $contactInfo->state = $request->state;
            $contactInfo->zipcode = $request->zipcode;
            $contactInfo->save();

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


    //license info

    public function updateLicenseInfo(LabLicenseInfoRequest $request, S3Library $S3Library)
    {
        try {
            /** @var \App\User $user */
           
            $lab = Lab::where('user_id', auth()->user()->id)->first();
            $licenseInfo = LabSettingsLicenseinfo::firstOrNew(['lab_id' => $lab->id]);
          
            $licenseInfo->lab_id = $lab->id;
            $licenseInfo->license_no = $request->license_no;
            $licenseInfo->expiration_date = $request->expiration_date;
           
            $licenseInfo->save();

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

    //payment info

    public function updatePaymentInfo(LabPaymentInfoRequest $request, S3Library $S3Library)
    {
        try {
            /** @var \App\User $user */
           
            $lab = Lab::where('user_id', auth()->user()->id)->first();
            $paymentInfo = LabSettingsPaymentinfo::firstOrNew(['lab_id' => $lab->id]);
          
            $paymentInfo->lab_id = $lab->id;
            $paymentInfo->account_holder_name = $request->account_holder_name;
            $paymentInfo->bank_name = $request->bank_name;
            $paymentInfo->account_number = $request->account_number;
            $paymentInfo->ifsc_Code = $request->ifsc_Code;
            if (isset($request->currency)) {
                $paymentInfo->currency = $request->currency;
            }
            $paymentInfo->tax_charge = $request->tax_charge;
            if (isset($request->time_zone)) {
                $paymentInfo->time_zone = $request->time_zone;
            }
            $paymentInfo->save();

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

    //Fetch by type 1-basic,2-contact, 3-license, 4-payment
    public function fetchInfo(Request $request)
    {
        try {
            $rules = [               
                'type' => 'required|in:1,2,3,4',   
            ];
            $messages = [
                'type.required' => __('digimed_validation.form_validation_error.type_required'),
                'type.in'       => __('digimed_validation.form_validation_error.type_max'),
            ];
            $validator = Validator::make($request->all(), $rules, $messages);

            if ($validator->fails()) {
                return self::sentResponse(422, [], $validator->errors()->first()); 
            } 

            $type = $request->type;
            $lab = Lab::where('user_id', auth()->user()->id)->first();
            if (!$lab) {
                return response()->json([
                    'code' => '404',
                    'message' => __('digimed_validation.form_validation_error.lab_not_found'),
                ], 404);
            }

            // Define the mapping of types to models
            $typeMappings = [
                1 => LabSettingsBasicinfo::class,
                2 => LabSettingsContactinfo::class,
                3 => LabSettingsLicenseinfo::class,
                4 => LabSettingsPaymentinfo::class,
            ];

            // Dynamically resolve the model
            $modelClass = $typeMappings[$type];
            $data = $modelClass::where('lab_id', $lab->id)->first();

            if (!$data) {
                return response()->json([
                    'code' => '200',
                    'data' => [],
                    'message' => __('digimed_validation.error_response.fill_lab_setting_info'),
                ], 200);
            }

            if ($type == 1) {
                $data->logo_url = $data->logo_url;
                $data->fav_icon_url = $data->fav_icon_url;
            }
           
            return self::sentResponse(200, $data->toArray(), __('digimed_validation.success_response.data_fetch_success'));

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

}