<?php

namespace App;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Database\Eloquent\SoftDeletes;
use Spatie\Permission\Traits\HasRoles;
use Laravel\Passport\HasApiTokens;
use Storage;
use DB;
use Auth;
use App\Language;
use App\DependantAccountHolder;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Support\Carbon;
use App\Enums\AppoitmentStatusEnum;
use App\Traits\Encryptable;

/**
 * App\User
 *
 * @property object $dependantAccountHolder
 * @property mixed $type
 * @property object $userDetail
 * @property object $sumSub
 * @property object $myDependants
 * @property mixed $subscription_plan
 * @property mixed $roles_count
 * @property mixed $my_dependants_count
 * @property mixed $dependant_account_holder_count
 * @property mixed $is_two_step_Verified
 * @property mixed $name
 * @property mixed $email_verification_code
 * @property mixed $user_completion
 * @property integer $id
 * @property integer $country_id
 * @property string $first_name
 * @property string $last_name
 * @property string $country_code
 * @property string $passport_number
 * @property mixed $email_verificaion_code
 * @property mixed $biographies
 * @property string $mobile_number
 * @property mixed $is_mobile_number_verified
 * @property string $email
 * @property mixed $is_email_verified
 * @property mixed $gender
 * @property mixed $dob
 * @property mixed $post_code
 * @property mixed $address
 * @property mixed $profile_image
 * @property mixed $signature
 * @property mixed $signatureurl
 * @property mixed $avgratingdoctor
 * @property mixed $isfavourite
 * @property mixed $user_completion
 * @property mixed $status
 * @property mixed $unique_id
 * @property mixed $two_step_verification_type
 * @property object $unreadNotifications
 * @property object $roles
 * @property string $browser_token
 * @property string $device_token
 */

class User extends Authenticatable
{
    use HasApiTokens, HasRoles, Notifiable, SoftDeletes, Encryptable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    public $guard_name = ['api'];

    protected $fillable = [
        'type','country_id','first_name', 'last_name', 'country_code', 'passport_number', 'mobile_number', 'is_mobile_number_verified', 'email', 'is_email_verified', 'gender', 'dob', 'country', 'post_code', 'address', 'profile_image', 'signature', 'password', 'user_completion', 'unique_id', 'two_step_verification_type', 'is_two_step_verified', 'status', 'created_by','updated_by','report_permission','more_details'
    ];

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password', 'remember_token','passcode','created_by','updated_by','deleted_by','deleted_at','updated_at', 'email_verification_code'
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];

    // protected $encryptable = ['first_name', 'last_name', 'passport_number', 'biographies', 'gender', 'post_code', 'address'];

    protected $appends = ['avgratingdoctor', 'isfavourite', 'signatureurl','waiting_room'];

    public function basicProfile($id = NULL,$mobile=NULL){
        /** @var object $this->roles() */
        return [
           'id' => $this->id,
           'name' => trim($this->first_name . ' '. $this->last_name),
           'profile_image' => $this->profile_image,
           'country_code' => $this->country_code,
           'mobile_number' => $this->mobile_number,
           'email' => $this->email,
           'address' => $this->address,
           'unique_id' => $this->unique_id,
           'status' => $this->status,
           'role' => $this->roles()->first()->name,
        ];
    }

    public function sumSub(): HasOne {
        return $this->hasOne(Sumsub::class, 'user_id', 'id')->orderBy('id', 'DESC');
    }

    public function getCountryIdAttribute($value) {
        return Country::select('id','name','iso2','currency')->where('id',$value)->first();
    }

    public function userDetail(): HasOne {
        return $this->hasOne(UserDetails::class, 'user_id');
    }

    public function userAdditionalInfo(): HasOne {
        return $this->hasOne(UserAdditionalInfo::class, 'user_id');
    }

    public function clinicDetail(): HasOne {
        return $this->hasOne(Clinic::class, 'user_id');
    }

    public function blogDetail(): HasOne {
        return $this->hasOne(Blog::class, 'user_id');
    }

    public function patientDiagnosis(): HasMany {
        return $this->hasMany(Diagnosis::class, 'patient_id');
    }

    public function userUpload(): HasMany {
        return $this->hasMany(UserUpload::class, 'user_id');
    }

    public function favouriteDoctors(): HasMany {
        return $this->hasMany(FavouriteDoctors::class, 'doctor_id');
    }

    public function favouritePatients(): HasMany {
        return $this->hasMany(FavouriteDoctors::class, 'patient_id');
    }

    public function countryData(): HasOne {
        return $this->hasOne(Country::class, 'id', 'country_id');
    }

    public function stateData(): HasOne {
        return $this->hasOne(State::class, 'id', 'state_id');
    }

    public function cityData(): HasOne {
        return $this->hasOne(City::class, 'id', 'city_id');
    }

    public function getIsFavouriteAttribute() {
        if (Auth::user()) {
            $data = $this->favouriteDoctors()->where('patient_id', auth()->user()->id)->count();
            return $data;
        } else {
            return 0;
        }
    }

    public function doctorRatings(): HasMany
    {
        return $this->hasMany(Rating::class, 'doctor_id')
                ->selectRaw('avg(doctor_rating) as doctor_rating, doctor_id')
            ->groupBy('doctor_id');
    }

    public function userDoctorRatings(): HasMany
    {
        return $this->hasMany(Rating::class, 'doctor_id');
    }

    public function scheduledAppointment(): HasMany
    {
        return $this->hasMany(ScheduledAppointment::class, 'doctor_id');
    }

    public function getAvgRatingDoctorAttribute() {
        $data = $this->userDoctorRatings()->avg('doctor_rating');
        /** @var float $data */
        return round((float)$data, 1);
    }

    public function doctorDocument(): HasOne
    {
        return $this->hasOne(DoctorDocument::class, 'user_id');
    }

    public function myDoctorAppointmentPaymentList(): HasManyThrough {
        return $this->hasManyThrough(Payment::class, Appointment::class, 'doctor_id', 'appointment_id');
    }

    public function myPatientAppointmentPaymentList(): HasManyThrough {
        return $this->hasManyThrough(Payment::class, Appointment::class, 'patient_id', 'appointment_id');
    }

    public function dependantsCanceledAppointmentList(): HasManyThrough {
        return $this->hasManyThrough(Appointment::class, DependantAccountHolder::class, 'user_id', 'patient_id')->whereIn('appointment_status',[AppoitmentStatusEnum::CANCELLED()]);
    }

    public function getProfileImageAttribute($image) {
        $S3Library = new \App\Library\S3Library;
        $digimedFile = ($S3Library->profileImage($image));
        return $digimedFile;
    }

    public function myAppointmentPatient(): BelongsTo
    {
        return $this->belongsTo(Appointment::class, 'id', 'patient_id');
    }

    public function mySubscribers(): HasMany
    {
        return $this->hasMany(Subscription::class, 'user_id', 'id');
    }

    public function myPatientAppointmentList(): HasMany
    {
        return $this->hasMany(Appointment::class, 'patient_id');
    }

    public function myDoctorAppointmentList(): HasMany
    {
        return $this->hasMany(Appointment::class, 'doctor_id');
    }

    public function getSignatureUrlAttribute() {
        $S3Library = new \App\Library\S3Library;
        $digimedFile = ($S3Library->s3Url($this->signature, $this->id, 'digimed/images/user_signature'));
        
        return $digimedFile;
    }

    public function myDependantsAppointmentList(): HasManyThrough {
        return $this->hasManyThrough(Appointment::class, DependantAccountHolder::class, 'user_id', 'patient_id');
    }

    public function myPatientOrderList(): HasManyThrough
    {
        return $this->hasManyThrough(PrescriptionRequest::class, Prescription::class, 'patient_id', 'prescription_id');
    }

    public function dependantsBookedAppointmentList(): HasManyThrough {
        return $this->hasManyThrough(Appointment::class, DependantAccountHolder::class, 'user_id', 'patient_id')->whereIn('appointment_status',[AppoitmentStatusEnum::ACCEPTED()]);
    }

    public function chats(): HasMany {
        return $this->hasMany(Chat::class, 'sender_id', 'id');
    }

    
    public function adminUserChats(): HasMany {
        return $this->hasMany(AdminUserChat::class, 'sender_id', 'id');
    }

    public function chat_inbox(): HasMany {
        return $this->hasMany(Chat::class, 'recipient_id', 'id');
    }

    public function adminChat_inbox(): HasMany {
        return $this->hasMany(AdminUserChat::class, 'recipient_id', 'id');
    }

    public function unreadChat($id) {
        return Chat::where('sender_id',$this->id)->where('recipient_id',$id)->where('read_status',0)->count();
    }

    public function unreadAdminUserChat($id) {
        return AdminUserChat::where('sender_id',$this->id)->where('recipient_id',$id)->where('read_status',0)->count();
    }

    public function lastChat($id) {
        $recipient_id = $this->id;
        $chat = Chat::select('message','file_path','created_at')->where(function($qry) use ($recipient_id,$id){
            $qry->whereRaw("sender_id=".$id." and recipient_id=".$recipient_id)
                ->orWhereRaw("sender_id=".$recipient_id." and recipient_id=".$id);
        });
        $list = $chat->orderBy('id','desc')->first();
        //$count = $chat->where('read_status',1)->count();
        if($list){
        (empty($list->message))? $msg = $list->file_path : $msg = $list->message;
        $created_at=$list->created_at->diffForHumans();
        }else{$msg =''; $created_at=''; }

        return [
            'message' => $msg,
            'created_at' => $created_at,
           // 'unread' => ($list)? $count : 0,
        ];
    }


    public function adminUserlastChat($id) {
        $recipient_id = $this->id;
        $chat = AdminUserChat::select('message','file_path','created_at')->where(function($qry) use ($recipient_id,$id){
            $qry->whereRaw("sender_id=".$id." and recipient_id=".$recipient_id)
                ->orWhereRaw("sender_id=".$recipient_id." and recipient_id=".$id);
        });
        $list = $chat->orderBy('id','desc')->first();
        //$count = $chat->where('read_status',1)->count();
        if($list){
        (empty($list->message))? $msg = $list->file_path : $msg = $list->message;
        $created_at=$list->created_at->diffForHumans();
        }else{$msg =''; $created_at=''; }

        return [
            'message' => $msg,
            'created_at' => $created_at,
           // 'unread' => ($list)? $count : 0,
        ];
    }

    public function userSpecialisation(): HasMany {
        return $this->hasMany(UserAreaSpecialisation::class, 'sender_id', 'id');
    }

    //Health Profile
    public function healthProfile(): HasOne {
        return $this->hasOne(HealthProfile::class, 'user_id', 'id')->latest();
    }

    public function allergieHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileAllergie::class, 'user_id', 'id');
    }

    public function medicalConditionHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileMedicalCondition::class, 'user_id', 'id');
    }

    public function medicationHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileMedication::class, 'user_id', 'id');
    }

    public function procedureHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileProcedure::class, 'user_id', 'id');
    }

    public function prosthesisHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileProsthesis::class, 'user_id', 'id');
    }

    public function dietaryRestrictionHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileDietaryRestrictions::class, 'user_id', 'id');
    }

    public function recreationalDrugHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileRecreationalDrugs::class, 'user_id', 'id');
    }

    public function alcoholConsumptionHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileAlcoholConsumptions::class, 'user_id', 'id');
    }

    public function tobaccoUseHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileTobaccoUses::class, 'user_id', 'id');
    }

    public function vaccinationHealthProfile(): HasMany {
        return $this->hasMany(HealthProfileVaccinations::class, 'user_id', 'id');
    }

    public function myDependants(): HasMany {
        return $this->hasMany(DependantAccountHolder::class, 'user_id', 'id');
    }

    public function dependantAccountHolder(): HasMany {
        return $this->hasMany(DependantAccountHolder::class, 'dependant_id', 'id');
    }

    public function dependantAddress(): HasMany {
        return $this->hasMany(UserAddress::class, 'user_id', 'id');
    }

    public function dependantRelation(): HasMany {
        return $this->hasMany(DependantAccountHolder::class, 'dependant_id', 'id');
    }

    public function preferenceSettings(): HasOne {
        return $this->hasOne(UserSettingsPreference::class, 'user_id', 'id');
    }

    public function notificationSettings(): HasOne {
        return $this->hasOne(UserSettingsNotification::class, 'user_id', 'id');
    }

    public function securitySettings(): HasOne {
        return $this->hasOne(UserSettingsSecurity::class, 'user_id', 'id');
    }

    public function subscription(): HasOne {
        return $this->hasOne(Subscription::class, 'user_id', 'id')->latest();
    }

    public function consultationPrice(): HasMany {
        return $this->hasMany(ConsultationPrice::class, 'user_id', 'id');
    }

    public function subscriptionStatus() {
        $subscriptionLibrary = new \App\Library\SubscriptionLibrary;
        // $result = $subscriptionLibrary->status($this->id);
        $result = $subscriptionLibrary->newStatus($this->id);
        
        $status = '1';
        if($result['plan'] == 'free')
            $status = '0';
        return $status;
    }

    public function insuranceDetail(): HasOne {
        return $this->hasOne(InsuranceDetail::class, 'user_id', 'id');
    }

    public function pharmacyGet(): HasOne {
        return $this->hasOne(Pharmacy::class, 'created_by', 'id');
    }

    public function pharmacy() : BelongsToMany {
        return $this->belongsToMany(Pharmacy::class, 'user_pharmacies','user_id','pharmacy_id');
    }

    public function userPharmacy() : hasMany {
        return $this->hasMany(UserPharmacy::class,'user_id','id');
    }

    public function generalConditionPatientDetail(): HasMany {
        return $this->hasMany(GeneralHealthConditionPatient::class, 'patient_id', 'id');
    }

    public function generalConditionDoctorDetail(): HasMany {
        return $this->hasMany(GeneralHealthConditionPatient::class, 'doctor_id', 'id');
    }

    public function getWaitingRoomAttribute()
    {
        $variableLibrary = new \App\Library\VariableLibrary;
        $current_date = Carbon::now()->format('Y-m-d');
        $current_datetime = Carbon::now();
        $online_status = 0;
        if ($this->id != '') {
            $patient_id = $this->id;
            $list = WaitingRoom::where('patient_id', $patient_id)
                    ->whereDate('start_time', $current_date)
                    ->where('end_time', '>', $current_datetime)
                    ->whereIn('status', [0, 1])
                    ->get();
            $count = 0;
            $time = Carbon::createFromFormat('H:i:s', '00:00:00');
            if (count($list) != 0) {
                foreach ($list as $key => $value) {
                    if ($value->status == 1) {
                        $count++;
                        $start_time = $current_datetime;
                        $end_time = Carbon::createFromFormat('Y-m-d H:i:s', $value->end_time);
                        $diff = $start_time->diff($end_time)->format('%H:%I:%S');
                        $diff_time = explode(':', $diff);
                        $var_hours = ($variableLibrary->int($diff_time[0]));
                        $var_mints = ($variableLibrary->int($diff_time[1]));
                        $var_secs = ($variableLibrary->int($diff_time[2]));
                        $time->addHours($var_hours)->addMinutes($var_mints)->addSeconds($var_secs);
                    } elseif ($value->status == 0) {
                        $count++;
                        if ($value->start_time < $current_datetime) {
                            $start_time = Carbon::createFromFormat('Y-m-d H:i:s', $current_datetime);
                        } else {
                            $start_time = Carbon::createFromFormat('Y-m-d H:i:s', $value->start_time);
                        }
                        // $start_time = Carbon::createFromFormat('Y-m-d H:i:s', $value->start_time);
                        $end_time = Carbon::createFromFormat('Y-m-d H:i:s', $value->end_time);
                        $diff = $start_time->diff($end_time)->format('%H:%I:%S');
                        $diff_time = explode(':', $diff);
                        $var_hours = ($variableLibrary->int($diff_time[0]));
                        $var_mints = ($variableLibrary->int($diff_time[1]));
                        $var_secs = ($variableLibrary->int($diff_time[2]));
                        $time->addHours($var_hours)->addMinutes($var_mints)->addSeconds($var_secs);
                    }
                }
                $time->addMinutes(1);
                $remain_time = Carbon::parse($time)->format('H:i:s');

                return ['online_status'=>$online_status, 'count'=>$count, 'duration'=>$remain_time];
            } else {
                return ['online_status'=>$online_status, 'count'=>0, 'duration'=>''];
            }
        } else {
            return ['online_status'=>$online_status, 'count'=>0, 'duration'=>''];
        }
    }

    public function labs()
    {
        return $this->hasMany(Lab::class);
    }
}