namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use NadLambino\Uploadable\Concerns\Uploadable;

class Post extends Model
{
    use Uploadable;
}

protected function uploadRules(): array
{
    return [
        // Override the rules for `document` field
        'document' => ['required', 'file', 'mime:application/pdf'], 

        // Add a new field with it's own set of rules
        'avatar' => ['required', 'image', 'mime:png'] 
    ];
}

public function uploadRuleMessages(): array
{
    return [
        'document.required' => 'The file is required.',
        'document.mime' => 'The file must be a PDF file.',
        'avatar.required' => 'The avatar is required.',
        'avatar.mime' => 'The avatar must be a PNG file.'
    ];
}

public function getUploadFilename(UploadedFile $file): string
{
    return str_replace('.', '', microtime(true)).'-'.$file->hashName();
}

public function getUploadPath(UploadedFile $file): string
{
    return $this->getTable().DIRECTORY_SEPARATOR.$this->{$this->getKeyName()};
}

public function getUploadStorageOptions(): array
{
    return [
        'visibility' => 'public',
        'CacheControl' => 'max-age=315360000, no-transform, public'
    ];
}

// Let us say that on your config/filesystems.php, your default disk is set to `local`.
// This method will create a user and will upload the file from the request, e.g., user avatar.
public function store(Request $request)
{
    User::create(...);
}

// While this method store the message and will upload the file from the request to `s3`.
public function store(Request $request)
{
    Message::uploadDisk('s3');
    Message::create(...);
}

public function store(Request $request)
{
    Post::uploadToCollection('banner');

    Post::create(...);
}

$post = Post::query()
    ->with('image', fn ($query) => $query->fromCollection('banner'))
    ->find(...);

public function update(Request $request, Post $post)
{
    $post->update($request->all());
    
    // If the post did not change, the `updated` event won't be fired.
    // So, we need to manually call the `updateUploads` method.
    if (! $post->wasChanged()) {
        $post->updateUploads();
    }
}

public function update(Request $request, Post $post)
{
    // Temporarily disable the file uploads
    Post::disableUpload();
    
    $post->update($request->all());
    
    // Do more stuff here...
    
    // Manually process the uploads after everything you want to do
    $post->updateUploads();
}

use NadLambino\Uploadable\Actions\Upload;

public function store(Request $request)
{
    // Disable the uploads for all of the instances of Post model
    Upload::disableFor(Post::class);

    // Files will be uploaded for User model
    User::create(...);

    // Files won't be uploaded for Post model
    Post::create(...);
}

// OR

public function update(Request $request, User $user)
{
     // Disable the uploads only for this specific $user
    Upload::disableFor($user);

    // Files won't be uploaded for this specific $user
    $user->update($request->validated());
    
    $anotherUser = User::find(...);

    // Files will be uploaded for this $anotherUser
    $anotherUser->update(...);
}

use NadLambino\Uploadable\Actions\Upload;

public function store()
{
    // Process the uploads only for all of the instances of User model
    Upload::onlyFor(User::class);

    // Files will be uploaded for this User model
    User::create(...);

    // Files won't be uploaded for this Post model
    Post::create(...);
}

public function update(User $user)
{
    // Process the uploads only for this specific $user
    Upload::onlyFor($user);

    // Files will be uploaded for this specific $user
    $user->update(...);

    $anotherUser = User::find(...);

    // Files won't be uploaded for this $anotherUser
    $anotherUser->update(...)
}

'replace_previous_uploads' => true,

public function update(Request $request, Post $post)
{
    // Replace the previous uploads
    Post::replacePreviousUploads();

    $post->update($request->all());
}

// DO
$post->uploadFrom($request->file('image'));

// OR
$post->uploadFrom(new UploadedFile(...));

// OR
$post->uploadFrom([
    $request->file('image'),
    $request->file('avatar')
]);

// OR
$fullpath = ... // The path of the file that is uploaded in your `temporary_disk`. This could be something like an image that was modified by `ImageIntervention` then temporarily stored before uploading

$post->uploadFrom($fullpath);

// OR
$post->uploadFrom([
    $fullpath1,
    $fullpath2
]);

// OR even a mixed of both
$post->uploadFrom([
    $request->file('image'),
    $fullpath,
]);

$post->save();

// Relation for all types of uploads
public function upload(): MorphOne { }

// Relation for all types of uploads
public function uploads(): MorphMany { }

// Relation for uploads where extension or type is in the accepted image mimes
public function image(): MorphOne { }

// Relation for uploads where extension or type is in the accepted image mimes
public function images(): MorphMany { }

// Relation for uploads where extension or type is in the accepted video mimes
public function video(): MorphOne { }

// Relation for uploads where extension or type is in the accepted video mimes
public function videos(): MorphMany { }

// Relation for uploads where extension or type is in the accepted document mimes
public function document(): MorphOne { }

// Relation for uploads where extension or type is in the accepted document mimes
public function documents(): MorphMany { }

public function beforeSavingUpload(Upload $upload, Model $model) : void
{
    $upload->additional_field = "some value";
}

Post::beforeSavingUploadUsing(function (Upload $upload, Post $model) use ($value) {
    $model->additional_field = $value;
});

$post->save();

'upload_on_queue' => null,

Post::uploadOnQueue('default');

$post->save();