// app/Models/Product.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use MacCesar\LaravelDropzoneEnhanced\Traits\HasPhotos;

class Product extends Model
{
  use HasPhotos;

  // ... your other model properties
}

// Get all associated photos as a Collection (ordered by sort_order)
$product->photos;

// Get the main photo model instance
$photo = $product->mainPhoto();

// Get the URL of the main photo (original)
$url = $product->getMainPhotoUrl();

// Get the thumbnail URL of the main photo (default dimensions from config)
$thumbUrl = $product->getMainPhotoThumbnailUrl();

// Get custom processed images (NEW in v2.1)
$mainPhoto = $product->mainPhoto();
$customUrl = $mainPhoto?->getUrl('400x400'); // Square 400x400
$webpUrl = $mainPhoto?->getUrl('800x600', 'webp'); // WebP format
$qualityUrl = $mainPhoto?->getUrl('400x400', 'jpg', 85); // Custom quality

// Set a specific photo as the main one
$product->setMainPhoto($photoId);

// Check if the model has any photos
if ($product->hasPhotos()) {
  // ...
}

// Delete all photos associated with the model
$product->deleteAllPhotos();

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use MacCesar\LaravelDropzoneEnhanced\Http\Controllers\DropzoneController;
use MacCesar\LaravelDropzoneEnhanced\Models\Photo;

class CustomDropzoneController extends DropzoneController
{
  public function upload(Request $request)
  {
    // Add custom validation rules
    $request->validate([
      'file' => 'required|image|mimes:jpeg,png,webp|dimensions:min_width=800,min_height=600',
      'directory' => 'required|string',
      'model_id' => 'required|integer',
      'model_type' => 'required|string',
    ]);

    // Custom processing before upload
    $file = $request->file('file');

    // Add watermark, custom processing, etc.
    $this->processImageBeforeUpload($file);

    // Call parent upload method
    return parent::upload($request);
  }

  private function processImageBeforeUpload($file)
  {
    // Your custom image processing logic here
    // Example: Add watermark, EXIF data removal, etc.
  }

  protected function userCanDeletePhoto(Request $request, Photo $photo, $model)
  {
    // Add custom authorization logic
    if ($model instanceof \App\Models\Product) {
      // Check if user owns the product's company
      if ($model->company_id !== auth()->user()->company_id) {
        return false;
      }
    }

    // Call parent method for default checks
    return parent::userCanDeletePhoto($request, $photo, $model);
  }
}

// In routes/web.php
use App\Http\Controllers\CustomDropzoneController;

Route::post('dropzone/upload', [CustomDropzoneController::class, 'upload']);
Route::delete('dropzone/photos/{id}', [CustomDropzoneController::class, 'destroy']);

// Get photo information
$photo = $product->photos->first();

echo $photo->filename;           // UUID filename
echo $photo->original_filename;  // Original upload name
echo $photo->extension;          // File extension
echo $photo->mime_type;          // MIME type
echo $photo->size;               // File size in bytes
echo $photo->width;              // Image width
echo $photo->height;             // Image height
echo $photo->sort_order;         // Display order
echo $photo->is_main;            // Boolean main status

// Get URLs
echo $photo->getUrl();                    // Original image URL
echo $photo->getThumbnailUrl();           // Default thumbnail (from config)
echo $photo->getPath();                   // Storage path

// Custom image processing (NEW in v2.1)
echo $photo->getUrl('400x400');           // Square 400x400
echo $photo->getUrl('800x600', 'webp');   // Rectangular WebP
echo $photo->getUrl('400x400', 'jpg', 85); // Custom quality
echo $photo->getUrl('300x200', 'png');    // PNG format

// Photo operations
$photo->deletePhoto();  // Delete photo and files

// Create a custom Photo model extending the package's Photo
<?php

namespace App\Models;

use MacCesar\LaravelDropzoneEnhanced\Models\Photo as BasePhoto;

class Photo extends BasePhoto
{
  // Custom scopes
  public function scopeByDirectory($query, $directory)
  {
    return $query->where('directory', 'like', "%{$directory}%");
  }

  public function scopeMainPhotos($query)
  {
    return $query->where('is_main', true);
  }

  public function scopeLargeImages($query, $minWidth = 1000)
  {
    return $query->where('width', '>=', $minWidth);
  }

  // Custom accessors
  public function getFileSizeFormattedAttribute()
  {
    $bytes = $this->size;
    $units = ['B', 'KB', 'MB', 'GB'];

    for ($i = 0; $bytes > 1024; $i++) {
      $bytes /= 1024;
    }

    return round($bytes, 2) . ' ' . $units[$i];
  }

  public function getAspectRatioAttribute()
  {
    return $this->width / $this->height;
  }
}

// In your Product model, override the photos relationship
public function photos()
{
    return $this->morphMany(\App\Models\Photo::class, 'photoable')
                ->orderBy('sort_order', 'asc');
}

// Then use custom scopes
$mainPhotos = $product->photos()->mainPhotos()->get();
$galleryPhotos = $product->photos()->byDirectory('gallery')->get();
$largeImages = $product->photos()->largeImages(1200)->get();

// This worked but was confusing
$product->getMainPhotoThumbnailUrl('400x400', 'webp', 85);

// Simplified - thumbnails use config defaults only
$product->getMainPhotoThumbnailUrl(); // Default dimensions from config

// Enhanced - getUrl() now handles all custom processing
$mainPhoto = $product->mainPhoto();
$customUrl = $mainPhoto?->getUrl('400x400', 'webp', 85);

// Replace this:
$url = $product->getMainPhotoThumbnailUrl('400x400', 'webp');

// With this:
$mainPhoto = $product->mainPhoto();
$url = $mainPhoto?->getUrl('400x400', 'webp');

// Server-side validation (automatically handled by the package)
// The DropzoneController validates with: 'file' => 'required|file|image|max:' . config('dropzone.images.max_filesize')

// For custom validation, extend the controller:
class CustomDropzoneController extends DropzoneController
{
  public function upload(Request $request)
  {
    $request->validate([
      'directory' => 'required|string',
      'model_id' => 'required|integer',
      'model_type' => 'required|string',
      'file' => 'required|image|mimes:jpeg,png,webp|max:5120', // 5MB max
    ]);

    return parent::upload($request);
  }
}

class CustomDropzoneController extends DropzoneController
{
  protected function userCanDeletePhoto(Request $request, Photo $photo, $model)
  {
    // Add your custom authorization logic
    if ($model instanceof Product && $model->company_id !== auth()->user()->company_id) {
      return false;
    }

    // Call parent method for default checks
    return parent::userCanDeletePhoto($request, $photo, $model);
  }
}

'security' => [
  // IMPORTANT: Keep this false in production
  'allow_all_authenticated_users' => false,

  // Set a strong access key for API requests
  'access_key' => env('DROPZONE_ACCESS_KEY', null),
],

'images' => [
  // Limit file sizes to prevent abuse
  'max_filesize' => 10000, // 10MB in KB
  'max_files' => 10,

  // Resize large images to save storage
  'default_dimensions' => '1920x1080',
  'pre_resize' => true,
],

// The photos table includes security fields:
// - user_id: Who uploaded the photo
// - photoable_id/photoable_type: What model it belongs to

// Check photo ownership programmatically:
$photo = Photo::find($photoId);
if ($photo->user_id !== auth()->id()) {
  abort(403, 'Unauthorized');
}

// Check model ownership:
$model = $photo->photoable;
if (!$model->isOwnedBy(auth()->user())) {
  abort(403, 'Unauthorized');
}

// In routes/web.php or your RouteServiceProvider
Route::middleware(['throttle:uploads'])->group(function () {
  // Dropzone routes are automatically registered
});

// In app/Http/Kernel.php
protected $middlewareGroups = [
  'web' => [
    // ... other middleware
    'throttle:60,1', // 60 requests per minute
  ],
];

'images' => [
  'quality' => 100,                     // JPEG quality (1-100) - Default: 100 for maximum quality
  'pre_resize' => true,                 // Client-side resize - Set false to preserve original images
  'max_filesize' => 10000,              // 10MB max in KB
  'default_dimensions' => '1920x1080',  // Max dimensions

  'thumbnails' => [
    'enabled' => true,
    'dimensions' => '288x288',        // Thumbnail size
  ],
],

// Get thumbnail URL with custom dimensions
$photo = $product->photos->first();
$thumbUrl = $photo->getThumbnailUrl('300x200');

// Default thumbnail from config
$defaultThumb = $photo->getThumbnailUrl(); // Uses config('dropzone.images.thumbnails.dimensions')

// Eager load photos to avoid N+1 queries
$products = Product::with('photos')->get();

// Get only main photos
$products = Product::with(['photos' => function($query) {
  $query->where('is_main', true);
}])->get();

// Order photos by sort_order (already done by HasPhotos trait)
$photos = $product->photos; // Automatically ordered by sort_order ASC

// Paginate photos for models with many images
$photos = $product->photos()->paginate(20);

// Use appropriate storage disk for your needs
'storage' => [
  'disk' => 'public',        // For local development
  // 'disk' => 's3',         // For production with CDN
  'directory' => 'images',
],

// Organize files in date-based directories to avoid too many files per folder
<x-dropzone-enhanced::area
  :model="$product"
  directory="products/{{ date('Y/m') }}/{{ $product->id }}"
/>

// The service automatically:
// 1. Creates image resources
// 2. Generates thumbnails with proper aspect ratio
// 3. Cleans up memory with imagedestroy()
// 4. Handles different image formats (JPEG, PNG, GIF, WebP)

// For very large images, ensure adequate PHP memory:
ini_set('memory_limit', '256M');

// Cache photo counts
public function getPhotoCountAttribute()
{
  return Cache::remember(
    "product_{$this->id}_photo_count",
    3600, // 1 hour
    fn() => $this->photos()->count()
  );
}

// Cache main photo URL
public function getCachedMainPhotoUrl()
{
  return Cache::remember(
    "product_{$this->id}_main_photo_url",
    3600,
    fn() => $this->getMainPhotoUrl()
  );
}

// Override the Photo model's getUrl() method for CDN
class Photo extends \MacCesar\LaravelDropzoneEnhanced\Models\Photo
{
  public function getUrl()
  {
    $cdnUrl = config('app.cdn_url');

    if ($cdnUrl) {
      return $cdnUrl . '/' . $this->getPath();
    }

    return parent::getUrl();
  }
}

// Delete multiple photos efficiently
public function deleteSelectedPhotos(array $photoIds)
{
  $photos = $this->photos()->whereIn('id', $photoIds)->get();

  foreach ($photos as $photo) {
    $photo->deletePhoto(); // Handles file deletion + DB cleanup
  }
}

// Reorder multiple photos in one operation
public function reorderPhotos(array $photoData)
{
  foreach ($photoData as $item) {
    Photo::where('id', $item['id'])
        ->update(['sort_order' => $item['order']]);
  }
}

// Bulk update main photo status
public function setMainPhoto(int $photoId): bool
{
  // Unset all main photos in one query
  $this->photos()->update(['is_main' => false]);

  // Set new main photo
  return (bool) $this->photos()
    ->where('id', $photoId)
    ->update(['is_main' => true]);
}

<?php

namespace App\Http\Livewire;

use Livewire\Component;
use App\Models\Product;

class ProductGallery extends Component
{
  public Product $product;
  public $photos;
  public $photoCount = 0;

  protected $listeners = [
    'photoUploaded' => 'refreshPhotos',
    'photoDeleted' => 'refreshPhotos',
    'photoReordered' => 'refreshPhotos',
  ];

  public function mount(Product $product)
  {
    $this->product = $product;
    $this->refreshPhotos();
  }

  public function refreshPhotos()
  {
    $this->photos = $this->product->photos()->get();
    $this->photoCount = $this->photos->count();
  }

  public function deletePhoto($photoId)
  {
    $photo = $this->product->photos()->findOrFail($photoId);
    $photo->deletePhoto();
    $this->refreshPhotos();

    session()->flash('message', 'Photo deleted successfully');
  }

  public function setMainPhoto($photoId)
  {
    $this->product->setMainPhoto($photoId);
    $this->refreshPhotos();

    session()->flash('message', 'Main photo updated');
  }

  public function render()
  {
    return view('livewire.product-gallery');
  }
}

// Alternative approach using Spatie MediaLibrary
use Spatie\MediaLibrary\MediaCollections\Models\Media;
use Spatie\MediaLibrary\InteractsWithMedia;
use Spatie\MediaLibrary\HasMedia;

class Product extends Model implements HasMedia
{
  use InteractsWithMedia;

  public function registerMediaCollections(): void
  {
    $this->addMediaCollection('gallery')
      ->acceptsMimeTypes(['image/jpeg', 'image/png', 'image/webp'])
      ->singleFile(); // For single main image

    $this->addMediaCollection('thumbnails')
      ->acceptsMimeTypes(['image/jpeg', 'image/png', 'image/webp']);
  }

  public function registerMediaConversions(Media $media = null): void
  {
    $this->addMediaConversion('thumb')
      ->width(288)
      ->height(288)
      ->sharpen(10);

    $this->addMediaConversion('large')
      ->width(1920)
      ->height(1080)
      ->quality(90);
  }

  // Helper methods to work with both systems
  public function getMainPhotoUrl()
  {
    if ($this->hasPhotos()) {
      return $this->getMainPhotoUrl(); // Use package method
    }

    // Fallback to MediaLibrary
    return $this->getFirstMediaUrl('gallery', 'large');
  }
}

// routes/api.php
use App\Http\Controllers\Api\DropzoneApiController;

Route::middleware('auth:sanctum')->group(function () {
  Route::post('photos/upload', [DropzoneApiController::class, 'upload']);
  Route::delete('photos/{photo}', [DropzoneApiController::class, 'destroy']);
  Route::post('photos/{photo}/main', [DropzoneApiController::class, 'setMain']);
  Route::post('photos/reorder', [DropzoneApiController::class, 'reorder']);
});

<?php

namespace App\Http\Controllers\Api;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use MacCesar\LaravelDropzoneEnhanced\Http\Controllers\DropzoneController;
use MacCesar\LaravelDropzoneEnhanced\Models\Photo;

class DropzoneApiController extends DropzoneController
{
  public function upload(Request $request)
  {
    try {
      $response = parent::upload($request);
      $data = $response->getData();

      if ($data->success) {
        return response()->json([
          'success' => true,
          'photo' => [
            'id' => $data->photo->id,
            'url' => $data->photo->getUrl(),
            'thumbnail' => $data->photo->getThumbnailUrl(),
            'filename' => $data->photo->original_filename,
            'size' => $data->photo->size,
            'is_main' => $data->photo->is_main,
          ]
        ]);
      }

      return $response;
    } catch (\Exception $e) {
      return response()->json([
        'success' => false,
        'message' => 'Upload failed',
        'error' => $e->getMessage()
      ], 422);
    }
  }

  public function destroy(Photo $photo)
  {
    try {
      // Use the package's authorization logic
      if (!$this->userCanDeletePhoto(request(), $photo, $photo->photoable)) {
        return response()->json([
          'success' => false,
          'message' => 'Unauthorized'
        ], 403);
      }

      $success = $photo->deletePhoto();

      return response()->json([
        'success' => $success,
        'message' => $success ? 'Photo deleted successfully' : 'Failed to delete photo'
      ]);
    } catch (\Exception $e) {
      return response()->json([
        'success' => false,
        'message' => 'Delete failed',
        'error' => $e->getMessage()
      ], 500);
    }
  }
}

// app/Filament/Resources/ProductResource.php
use Filament\Forms\Components\SpatieMediaLibraryFileUpload;
use MacCesar\LaravelDropzoneEnhanced\Traits\HasPhotos;

class ProductResource extends Resource
{
  public static function form(Form $form): Form
  {
    return $form->schema([
      // Other form fields...

      Section::make('Photos')
        ->schema([
          // Custom photo management component
          ViewField::make('photos')
            ->view('filament.forms.dropzone-photos')
            ->viewData(fn($record) => [
              'product' => $record,
              'photos' => $record?->photos ?? collect(),
            ]),
        ]),
    ]);
  }
}