<?php

namespace App\Models;

use App\Events\ClaimApproved;
use App\Events\ClaimDeclined;
use App\Events\ClaimPaid;
use App\Events\ClaimPostpone;
use App\Events\ClaimReceived;
use App\Events\ClaimRequested;
use App\Traits\Blameable;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Str;

class Claim extends Model
{
    use HasFactory, Blameable, SoftDeletes;
    
    protected static $code_prefix = 'CLM';

    protected $fillable = [
        'claim_request_id',
        'code',
        'member_id',
        'total_claim',
        'currency',
        'plan_id',
        'benefit_id',
        'status',
    ];

    protected $hidden = [
        'created_at',
        'updated_at',
        'deleted_at',
        'created_by',
        'updated_by',
        'deleted_by',
    ];

    public static $status = [
        'draft' => 'Draft',
        'requested' => 'Requested',
        'received' => 'Received',
        'approved' => 'Approved',
        'postpone' => 'Postpone',
        'paid' => 'Paid',
        'declined' => 'Declined'
    ];
    
    protected static function boot()
    {
        parent::boot();

        static::creating(function ($model) {
            try {
                $model->uuid = (string) Str::orderedUuid(); // generate uuid
                $model->code = self::getNextCode();
            } catch (\Exception $e) {
                abort(500, $e->getMessage());
            }
        });

        static::created(function ($model) {
            try {
                if (!empty($model->status)) {
                    $model->statusHistories()->create([
                        'status' => $model->status
                    ]);
                }
            } catch (\Exception $e) {
                abort(500, $e->getMessage());
            }
        });

        static::updated(function ($model) {
            if ($model->hasChanges(['status'])) {
                $model->statusHistories()->create([
                    'status' => $model->status
                ]);

                // if ($model->status == 'requested') {
                //     ClaimRequested::dispatch($model);
                // }

                if ($model->status == 'received') {
                    ClaimReceived::dispatch($model);
                }

                if ($model->status == 'approved') {
                    ClaimApproved::dispatch($model);
                }

                if ($model->status == 'postpone') {
                    ClaimPostpone::dispatch($model);
                }

                if ($model->status == 'paid') {
                    ClaimPaid::dispatch($model);
                }

                if ($model->status == 'declined') {
                    ClaimDeclined::dispatch($model);
                }
            }
        });
    }
    
    public static function getNextCode()
    {
        $last_number = self::withTrashed()->max('code');
        $next_number = empty($last_number) ? 1 : ((int) explode('-', $last_number)[1] + 1);

        return self::makeCode($next_number);
    }

    public static function makeCode($next_number)
    {
        return (string) self::$code_prefix .'-'. str_pad($next_number, 5, 0, STR_PAD_LEFT);
    }

    // Current ClaimRequest that refer to the claim
    public function claimRequest()
    {
        return $this->belongsTo(ClaimRequest::class, 'claim_request_id');
    }

    // Possibilities of ClaimRequest that refer to the claim
    public function claimRequests()
    {
        return $this->hasMany(ClaimRequest::class, 'claim_id');
    }

    public function files()
    {
        return $this->morphMany(File::class, 'fileable');
    }

    public function items()
    {
        return $this->hasMany(ClaimItem::class, 'claim_id');
    }

    public function member()
    {
        return $this->belongsTo(Member::class, 'member_id');
    }

    public function encounters()
    {
        return $this->belongsToMany(Encounter::class, 'claim_encounter');
    }

    public function finalEncounter()
    {
        return $this->belongsTo(Encounter::class, 'final_encounter_id');
    }

    public function diagnoses()
    {
        return $this->hasMany(ClaimDiagnosis::class, 'claim_id');
    }

    // TODO Remove this !, Sementara
    public function diagnosis()
    {
        return $this->hasOne(ClaimDiagnosis::class, 'claim_id')->ofMany([
            'id' => 'min',
        ], function ($query) {
            $query->where('type', 'primary');
        });
    }

    public function plan()
    {
        return $this->belongsTo(Plan::class, 'plan_id');
    }

    public function benefit()
    {
        return $this->belongsTo(Benefit::class, 'benefit_id');
    }

    public function statusHistories()
    {
        return $this->morphMany(StatusHistory::class, 'statusable');
    }

    public function scopeUsed($query, $startDate, $endDate)
    {
        return $query
                ->whereIn('status', ['approved', 'paid']);
                // ->whereBetween('requested_at', [$startDate, $endDate]);
    }

    public function getTotalTagihanAttribute()
    {
        return $this->items->sum('nominal_ditagihkan');
    }
    
}