<?php

namespace App\Models;

use App\Notifications\ResetPasswordNotification;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;
use Pylon\Traits\Models\HasSearchScope;
use Pylon\Traits\Models\HasSoftDeletesActivity;

class User extends Authenticatable
{
	use HasApiTokens, HasFactory, Notifiable;
	
	use SoftDeletes, HasSoftDeletesActivity, HasSearchScope;

	/**
	 * The attributes that are mass assignable.
	 *
	 * @var array
	 */
	protected $fillable = [
		'full_name',
		'unique_id',
		'email',
		'mobile_num',
		'password',
		'role_id',
		'gender',
		'address',
		'postcode',
		'city',
		'state',
		'company_name',
		'business_reg_num',
		'partner_package_id',
		'commission_rate',
		'phone_verified_at',
	];

	/**
	 * The attributes that should be hidden for arrays.
	 *
	 * @var array
	 */
	protected $hidden = [
		'password',
		'remember_token',
	];

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

	const ROLE_CUSTOMER = 1;
	const ROLE_PARTNER = 2;
	const ROLE_SUPER_ADMIN = 98;
	const ROLE_AA_ADMIN = 99;
	public const ROLE_TYPES = [
		self::ROLE_CUSTOMER => "Customer",
		self::ROLE_PARTNER => "Partner",
		self::ROLE_SUPER_ADMIN => "Superadmin",
		self::ROLE_AA_ADMIN => "AA admin",
	];

	public const GENDER_TYPES =[
		"Male",
		"Female"
	]; 

	protected $appends = [
		'has_password',
		'role_name',
	];

	protected function serializeDate(\DateTimeInterface $date)
	{
		return $date->format('Y-m-d H:i:s');
	}
	
	// accessor
	public function getRoleNameAttribute()
	{   
		if(isset($this->attributes['role_id'])){
			return self::ROLE_TYPES[$this->attributes['role_id']] ?? 'N/A';
		}
	}

	public function getHasPasswordAttribute()
	{   
		if(isset($this->attributes['password']) && $this->attributes["password"] != "N/A")
			return true;

		return false;
	}

	// relationship
	public function socializes() {
		return $this->hasMany('App\Models\UserSocialize', 'user_id');
	}
	public function credits() {
		return $this->hasMany('App\Models\UserCredit', 'user_id');
	}
	public function fcmTokens() {
		return $this->hasMany('App\Models\UserFcmToken', 'user_id');
	}
	public function notificationMessages() {
        return $this->belongsToMany('App\Models\NotificationMessage', 'user_notifications', 'user_id','notification_id')->withPivot('is_read');
	}
	public function partnerPackage() {
		return $this->belongsTo('App\Models\PartnerPackage');
	}

	// Notifiable
	public function sendPasswordResetNotification($token)
	{
		$this->notify(new ResetPasswordNotification($token));
	}

	// Sanctum
    public function tokens()
    {
        return $this->morphMany('App\Models\SanctumToken', 'tokenable');
    }
    public function createToken(string $name, $platform = '', array $abilities = ['*'])
    {
        $token = $this->tokens()->create([
            'name' => $name,
            'platform_id' => $platform,
            'token' => hash('sha256', $plainTextToken = \Str::random(40)),
            'abilities' => $abilities,
        ]);

        return new \Laravel\Sanctum\NewAccessToken($token, $token->id.'|'.$plainTextToken);
    }

	// other
	public function isSuperAdmin()
	{
		return in_array($this->attributes['role_id'], [self::ROLE_SUPER_ADMIN, self::ROLE_AA_ADMIN]);
	}
	public function isCustomer()
	{
		return in_array($this->attributes['role_id'], [self::ROLE_CUSTOMER]);
	}
	public function isPartner()
	{
		return in_array($this->attributes['role_id'], [self::ROLE_PARTNER]);
	}
	public function isContainOldPassword()
	{
		return ($this->attributes['password'] != 'N/A');
	}	
	public function getCreditAmount()
	{
		$this->loadSum('credits as total_credit','amount');
		$this->attributes['total_credit'] = $this->attributes['total_credit'] ?: "0";
		return $this->attributes['total_credit'];
	}

	// static
	public static function computedUniqueId($role_id)
	{	
		$last_user = User::where('role_id',$role_id)->whereNotNull('unique_id')->latest('created_at')->withTrashed()->first();

		$last_unique_id = (int)substr($last_user->unique_id,5);

		$year = now()->format('Y');

		$unique_id = self::getUniqueId($role_id, $last_unique_id, $year);

		return $unique_id;
	}

	public static function getUniqueId($role_id, $count, $year)
	{
		$running_number = $count + 1;

		switch ($role_id) {
			case self::ROLE_AA_ADMIN:
				$unique_id = 'SA'.str_pad($running_number, 1, '0', STR_PAD_LEFT);
				break;
			case self::ROLE_SUPER_ADMIN:
				$unique_id = 'A'.str_pad($running_number, 3, '0', STR_PAD_LEFT);
				break;
			case self::ROLE_PARTNER:
				$unique_id = 'P'.$year.str_pad($running_number, 5, '0', STR_PAD_LEFT);
				break;
			case self::ROLE_CUSTOMER:
				$unique_id = 'U'.$year.str_pad($running_number, 7, '0', STR_PAD_LEFT);
				break;
			default:
				throw new \Exception("Role Type #{$role_id} required new action.");
				break;
		}

		$user = User::where('unique_id',$unique_id)->first();

		if($user)
		{
			$unique_id = self::getUniqueId($role_id, $running_number, $year);
		}

		return $unique_id;
	}
}