repomix-output.xml

This file is a merged representation of a subset of the codebase, containing files not matching ignore patterns, combined into a single document by Repomix.

<file_summary>
This section contains a summary of this file.

<purpose>
This file contains a packed representation of the entire repository's contents.
It is designed to be easily consumable by AI systems for analysis, code review,
or other automated processes.
</purpose>

<file_format>
The content is organized as follows:
1. This summary section
2. Repository information
3. Directory structure
4. Repository files (if enabled)
5. Multiple file entries, each consisting of:
  - File path as an attribute
  - Full contents of the file
</file_format>

<usage_guidelines>
- This file should be treated as read-only. Any changes should be made to the
  original repository files, not this packed version.
- When processing this file, use the file path to distinguish
  between different files in the repository.
- Be aware that this file may contain sensitive information. Handle it with
  the same level of security as you would the original repository.
</usage_guidelines>

<notes>
- Some files may have been excluded based on .gitignore rules and Repomix's configuration
- Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files
- Files matching these patterns are excluded: **/*.log, tmp/, .js, .html, .blade.php, .css, public/, vendor/, node_modules, venv/, logs/, electorn-sentinerl/
- Files matching patterns in .gitignore are excluded
- Files matching default ignore patterns are excluded
- Files are sorted by Git change count (files with more changes are at the bottom)
</notes>

</file_summary>

<directory_structure>
.claude/
  settings.local.json
.github/
  ISSUE_TEMPLATE/
    bug.yml
    config.yml
  workflows/
    dependabot-auto-merge.yml
    fix-php-code-styling.yml
    tests.yml
  CONTRIBUTING.md
  dependabot.yml
  FUNDING.yml
  SECURITY.md
config/
  filament-media-manager.php
database/
  migrations/
    2024_09_28_143941_add_media_if_not_exists_table.php
    2024_10_03_171807_create_folders_table.php
    2024_10_03_171808_create_media_has_models_table.php
    2024_10_03_171809_create_folder_has_models_table.php
    2024_10_03_171810_update_folders_table.php
    2024_10_20_000000_add_order_column_to_media_has_models_table.php
    2024_10_21_000000_add_collection_name_to_media_has_models_table.php
docs/
  TRAITS.md
resources/
  lang/
    ar/
      messages.php
    en/
      messages.php
    ru/
      messages.php
    tr/
      messages.php
  views/
    columns/
      media-preview.blade.php
    components/
      folder-action-view.blade.php
      media-picker-modal.blade.php
    forms/
      media-manager-picker.blade.php
    livewire/
      folder-component.blade.php
      media-picker.blade.php
    pages/
      folders.blade.php
      media.blade.php
routes/
  api.php
src/
  Console/
    FilamentMediaManagerInstall.php
  Facade/
    FilamentMediaManager.php
  Form/
    FileInput.php
    MediaManagerInput.php
    MediaManagerPicker.php
  Http/
    Controllers/
      FolderController.php
    Resources/
      FolderResource.php
      FoldersResource.php
      MediaResource.php
  Livewire/
    FolderComponent.php
    MediaPicker.php
  Models/
    Folder.php
    Media.php
  Resources/
    Actions/
      CreateMediaAction.php
      CreateSubFolderAction.php
      DeleteFolderAction.php
      EditCurrentFolderAction.php
    FolderResource/
      Pages/
        CreateFolder.php
        EditFolder.php
        ListFolders.php
    MediaResource/
      Pages/
        CreateMedia.php
        EditMedia.php
        ListMedia.php
    FolderResource.php
    MediaResource.php
  Services/
    Contracts/
      MediaManagerType.php
    FilamentMediaManagerServices.php
  Traits/
    InteractsWithMediaFolders.php
    InteractsWithMediaManager.php
  FilamentMediaManagerPlugin.php
  FilamentMediaManagerServiceProvider.php
tests/
  database/
    factories/
      FolderFactory.php
      ProductFactory.php
      UserFactory.php
    migrations/
      2025_10_07_000001_create_products_table.php
  src/
    Models/
      Product.php
      User.php
    AdminPanelProvider.php
    DebugTest.php
    FolderResourceTest.php
    InteractsWithMediaManagerTest.php
    LivewireComponentTest.php
    MediaManagerInputTest.php
    MediaManagerPickerTest.php
    MediaResourceTest.php
    PluginTest.php
    ProtectedFolderTest.php
    TestCase.php
  Pest.php
  README.md
.gitignore
.php-cs-fixer.dist.php
CHANGELOG.md
CODE_OF_CONDUCT.md
composer.json
fadymondy-tomato-media-manager.md
LICENSE.md
module.json
phpstan.neon
phpunit.xml
pint.json
README.md
testbench.yaml
</directory_structure>

<files>
This section contains the contents of the repository's files.

<file path=".claude/settings.local.json">
{
  "permissions": {
    "allow": [
      "Bash(tree -L 3 /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src -I \"node_modules\")",
      "Bash(vendor/bin/pint /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Traits/InteractsWithMediaManager.php)",
      "Bash(composer test)",
      "Bash(vendor/bin/pint /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Traits/InteractsWithMediaManager.php /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Livewire/MediaPicker.php /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Form/MediaManagerPicker.php)",
      "Bash(php artisan make:migration add_collection_name_to_media_has_models_table --path=database/migrations --no-interaction)",
      "Bash(vendor/bin/pint /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Traits/InteractsWithMediaManager.php /Users/fadymondy/Sites/3x1/vendor/tomatophp/filament-media-manager/src/Form/MediaManagerPicker.php)"
    ]
  },
  "enableAllProjectMcpServers": true,
  "enabledMcpjsonServers": [
    "laravel-boost",
    "herd",
    "puppeteer"
  ]
}
</file>

<file path="database/migrations/2024_10_21_000000_add_collection_name_to_media_has_models_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('media_has_models', function (Blueprint $table) {
            $table->string('collection_name')->nullable()->after('media_id');
            $table->boolean('responsive_images')->default(false)->after('collection_name');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('media_has_models', function (Blueprint $table) {
            $table->dropColumn(['collection_name', 'responsive_images']);
        });
    }
};
</file>

<file path=".github/ISSUE_TEMPLATE/bug.yml">
name: Bug Report
description: Report an Issue or Bug with the Package
title: "[Bug]: "
labels: ["bug"]
body:
  - type: markdown
    attributes:
      value: |
        We're sorry to hear you have a problem. Can you help us solve it by providing the following details.
  - type: textarea
    id: what-happened
    attributes:
      label: What happened?
      description: What did you expect to happen?
      placeholder: I cannot currently do X thing because when I do, it breaks X thing.
    validations:
      required: true
  - type: textarea
    id: how-to-reproduce
    attributes:
      label: How to reproduce the bug
      description: How did this occur, please add any config values used and provide a set of reliable steps if possible.
      placeholder: When I do X I see Y.
    validations:
      required: true
  - type: input
    id: package-version
    attributes:
      label: Package Version
      description: What version of our Package are you running? Please be as specific as possible
      placeholder: 2.0.0
    validations:
      required: true
  - type: input
    id: php-version
    attributes:
      label: PHP Version
      description: What version of PHP are you running? Please be as specific as possible
      placeholder: 8.2.0
    validations:
      required: true
  - type: input
    id: laravel-version
    attributes:
      label: Laravel Version
      description: What version of Laravel are you running? Please be as specific as possible
      placeholder: 9.0.0
    validations:
      required: true
  - type: dropdown
    id: operating-systems
    attributes:
      label: Which operating systems does with happen with?
      description: You may select more than one.
      multiple: true
      options:
        - macOS
        - Windows
        - Linux
  - type: textarea
    id: notes
    attributes:
      label: Notes
      description: Use this field to provide any other notes that you feel might be relevant to the issue.
    validations:
      required: false
</file>

<file path=".github/ISSUE_TEMPLATE/config.yml">
blank_issues_enabled: false
contact_links:
  - name: Ask a question
    url: https://github.com/tomatophp/filament-media-manager/discussions/new?category=q-a
    about: Ask the community for help
  - name: Request a feature
    url: https://github.com/tomatophp/filament-media-manager/discussions/new?category=ideas
    about: Share ideas for new features
  - name: Report a security issue
    url: https://github.com/tomatophp/filament-media-manager/security/policy
    about: Learn how to notify us for sensitive bugs
</file>

<file path=".github/workflows/dependabot-auto-merge.yml">
name: dependabot-auto-merge
on: pull_request_target

permissions:
  pull-requests: write
  contents: write

jobs:
  dependabot:
    runs-on: ubuntu-latest
    if: ${{ github.actor == 'dependabot[bot]' }}
    steps:

      - name: Dependabot metadata
        id: metadata
        uses: dependabot/fetch-metadata@v2.4.0
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"

      - name: Auto-merge Dependabot PRs for semver-minor updates
        if: ${{steps.metadata.outputs.update-type == 'version-update:semver-minor'}}
        run: gh pr merge --auto --merge "$PR_URL"
        env:
          PR_URL: ${{github.event.pull_request.html_url}}
          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

      - name: Auto-merge Dependabot PRs for semver-patch updates
        if: ${{steps.metadata.outputs.update-type == 'version-update:semver-patch'}}
        run: gh pr merge --auto --merge "$PR_URL"
        env:
          PR_URL: ${{github.event.pull_request.html_url}}
          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
</file>

<file path=".github/CONTRIBUTING.md">
# Contributing

Contributions are **welcome** and will be fully **credited**.

Please read and understand the contribution guide before creating an issue or pull request.

## Etiquette

This project is open source, and as such, the maintainers give their free time to build and maintain the source code
held within. They make the code freely available in the hope that it will be of use to other developers. It would be
extremely unfair for them to suffer abuse or anger for their hard work.

Please be considerate towards maintainers when raising issues or presenting pull requests. Let's show the
world that developers are civilized and selfless people.

It's the duty of the maintainer to ensure that all submissions to the project are of sufficient
quality to benefit the project. Many developers have different skills, strengths, and weaknesses. Respect the maintainer's decision, and do not be upset or abusive if your submission is not used.

## Viability

When requesting or submitting new features, first consider whether it might be useful to others. Open
source projects are used by many developers, who may have entirely different needs to your own. Think about
whether or not your feature is likely to be used by other users of the project.

## Procedure

Before filing an issue:

- Attempt to replicate the problem, to ensure that it wasn't a coincidental incident.
- Check to make sure your feature suggestion isn't already present within the project.
- Check the pull requests tab to ensure that the bug doesn't have a fix in progress.
- Check the pull requests tab to ensure that the feature isn't already in progress.

Before submitting a pull request:

- Check the codebase to ensure that your feature doesn't already exist.
- Check the pull requests to ensure that another person hasn't already submitted the feature or fix.

## Requirements

If the project maintainer has any additional requirements, you will find them listed here.

- **[PSR-2 Coding Standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)** - The easiest way to apply the conventions is to install [PHP Code Sniffer](https://pear.php.net/package/PHP_CodeSniffer).

- **Add tests!** - Your patch won't be accepted if it doesn't have tests.

- **Document any change in behaviour** - Make sure the `README.md` and any other relevant documentation are kept up-to-date.

- **Consider our release cycle** - We try to follow [SemVer v2.0.0](https://semver.org/). Randomly breaking public APIs is not an option.

- **One pull request per feature** - If you want to do more than one thing, send multiple pull requests.

- **Send coherent history** - Make sure each individual commit in your pull request is meaningful. If you had to make multiple intermediate commits while developing, please [squash them](https://www.git-scm.com/book/en/v2/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages) before submitting.

**Happy coding**!
</file>

<file path=".github/dependabot.yml">
# Please see the documentation for all configuration options:
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates

version: 2
updates:

  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
    labels:
      - "dependencies"
</file>

<file path=".github/SECURITY.md">
# Security Policy

If you discover any security related issues, please email info@3x1.io instead of using the issue tracker.
</file>

<file path="database/migrations/2024_09_28_143941_add_media_if_not_exists_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        if (! Schema::hasTable('media')) {
            Schema::create('media', function (Blueprint $table) {
                $table->id();

                $table->morphs('model');
                $table->uuid()->nullable()->unique();
                $table->string('collection_name');
                $table->string('name');
                $table->string('file_name');
                $table->string('mime_type')->nullable();
                $table->string('disk');
                $table->string('conversions_disk')->nullable();
                $table->unsignedBigInteger('size');
                $table->json('manipulations');
                $table->json('custom_properties');
                $table->json('generated_conversions');
                $table->json('responsive_images');
                $table->unsignedInteger('order_column')->nullable()->index();

                $table->nullableTimestamps();
            });
        }
    }
};
</file>

<file path="database/migrations/2024_10_03_171810_update_folders_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('folders', function (Blueprint $table) {
            $table->boolean('is_public')->default(true)->nullable();
            $table->boolean('has_user_access')->default(false)->nullable();
            $table->unsignedBigInteger('user_id')->nullable();
            $table->string('user_type')->nullable();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('folders', function (Blueprint $table) {
            $table->dropColumn('is_public');
            $table->dropColumn('has_user_access');
            $table->dropColumn('user_id');
            $table->dropColumn('user_type');
        });
    }
};
</file>

<file path="database/migrations/2024_10_20_000000_add_order_column_to_media_has_models_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::table('media_has_models', function (Blueprint $table) {
            $table->unsignedInteger('order_column')->nullable()->after('media_id');
            $table->index('order_column');
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::table('media_has_models', function (Blueprint $table) {
            $table->dropIndex(['order_column']);
            $table->dropColumn('order_column');
        });
    }
};
</file>

<file path="docs/TRAITS.md">
# Media Manager Traits

## InteractsWithMediaManager

The `InteractsWithMediaManager` trait provides convenient methods to interact with media attached to your models via both **MediaManagerPicker** and **MediaManagerInput** (Spatie Media Library).

### Installation

Add the trait to your model:

```php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaManager;

class Product extends Model
{
    use InteractsWithMediaManager;

    // ... your model code
}
```

---

## Available Methods

### 1. Get All Media (MediaManagerPicker)

Get all media attached to the model via MediaManagerPicker:

```php
$product = Product::find(1);
$mediaItems = $product->getMediaManagerMedia();

// Get media filtered by field name (if stored in custom properties)
$avatarMedia = $product->getMediaManagerMedia('avatar');
```

**Returns:** `Illuminate\Database\Eloquent\Collection` of Media models

---

### 2. Get Media by UUIDs

Get specific media items by their UUIDs:

```php
$uuids = ['uuid-1', 'uuid-2', 'uuid-3'];
$mediaItems = $product->getMediaManagerMediaByUuids($uuids);
```

**Returns:** `Illuminate\Database\Eloquent\Collection` of Media models

---

### 3. Get Media from Spatie Collection (MediaManagerInput)

Get media from a Spatie Media Library collection:

```php
// Get all media from 'images' collection
$images = $product->getMediaManagerInputMedia('images');

// Get from default collection
$defaultMedia = $product->getMediaManagerInputMedia();
```

**Returns:** `Illuminate\Database\Eloquent\Collection` of Media models

---

### 4. Attach Media

Attach media to the model programmatically:

```php
$uuids = ['uuid-1', 'uuid-2'];
$product->attachMediaManagerMedia($uuids);
```

---

### 5. Detach Media

Detach specific media or all media:

```php
// Detach specific media
$product->detachMediaManagerMedia(['uuid-1', 'uuid-2']);

// Detach all media
$product->detachMediaManagerMedia();
```

---

### 6. Sync Media

Replace all existing media with new media (detach all, then attach new):

```php
$newUuids = ['uuid-3', 'uuid-4', 'uuid-5'];
$product->syncMediaManagerMedia($newUuids);
```

---

### 7. Check if Media Exists

Check if a specific media is attached to the model:

```php
if ($product->hasMediaManagerMedia('uuid-1')) {
    // Media is attached
}
```

**Returns:** `bool`

---

### 8. Get First Media

Get the first media item attached to the model:

```php
$firstMedia = $product->getFirstMediaManagerMedia();

if ($firstMedia) {
    echo $firstMedia->name;
}
```

**Returns:** `Media|null`

---

### 9. Get Media URL

Get the URL of the first media item:

```php
// Get original URL
$url = $product->getMediaManagerUrl();

// Get URL of a specific conversion
$thumbUrl = $product->getMediaManagerUrl('thumb');
```

**Returns:** `string|null`

---

### 10. Get All Media URLs

Get URLs of all media items:

```php
// Get all original URLs
$urls = $product->getMediaManagerUrls();

// Get all thumbnail URLs
$thumbUrls = $product->getMediaManagerUrls('thumb');
```

**Returns:** `array`

---

## Usage Examples

### Example 1: Display Product Images

```php
@php
    $product = App\Models\Product::find(1);
    $images = $product->getMediaManagerMedia();
@endphp

<div class="product-gallery">
    @foreach($images as $image)
        <img src="{{ $image->getUrl('thumb') }}" alt="{{ $image->name }}">
    @endforeach
</div>
```

### Example 2: Display User Avatar

```php
@php
    $user = auth()->user();
    $avatarUrl = $user->getMediaManagerUrl('avatar-thumb') ?? '/default-avatar.png';
@endphp

<img src="{{ $avatarUrl }}" alt="User Avatar" class="avatar">
```

### Example 3: Attach Media in Controller

```php
public function attachFiles(Request $request, Product $product)
{
    $mediaUuids = $request->input('media_uuids');
    $product->attachMediaManagerMedia($mediaUuids);

    return back()->with('success', 'Files attached successfully');
}
```

### Example 4: Sync Media on Update

```php
public function update(Request $request, Product $product)
{
    $product->update($request->only(['name', 'description']));

    // Sync media (replace all existing with new selection)
    if ($request->has('gallery_media')) {
        $product->syncMediaManagerMedia($request->input('gallery_media'));
    }

    return back()->with('success', 'Product updated successfully');
}
```

### Example 5: Check and Display

```php
@if($product->hasMediaManagerMedia($specificUuid))
    <div class="badge">Featured Image Set</div>
@endif

@php
    $featuredImage = $product->getFirstMediaManagerMedia();
@endphp

@if($featuredImage)
    <img src="{{ $featuredImage->getUrl() }}" alt="Featured">
@endif
```

---

## Notes

- All methods that query media bypass the global `folder` scope to ensure you get the correct media
- The `attachMediaManagerMedia()` method uses `updateOrInsert` to prevent duplicates
- Media URLs can be generated with conversions (e.g., `thumb`, `medium`, `large`) if configured in Spatie Media Library
- The trait works with both **MediaManagerPicker** (form component) and **MediaManagerInput** (Spatie collections)

---

## Advanced: Custom Field Names

You can store a field name in the media's custom properties to distinguish between different picker fields:

```php
// When saving, store the field name
$media->setCustomProperty('field_name', 'avatar');
$media->save();

// Later, retrieve only avatar media
$avatarMedia = $user->getMediaManagerMedia('avatar');
```

This is useful when a model has multiple MediaManagerPicker fields and you need to distinguish between them programmatically.
</file>

<file path="resources/views/components/media-picker-modal.blade.php">
@livewire('media-picker', [
    'pickerKey' => $pickerKey,
    'isMultiple' => $isMultiple,
    'collectionName' => $collectionName,
    'maxItems' => $maxItems ?? null,
    'minItems' => $minItems ?? null,
    'initialState' => $currentState ?? null,
])
</file>

<file path="resources/views/livewire/folder-component.blade.php">
<div>
    {{ ($this->getFolderAction)(['item' => $item]) }}

    <x-filament-actions::modals />
</div>
</file>

<file path="src/Http/Resources/FoldersResource.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class FoldersResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'color' => $this->color,
            'icon' => $this->icon,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}
</file>

<file path="src/Livewire/FolderComponent.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Livewire;

use Filament\Actions\Action;
use Filament\Actions\Concerns\InteractsWithActions;
use Filament\Actions\Contracts\HasActions;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Schemas\Concerns\InteractsWithSchemas;
use Filament\Schemas\Contracts\HasSchemas;
use Livewire\Component;

class FolderComponent extends Component implements HasActions, HasSchemas
{
    use InteractsWithActions;
    use InteractsWithSchemas;

    public $item;

    public function mount($item): void
    {
        $this->item = $item;
    }

    public function getFolderAction(): Action
    {
        return Action::make('getFolderAction')
            ->color('danger')
            ->view('filament-media-manager::components.folder-action-view', fn (array $arguments) => ['item' => $arguments['item']])
            ->requiresConfirmation(function (array $arguments) {
                if (isset($arguments['item'])) {
                    if ($arguments['item']['is_protected']) {
                        return true;
                    } else {
                        return false;
                    }
                }
            })
            ->schema(function (array $arguments) {
                if (isset($arguments['item'])) {
                    if ($arguments['item']['is_protected']) {
                        return [
                            TextInput::make('password')
                                ->password()
                                ->revealable()
                                ->required()
                                ->maxLength(255),
                        ];
                    } else {
                        return null;
                    }
                }
            })
            ->action(function (array $arguments, array $data) {
                if (isset($arguments['item'])) {
                    if ($arguments['item']['is_protected']) {
                        if ($arguments['item']['password'] != $data['password']) {
                            Notification::make()
                                ->title('Password is incorrect')
                                ->danger()
                                ->send();

                            return;
                        } else {
                            session()->put('folder_password', $data['password']);
                        }
                    }
                    if (! $arguments['item']['model_type']) {
                        if (filament()->getTenant()) {
                            return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/media?folder_id=' . $arguments['item']['id']));
                        } else {
                            return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.media.index', ['folder_id' => $arguments['item']['id']]);
                        }
                    }
                    if (! $arguments['item']['model_id'] && ! $arguments['item']['collection']) {
                        if (filament()->getTenant()) {
                            return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/folders?model_type=' . $arguments['item']['model_type']));
                        } else {
                            return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.folders.index', ['model_type' => $arguments['item']['model_type']]);
                        }
                    } elseif (! $arguments['item']['model_id']) {
                        if (filament()->getTenant()) {
                            return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/folders?model_type=' . $arguments['item']['model_type'] . '&collection=' . $arguments['item']['collection']));
                        } else {
                            return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.folders.index', ['model_type' => $arguments['item']['model_type'], 'collection' => $arguments['item']['collection']]);
                        }
                    } else {
                        if (filament()->getTenant()) {
                            return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/media?folder_id=' . $arguments['item']['id']));
                        } else {
                            return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.media.index', ['folder_id' => $arguments['item']['id']]);
                        }
                    }
                }
            });
    }

    public function render(): mixed
    {
        return view('filament-media-manager::livewire.folder-component');
    }
}
</file>

<file path="tests/database/factories/FolderFactory.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests\Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;
use TomatoPHP\FilamentMediaManager\Models\Folder;

class FolderFactory extends Factory
{
    protected $model = Folder::class;

    public function definition(): array
    {
        $name = $this->faker->words(2, true);

        return [
            'name' => $name,
            'collection' => Str::slug($name),
            'description' => $this->faker->sentence(),
            'icon' => 'heroicon-o-folder',
            'color' => $this->faker->hexColor(),
            'is_protected' => false,
            'password' => null,
        ];
    }

    public function protected(string $password = 'secret123'): self
    {
        return $this->state(function (array $attributes) use ($password) {
            return [
                'is_protected' => true,
                'password' => $password,
            ];
        });
    }

    public function withPassword(string $password): self
    {
        return $this->state(function (array $attributes) use ($password) {
            return [
                'password' => $password,
            ];
        });
    }

    public function public(): self
    {
        return $this->state(function (array $attributes) {
            return [
                'is_protected' => false,
                'password' => null,
            ];
        });
    }
}
</file>

<file path="tests/database/factories/ProductFactory.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests\Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;
use TomatoPHP\FilamentMediaManager\Tests\Models\Product;

class ProductFactory extends Factory
{
    protected $model = Product::class;

    public function definition(): array
    {
        return [
            'name' => $this->faker->words(3, true),
            'description' => $this->faker->paragraph(),
        ];
    }
}
</file>

<file path="tests/database/factories/UserFactory.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests\Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition(): array
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];
    }
}
</file>

<file path="tests/database/migrations/2025_10_07_000001_create_products_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('products');
    }
};
</file>

<file path="tests/src/Models/Product.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;
use TomatoPHP\FilamentMediaManager\Tests\Database\Factories\ProductFactory;
use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaManager;

class Product extends Model implements HasMedia
{
    use HasFactory;
    use InteractsWithMedia;
    use InteractsWithMediaManager;

    protected $guarded = [];

    protected $table = 'products';

    protected static function newFactory(): ProductFactory
    {
        return ProductFactory::new();
    }
}
</file>

<file path="tests/src/Models/User.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests\Models;

use Filament\Models\Contracts\FilamentUser;
use Filament\Panel;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use TomatoPHP\FilamentMediaManager\Tests\Database\Factories\UserFactory;

class User extends Authenticatable implements FilamentUser, MustVerifyEmail
{
    use HasFactory;
    use Notifiable;

    protected $guarded = [];

    protected $hidden = [
        'password',
        'remember_token',
    ];

    public function canAccessPanel(Panel $panel): bool
    {
        return true;
    }

    protected static function newFactory(): UserFactory
    {
        return UserFactory::new();
    }
}
</file>

<file path="tests/src/AdminPanelProvider.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Filament\Http\Middleware\Authenticate;
use Filament\Http\Middleware\DisableBladeIconComponents;
use Filament\Http\Middleware\DispatchServingFilamentEvent;
use Filament\Pages;
use Filament\Panel;
use Filament\PanelProvider;
use Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse;
use Illuminate\Cookie\Middleware\EncryptCookies;
use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken;
use Illuminate\Routing\Middleware\SubstituteBindings;
use Illuminate\Session\Middleware\AuthenticateSession;
use Illuminate\Session\Middleware\StartSession;
use Illuminate\View\Middleware\ShareErrorsFromSession;
use TomatoPHP\FilamentMediaManager\FilamentMediaManagerPlugin;

class AdminPanelProvider extends PanelProvider
{
    public function panel(Panel $panel): Panel
    {
        return $panel
            ->default()
            ->id('admin')
            ->path('admin')
            ->login()
            ->pages([
                Pages\Dashboard::class,
            ])
            ->plugin(
                FilamentMediaManagerPlugin::make()
            )
            ->middleware([
                EncryptCookies::class,
                AddQueuedCookiesToResponse::class,
                StartSession::class,
                AuthenticateSession::class,
                ShareErrorsFromSession::class,
                VerifyCsrfToken::class,
                SubstituteBindings::class,
                DisableBladeIconComponents::class,
                DispatchServingFilamentEvent::class,
            ])
            ->authMiddleware([
                Authenticate::class,
            ]);
    }
}
</file>

<file path="tests/src/DebugTest.php">
<?php

it('will not use debugging functions', function () {
    expect(['dd', 'dump', 'ray'])->each->not->toBeUsed();
});
</file>

<file path="tests/src/FolderResourceTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Filament\Actions\EditAction;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource\Pages;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;
use function Pest\Laravel\assertDatabaseHas;
use function Pest\Laravel\assertModelMissing;
use function Pest\Laravel\get;
use function Pest\Livewire\livewire;

beforeEach(function () {
    actingAs(User::factory()->create());

    $this->panel->resources([
        FolderResource::class,
    ]);
});

it('can render folder resource', function () {
    get(FolderResource::getUrl())->assertSuccessful();
});

it('can list folders', function () {
    Folder::factory()->count(10)->create();

    livewire(Pages\ListFolders::class)
        ->assertSuccessful();
});

it('can render folder name/collection columns in table', function () {
    Folder::factory()->count(10)->create();

    livewire(Pages\ListFolders::class)
        ->assertSuccessful();
});

it('can render folder list page', function () {
    livewire(Pages\ListFolders::class)->assertSuccessful();
});

it('can render folder create action', function () {
    livewire(Pages\ListFolders::class)
        ->callAction('create')
        ->assertSuccessful();
});

it('can create new folder', function () {
    livewire(Pages\ListFolders::class)
        ->callAction('create', data: [
            'name' => 'Test Folder',
            'collection' => 'test-folder',
            'description' => 'Test Description',
            'icon' => 'heroicon-o-folder',
            'color' => '#f3c623',
            'is_protected' => false,
        ])
        ->assertHasNoActionErrors();

    assertDatabaseHas(Folder::class, [
        'name' => 'Test Folder',
        'collection' => 'test-folder',
    ]);
});

it('can create protected folder with password', function () {
    livewire(Pages\ListFolders::class)
        ->callAction('create', data: [
            'name' => 'Protected Folder',
            'collection' => 'protected-folder',
            'description' => 'Protected Description',
            'icon' => 'heroicon-o-folder',
            'color' => '#f3c623',
            'is_protected' => true,
            'password' => 'secret123',
            'password_confirmation' => 'secret123',
        ])
        ->assertHasNoActionErrors();

    assertDatabaseHas(Folder::class, [
        'name' => 'Protected Folder',
        'is_protected' => true,
    ]);
});

it('can validate folder input', function () {
    livewire(Pages\ListFolders::class)
        ->callAction('create', data: [
            'name' => null,
            'collection' => null,
        ])
        ->assertHasActionErrors([
            'name' => 'required',
            'collection' => 'required',
        ]);
});

it('can render folder edit action', function () {
    $folder = Folder::factory()->create();

    livewire(Pages\ListFolders::class)
        ->mountTableAction('edit', $folder)
        ->assertSuccessful();
});

it('can retrieve folder data', function () {
    $folder = Folder::factory()->create();

    livewire(Pages\ListFolders::class)
        ->mountTableAction(EditAction::class, $folder)
        ->assertTableActionDataSet([
            'name' => $folder->name,
            'collection' => $folder->collection,
        ])
        ->assertHasNoTableActionErrors();
});

it('can validate edit folder input', function () {
    $folder = Folder::factory()->create();

    livewire(Pages\ListFolders::class)
        ->callTableAction('edit', $folder, [
            'name' => null,
            'collection' => null,
        ])
        ->assertHasTableActionErrors([
            'name' => 'required',
            'collection' => 'required',
        ]);
});

it('can save folder data', function () {
    $folder = Folder::factory()->create();

    livewire(Pages\ListFolders::class)
        ->callTableAction('edit', $folder, data: [
            'name' => 'Updated Folder',
            'collection' => 'updated-folder',
            'description' => 'Updated Description',
        ])
        ->assertHasNoTableActionErrors();

    expect($folder->refresh())
        ->name->toBe('Updated Folder')
        ->collection->toBe('updated-folder');
});

it('can delete folder', function () {
    $folder = Folder::factory()->create();

    livewire(Pages\ListFolders::class)
        ->callTableAction('delete', $folder)
        ->assertHasNoTableActionErrors();

    assertModelMissing($folder);
});

it('can filter folders by protected status', function () {
    Folder::factory()->count(5)->create(['is_protected' => true]);
    Folder::factory()->count(5)->create(['is_protected' => false]);

    livewire(Pages\ListFolders::class)
        ->assertSuccessful();
});
</file>

<file path="tests/src/LivewireComponentTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use TomatoPHP\FilamentMediaManager\Livewire\FolderComponent;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;
use function Pest\Livewire\livewire;

beforeEach(function () {
    actingAs(User::factory()->create());
});

it('can render folder component', function () {
    $folder = Folder::factory()->create();

    livewire(FolderComponent::class, ['item' => $folder])
        ->assertSuccessful();
});

it('can mount folder action', function () {
    $folder = Folder::factory()->create();

    livewire(FolderComponent::class, ['item' => $folder])
        ->assertActionExists('getFolderAction');
});

it('shows password form for protected folder', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    livewire(FolderComponent::class, ['item' => $folder])
        ->assertSee('getFolderAction');
});

it('does not show password form for public folder', function () {
    $folder = Folder::factory()->create([
        'is_protected' => false,
    ]);

    expect($folder->is_protected)->toBeFalse();
});

it('validates password input is required for protected folders', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    expect($folder->is_protected)->toBeTrue();
    expect($folder->password)->not->toBeEmpty();
});
</file>

<file path="tests/src/MediaManagerInputTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use TomatoPHP\FilamentMediaManager\Form\MediaManagerInput;
use TomatoPHP\FilamentMediaManager\Tests\Models\Product;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;

beforeEach(function () {
    Storage::fake('public');
    actingAs(User::factory()->create());
});

describe('MediaManagerInput Component', function () {
    it('can be instantiated', function () {
        $field = MediaManagerInput::make('images');

        expect($field)->toBeInstanceOf(MediaManagerInput::class);
    });

    it('can set disk', function () {
        $field = MediaManagerInput::make('images')->disk('public');

        expect($field->getDiskName())->toBe('public');
    });

    it('can be configured as single file', function () {
        $field = MediaManagerInput::make('image')->single();

        // Single method exists and returns static
        expect($field)->toBeInstanceOf(MediaManagerInput::class);
    });

    it('can set custom schema', function () {
        $field = MediaManagerInput::make('images')->schema([
            \Filament\Forms\Components\TextInput::make('title'),
        ]);

        expect($field)->toBeInstanceOf(MediaManagerInput::class);
    });
});

describe('MediaManagerInput File Upload', function () {
    it('can upload single file', function () {
        $product = Product::create(['name' => 'Test Product']);
        $file = UploadedFile::fake()->image('test.jpg');

        $media = $product->addMedia($file)->toMediaCollection('images');

        expect($media)->not->toBeNull();
        expect($media->collection_name)->toBe('images');
        expect($media->file_name)->toBe('test.jpg');
    });

    it('can upload multiple files', function () {
        $product = Product::create(['name' => 'Test Product']);
        $files = [
            UploadedFile::fake()->image('test1.jpg'),
            UploadedFile::fake()->image('test2.jpg'),
            UploadedFile::fake()->image('test3.jpg'),
        ];

        foreach ($files as $file) {
            $product->addMedia($file)->toMediaCollection('images');
        }

        $mediaCount = $product->getMedia('images')->count();

        expect($mediaCount)->toBe(3);
    });

    it('stores files in correct disk', function () {
        $product = Product::create(['name' => 'Test Product']);
        $file = UploadedFile::fake()->image('test.jpg');

        $media = $product->addMedia($file)
            ->toMediaCollection('images', 'public');

        expect($media->disk)->toBe('public');
    });

    it('stores files with custom properties', function () {
        $product = Product::create(['name' => 'Test Product']);
        $file = UploadedFile::fake()->image('test.jpg');

        $media = $product->addMedia($file)
            ->withCustomProperties([
                'title' => 'Test Image',
                'description' => 'A test image description',
            ])
            ->toMediaCollection('images');

        expect($media->getCustomProperty('title'))->toBe('Test Image');
        expect($media->getCustomProperty('description'))->toBe('A test image description');
    });
});

describe('MediaManagerInput Media Retrieval', function () {
    it('can get all media from collection', function () {
        $product = Product::create(['name' => 'Test Product']);

        $product->addMedia(UploadedFile::fake()->image('test1.jpg'))->toMediaCollection('images');
        $product->addMedia(UploadedFile::fake()->image('test2.jpg'))->toMediaCollection('images');
        $product->addMedia(UploadedFile::fake()->image('test3.jpg'))->toMediaCollection('documents');

        $images = $product->getMedia('images');

        expect($images)->toHaveCount(2);
    });

    it('can get first media from collection', function () {
        $product = Product::create(['name' => 'Test Product']);

        $product->addMedia(UploadedFile::fake()->image('test1.jpg'))->toMediaCollection('images');
        $product->addMedia(UploadedFile::fake()->image('test2.jpg'))->toMediaCollection('images');

        $firstImage = $product->getFirstMedia('images');

        expect($firstImage)->not->toBeNull();
        expect($firstImage->file_name)->toBe('test1.jpg');
    });

    it('can get media url', function () {
        $product = Product::create(['name' => 'Test Product']);

        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $url = $media->getUrl();

        expect($url)->not->toBeNull();
        expect($url)->toContain('test.jpg');
    });

    it('can check if media exists', function () {
        $product = Product::create(['name' => 'Test Product']);

        $product->addMedia(UploadedFile::fake()->image('test.jpg'))->toMediaCollection('images');

        expect($product->hasMedia('images'))->toBeTrue();
        expect($product->hasMedia('videos'))->toBeFalse();
    });
});

describe('MediaManagerInput Media Deletion', function () {
    it('can delete single media', function () {
        $product = Product::create(['name' => 'Test Product']);

        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $mediaId = $media->id;
        $media->delete();

        $exists = $product->getMedia('images')->contains('id', $mediaId);

        expect($exists)->toBeFalse();
    });

    it('can clear media collection', function () {
        $product = Product::create(['name' => 'Test Product']);

        $product->addMedia(UploadedFile::fake()->image('test1.jpg'))->toMediaCollection('images');
        $product->addMedia(UploadedFile::fake()->image('test2.jpg'))->toMediaCollection('images');

        expect($product->getMedia('images'))->toHaveCount(2);

        $product->clearMediaCollection('images');

        expect($product->getMedia('images'))->toHaveCount(0);
    });

    it('cascade deletes media when model is deleted', function () {
        $product = Product::create(['name' => 'Test Product']);

        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $mediaId = $media->id;
        $product->delete();

        $mediaExists = \TomatoPHP\FilamentMediaManager\Models\Media::find($mediaId);

        expect($mediaExists)->toBeNull();
    });
});

describe('MediaManagerInput with Custom Schema', function () {
    it('can use custom schema for file metadata', function () {
        $field = MediaManagerInput::make('images')
            ->schema([
                \Filament\Forms\Components\TextInput::make('title')
                    ->required()
                    ->maxLength(255),
                \Filament\Forms\Components\Textarea::make('description')
                    ->maxLength(500),
            ]);

        expect($field)->toBeInstanceOf(MediaManagerInput::class);
    });

    it('saves custom properties from schema', function () {
        $product = Product::create(['name' => 'Test Product']);
        $file = UploadedFile::fake()->image('test.jpg');

        $media = $product->addMedia($file)
            ->withCustomProperties([
                'title' => 'Product Image',
                'description' => 'Main product photo',
            ])
            ->toMediaCollection('images');

        expect($media->getCustomProperty('title'))->toBe('Product Image');
        expect($media->getCustomProperty('description'))->toBe('Main product photo');
    });
});

describe('MediaManagerInput with Conversions', function () {
    it('can register media conversions', function () {
        $product = Product::create(['name' => 'Test Product']);

        // Note: This would require setting up conversion in the model
        // For testing purposes, we just verify the media is created
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        expect($media)->not->toBeNull();
    });

    it('can get conversion url', function () {
        $product = Product::create(['name' => 'Test Product']);

        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        // Get the original URL (conversion would work if defined in model)
        $url = $media->getUrl();

        expect($url)->not->toBeNull();
    });
});
</file>

<file path="tests/src/MediaManagerPickerTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use TomatoPHP\FilamentMediaManager\Form\MediaManagerPicker;
use TomatoPHP\FilamentMediaManager\Livewire\MediaPicker;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Models\Media;
use TomatoPHP\FilamentMediaManager\Tests\Models\Product;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;
use function Pest\Livewire\livewire;

beforeEach(function () {
    Storage::fake('public');
    actingAs(User::factory()->create());
});

describe('MediaManagerPicker Component', function () {
    it('can be instantiated', function () {
        $field = MediaManagerPicker::make('media');

        expect($field)->toBeInstanceOf(MediaManagerPicker::class);
    });

    it('can be configured as multiple selection', function () {
        $field = MediaManagerPicker::make('media')->multiple();

        expect($field->isMultiple())->toBeTrue();
    });

    it('can be configured as single selection', function () {
        $field = MediaManagerPicker::make('media')->single();

        expect($field->isMultiple())->toBeFalse();
    });

    it('can set max items', function () {
        $field = MediaManagerPicker::make('media')->maxItems(5);

        expect($field->getMaxItems())->toBe(5);
    });

    it('can set min items', function () {
        $field = MediaManagerPicker::make('media')->minItems(2);

        expect($field->getMinItems())->toBe(2);
    });

    it('can set collection name', function () {
        $field = MediaManagerPicker::make('media')->collection('products');

        expect($field->getCollectionName())->toBe('products');
    });

    it('has browse action', function () {
        $field = MediaManagerPicker::make('media');
        $action = $field->getBrowseAction();

        expect($action)->not->toBeNull();
        expect($action->getName())->toBe('getBrowseAction');
    });

    it('has remove action', function () {
        $field = MediaManagerPicker::make('media');
        $action = $field->getRemoveAction();

        expect($action)->not->toBeNull();
        expect($action->getName())->toBe('getRemoveAction');
    });

    it('has remove media item action', function () {
        $field = MediaManagerPicker::make('media');
        $action = $field->getRemoveMediaItemAction();

        expect($action)->not->toBeNull();
        expect($action->getName())->toBe('removeMediaItem');
    });
});

describe('MediaPicker Livewire Component', function () {
    it('can render', function () {
        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])->assertSuccessful();
    });

    it('initializes with correct properties', function () {
        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
            'maxItems' => 5,
            'minItems' => 2,
        ])
            ->assertSet('pickerKey', 'test-picker')
            ->assertSet('isMultiple', true)
            ->assertSet('maxItems', 5)
            ->assertSet('minItems', 2);
    });

    it('can open folder', function () {
        $folder = Folder::factory()->create();

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->call('openFolder', $folder->id)
            ->assertSet('currentFolderId', $folder->id);
    });

    it('can go back to root from folder', function () {
        $folder = Folder::factory()->create();

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->set('currentFolderId', $folder->id)
            ->call('goBack')
            ->assertSet('currentFolderId', null); // Goes back to root
    });

    it('enforces max items limit', function () {
        $product = Product::create(['name' => 'Test Product']);
        $folder = Folder::factory()->create([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'collection' => 'images',
        ]);

        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
            'maxItems' => 1,
        ])
            ->call('toggleMediaSelection', $media1->uuid)
            ->assertSet('selectedMedia', [$media1->uuid])
            ->call('toggleMediaSelection', $media2->uuid)
            ->assertSet('selectedMedia', [$media1->uuid]) // Should not add second item
            ->assertNotified(); // Should show warning notification
    });

    it('validates min items requirement', function () {
        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
            'minItems' => 2,
        ])
            ->set('selectedMedia', ['uuid-1'])
            ->call('selectMedia')
            ->assertNotified(); // Should show warning notification
    });

    it('can toggle media selection in multiple mode', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->call('toggleMediaSelection', $media->uuid)
            ->assertSet('selectedMedia', [$media->uuid])
            ->call('toggleMediaSelection', $media->uuid)
            ->assertSet('selectedMedia', []); // Deselected
    });

    it('auto-selects in single mode', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => false,
        ])
            ->call('toggleMediaSelection', $media->uuid)
            ->assertNotified(); // Should show success notification
    });

    it('can remove selection', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->set('selectedMedia', [$media->uuid])
            ->call('removeSelection', $media->uuid)
            ->assertSet('selectedMedia', []);
    });

    it('can search folders and media', function () {
        $folder = Folder::factory()->create(['name' => 'Test Folder']);

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->set('search', 'Test')
            ->assertSee('Test Folder');
    });
});

describe('MediaManagerPicker with Password Protected Folders', function () {
    it('prompts for password on protected folder', function () {
        $folder = Folder::factory()->create([
            'is_protected' => true,
            'password' => 'secret123',
        ]);

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->call('openFolder', $folder->id)
            ->assertActionMounted('verifyPassword');
    });

    it('opens folder with correct password', function () {
        $folder = Folder::factory()->create([
            'is_protected' => true,
            'password' => 'secret123',
        ]);

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->call('openFolder', $folder->id)
            ->assertSet('pendingFolderId', $folder->id)
            ->callMountedAction(['password' => 'secret123'])
            ->assertNotified(); // Should show "Access granted" notification
    });

    it('rejects incorrect password', function () {
        $folder = Folder::factory()->create([
            'is_protected' => true,
            'password' => 'secret123',
        ]);

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->call('openFolder', $folder->id)
            ->callMountedAction(['password' => 'wrong-password'])
            ->assertSet('currentFolderId', null)
            ->assertNotified();
    });
});

describe('MediaManagerPicker State Hydration', function () {
    it('loads existing media on edit', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        // Attach media via pivot table
        DB::table('media_has_models')->insert([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'media_id' => $media->id,
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        $field = MediaManagerPicker::make('media')->multiple();

        // Simulate afterStateHydrated
        $field->afterStateHydrated(function (MediaManagerPicker $component) use ($product) {
            $mediaIds = DB::table('media_has_models')
                ->where('model_type', Product::class)
                ->where('model_id', $product->id)
                ->pluck('media_id')
                ->toArray();

            $mediaCollection = Media::whereIn('id', $mediaIds)->get();
            $component->state($mediaCollection->pluck('uuid')->toArray());
        });

        expect($field)->toBeInstanceOf(MediaManagerPicker::class);
    });
});

describe('MediaManagerPicker Upload', function () {
    it('can upload files directly from picker', function () {
        $product = Product::create(['name' => 'Test Product']);
        $folder = Folder::factory()->create([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'collection' => 'images',
        ]);

        $file = UploadedFile::fake()->image('test.jpg');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->set('currentFolderId', $folder->id)
            ->callAction('uploadMedia', ['files' => [$file]])
            ->assertHasNoActionErrors();
    });

    it('auto-selects uploaded media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $folder = Folder::factory()->create([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'collection' => 'images',
        ]);

        $file = UploadedFile::fake()->image('test.jpg');

        livewire(MediaPicker::class, [
            'pickerKey' => 'test-picker',
            'isMultiple' => true,
        ])
            ->set('currentFolderId', $folder->id)
            ->callAction('uploadMedia', ['files' => [$file]])
            ->assertSet('selectedMedia', function ($selectedMedia) {
                return count($selectedMedia) === 1;
            });
    });
});
</file>

<file path="tests/src/MediaResourceTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Illuminate\Support\Facades\Storage;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Models\Media;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;
use function Pest\Laravel\get;

beforeEach(function () {
    actingAs(User::factory()->create());

    $this->panel->resources([
        MediaResource::class,
    ]);

    Storage::fake('public');
});

it('can render media resource with folder id', function () {
    $folder = Folder::factory()->create([
        'is_protected' => false,
    ]);

    session()->put('folder_id', $folder->id);

    get(MediaResource::getUrl('index') . '?folder_id=' . $folder->id)
        ->assertSuccessful();
});

it('can list media items', function () {
    $folder = Folder::factory()->create();

    session()->put('folder_id', $folder->id);

    // Create test media items
    for ($i = 0; $i < 5; $i++) {
        Media::create([
            'model_type' => Folder::class,
            'model_id' => $folder->id,
            'name' => "test-file-{$i}",
            'file_name' => "test-{$i}.jpg",
            'mime_type' => 'image/jpeg',
            'disk' => 'public',
            'size' => 1024,
            'collection_name' => $folder->collection,
            'manipulations' => [],
            'custom_properties' => [],
            'generated_conversions' => [],
            'responsive_images' => [],
        ]);
    }

    expect(Media::where('collection_name', $folder->collection)->count())->toBe(5);
});

it('can handle media with custom properties', function () {
    $folder = Folder::factory()->create();

    $media = Media::create([
        'model_type' => Folder::class,
        'model_id' => $folder->id,
        'name' => 'test-file',
        'file_name' => 'test.jpg',
        'mime_type' => 'image/jpeg',
        'disk' => 'public',
        'size' => 1024,
        'collection_name' => $folder->collection,
        'manipulations' => [],
        'custom_properties' => [
            'title' => 'Test Title',
            'description' => 'Test Description',
            'alt' => 'Test Alt',
        ],
        'generated_conversions' => [],
        'responsive_images' => [],
    ]);

    expect($media->getCustomProperty('title'))->toBe('Test Title');
    expect($media->getCustomProperty('description'))->toBe('Test Description');
    expect($media->getCustomProperty('alt'))->toBe('Test Alt');
});

it('can edit media properties', function () {
    $folder = Folder::factory()->create();

    $media = Media::create([
        'model_type' => Folder::class,
        'model_id' => $folder->id,
        'name' => 'test-file',
        'file_name' => 'test.jpg',
        'mime_type' => 'image/jpeg',
        'disk' => 'public',
        'size' => 1024,
        'collection_name' => $folder->collection,
        'manipulations' => [],
        'custom_properties' => [],
        'generated_conversions' => [],
        'responsive_images' => [],
    ]);

    $media->setCustomProperty('title', 'Updated Title');
    $media->setCustomProperty('description', 'Updated Description');
    $media->setCustomProperty('alt', 'Updated Alt');
    $media->save();

    expect($media->getCustomProperty('title'))->toBe('Updated Title');
    expect($media->getCustomProperty('description'))->toBe('Updated Description');
    expect($media->getCustomProperty('alt'))->toBe('Updated Alt');
});

it('can delete media', function () {
    $folder = Folder::factory()->create();

    $media = Media::create([
        'model_type' => Folder::class,
        'model_id' => $folder->id,
        'name' => 'test-file',
        'file_name' => 'test.jpg',
        'mime_type' => 'image/jpeg',
        'disk' => 'public',
        'size' => 1024,
        'collection_name' => $folder->collection,
        'manipulations' => [],
        'custom_properties' => [],
        'generated_conversions' => [],
        'responsive_images' => [],
    ]);

    $mediaId = $media->id;
    $media->delete();

    expect(Media::find($mediaId))->toBeNull();
});

it('can handle different mime types', function () {
    $folder = Folder::factory()->create();

    $mimeTypes = [
        'image/jpeg',
        'image/png',
        'video/mp4',
        'audio/mpeg',
        'application/pdf',
        'application/zip',
    ];

    foreach ($mimeTypes as $index => $mimeType) {
        $media = Media::create([
            'model_type' => Folder::class,
            'model_id' => $folder->id,
            'name' => "test-file-{$index}",
            'file_name' => "test-{$index}.ext",
            'mime_type' => $mimeType,
            'disk' => 'public',
            'size' => 1024,
            'collection_name' => $folder->collection,
            'manipulations' => [],
            'custom_properties' => [],
            'generated_conversions' => [],
            'responsive_images' => [],
        ]);

        expect($media->mime_type)->toBe($mimeType);
    }
});
</file>

<file path="tests/src/PluginTest.php">
<?php

use Filament\Facades\Filament;
use TomatoPHP\FilamentMediaManager\FilamentMediaManagerPlugin;

it('registers plugin', function () {
    $panel = Filament::getCurrentOrDefaultPanel();

    $panel->plugins([
        FilamentMediaManagerPlugin::make(),
    ]);

    expect($panel->getPlugin('filament-media-manager'))
        ->not()
        ->toThrow(Exception::class);
});
</file>

<file path="tests/src/ProtectedFolderTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;
use function Pest\Laravel\assertDatabaseHas;

beforeEach(function () {
    actingAs(User::factory()->create());
});

it('can create a protected folder', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => bcrypt('secret123'),
    ]);

    assertDatabaseHas(Folder::class, [
        'id' => $folder->id,
        'is_protected' => true,
    ]);

    expect($folder->is_protected)->toBeTrue();
});

it('requires password for protected folder', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    expect($folder->is_protected)->toBeTrue();
    expect($folder->password)->toBe('secret123');
});

it('validates password for protected folder', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    $wrongPassword = 'wrongpassword';
    expect($folder->password)->not->toBe($wrongPassword);
});

it('allows access with correct password', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    session()->put('folder_password', 'secret123');

    expect(session()->has('folder_password'))->toBeTrue();
});

it('stores folder id in session', function () {
    $folder = Folder::factory()->create();

    session()->put('folder_id', $folder->id);

    expect(session()->get('folder_id'))->toBe($folder->id);
});

it('clears folder session on logout', function () {
    $folder = Folder::factory()->create();

    session()->put('folder_id', $folder->id);
    session()->put('folder_password', 'secret123');

    session()->forget('folder_id');
    session()->forget('folder_password');

    expect(session()->has('folder_id'))->toBeFalse();
    expect(session()->has('folder_password'))->toBeFalse();
});

it('can display lock icon for protected folders', function () {
    $folder = Folder::factory()->create([
        'is_protected' => true,
        'password' => 'secret123',
    ]);

    expect($folder->is_protected)->toBeTrue();
});

it('can create public folder without password', function () {
    $folder = Folder::factory()->create([
        'is_protected' => false,
    ]);

    expect($folder->is_protected)->toBeFalse();
    expect($folder->password)->toBeNull();
});
</file>

<file path="tests/src/TestCase.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use BladeUI\Heroicons\BladeHeroiconsServiceProvider;
use BladeUI\Icons\BladeIconsServiceProvider;
use Filament\Actions\ActionsServiceProvider;
use Filament\Facades\Filament;
use Filament\FilamentServiceProvider;
use Filament\Forms\FormsServiceProvider;
use Filament\Infolists\InfolistsServiceProvider;
use Filament\Notifications\NotificationsServiceProvider;
use Filament\Panel;
use Filament\Schemas\SchemasServiceProvider;
use Filament\Support\SupportServiceProvider;
use Filament\Tables\TablesServiceProvider;
use Filament\Widgets\WidgetsServiceProvider;
use Illuminate\Foundation\Testing\LazilyRefreshDatabase;
use Livewire\LivewireServiceProvider;
use Orchestra\Testbench\Attributes\WithEnv;
use Orchestra\Testbench\Concerns\WithWorkbench;
use Orchestra\Testbench\TestCase as BaseTestCase;
use RyanChandler\BladeCaptureDirective\BladeCaptureDirectiveServiceProvider;
use Spatie\MediaLibrary\MediaLibraryServiceProvider;
use TomatoPHP\FilamentIcons\FilamentIconsServiceProvider;
use TomatoPHP\FilamentMediaManager\FilamentMediaManagerServiceProvider;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

#[WithEnv('DB_CONNECTION', 'testing')]
abstract class TestCase extends BaseTestCase
{
    use LazilyRefreshDatabase;
    use WithWorkbench;

    public ?Panel $panel = null;

    protected function setUp(): void
    {
        parent::setUp();

        $this->panel = Filament::getCurrentOrDefaultPanel();
    }

    protected function getPackageProviders($app): array
    {
        $providers = [
            ActionsServiceProvider::class,
            BladeCaptureDirectiveServiceProvider::class,
            BladeHeroiconsServiceProvider::class,
            BladeIconsServiceProvider::class,
            FilamentServiceProvider::class,
            FormsServiceProvider::class,
            InfolistsServiceProvider::class,
            LivewireServiceProvider::class,
            NotificationsServiceProvider::class,
            SupportServiceProvider::class,
            TablesServiceProvider::class,
            WidgetsServiceProvider::class,
            SchemasServiceProvider::class,
            MediaLibraryServiceProvider::class,
            FilamentIconsServiceProvider::class,
            FilamentMediaManagerServiceProvider::class,
            AdminPanelProvider::class,
        ];

        sort($providers);

        return $providers;
    }

    protected function defineDatabaseMigrations(): void
    {
        $this->loadMigrationsFrom(__DIR__ . '/../../database/migrations');
        $this->loadMigrationsFrom(__DIR__ . '/../database/migrations');
    }

    public function getEnvironmentSetUp($app): void
    {
        $app['config']->set('filament-media-manager.user.model', User::class);
        $app['config']->set('database.default', 'testing');
        $app['config']->set('filament-icons.cache', false);

        $app['config']->set('view.paths', [
            ...$app['config']->get('view.paths'),
            __DIR__ . '/../resources/views',
        ]);
    }
}
</file>

<file path="tests/Pest.php">
<?php

use TomatoPHP\FilamentMediaManager\Tests\TestCase;

uses(TestCase::class)->in(__DIR__);
</file>

<file path="tests/README.md">
# Testing Guide

This package uses [Pest PHP](https://pestphp.com/) for testing.

## Running Tests

Run all tests:
```bash
composer test
```

Run specific test file:
```bash
./vendor/bin/pest tests/src/MediaManagerPickerTest.php
```

Run tests with coverage:
```bash
./vendor/bin/pest --coverage
```

## Test Structure

### MediaManagerPickerTest.php

Tests for the MediaManagerPicker form component and MediaPicker Livewire component:

- **Component Configuration**
  - Single/multiple selection modes
  - Max/min items validation
  - Collection filtering
  - Action availability

- **Livewire Component**
  - Rendering and initialization
  - Folder navigation
  - Media selection and deselection
  - Max/min items enforcement
  - Search functionality

- **Password Protected Folders**
  - Password prompting
  - Correct password acceptance
  - Incorrect password rejection

- **State Hydration**
  - Loading existing media on edit

- **File Upload**
  - Direct upload from picker modal
  - Auto-selection after upload

### MediaManagerInputTest.php

Tests for the MediaManagerInput form component (Spatie Media Library integration):

- **Component Configuration**
  - Disk configuration
  - Collection settings
  - Max files and file size limits
  - Accepted file types
  - Single/multiple file modes

- **File Upload**
  - Single and multiple file uploads
  - Disk storage verification
  - Custom properties storage

- **Media Retrieval**
  - Get all media from collection
  - Get first media
  - Get media URLs
  - Check media existence

- **Media Deletion**
  - Delete single media
  - Clear collection
  - Cascade delete on model deletion

- **Custom Schema**
  - Custom metadata fields
  - Custom property storage

- **Validation**
  - File size validation
  - File type validation
  - Max files validation
  - Required validation

- **Conversions**
  - Media conversions (if configured)
  - Conversion URL generation

### InteractsWithMediaManagerTest.php

Tests for the InteractsWithMediaManager trait:

- **Media Retrieval**
  - Get all attached media
  - Get media by UUIDs
  - Get media from Spatie collections
  - Filter by field name

- **Media Attachment**
  - Attach media programmatically
  - Prevent duplicate attachments

- **Media Detachment**
  - Detach specific media
  - Detach all media

- **Media Synchronization**
  - Replace all media with new selection

- **Media Existence Check**
  - Check if specific media is attached

- **First Media**
  - Get first media item
  - Handle empty collections

- **Media URLs**
  - Get first media URL
  - Get all media URLs
  - Handle conversions

- **Model Isolation**
  - Ensure media is isolated between different model instances

## Test Models

### Product Model

A test model that uses both Spatie's `InteractsWithMedia` and our `InteractsWithMediaManager` trait:

```php
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;
use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaManager;

class Product extends Model implements HasMedia
{
    use InteractsWithMedia;
    use InteractsWithMediaManager;
}
```

### User Model

A test user model for authentication:

```php
use Filament\Models\Contracts\FilamentUser;

class User extends Authenticatable implements FilamentUser
{
    public function canAccessPanel(Panel $panel): bool
    {
        return true;
    }
}
```

## Factories

### FolderFactory

Creates test folders with various configurations:

```php
Folder::factory()->create();
Folder::factory()->create(['is_protected' => true, 'password' => 'secret']);
Folder::factory()->create(['parent_id' => $parentFolder->id]);
```

### UserFactory

Creates test users:

```php
User::factory()->create();
User::factory()->create(['email' => 'test@example.com']);
```

## Database Setup

The test suite uses an in-memory SQLite database configured in `TestCase.php`:

```php
#[WithEnv('DB_CONNECTION', 'testing')]
abstract class TestCase extends BaseTestCase
{
    use LazilyRefreshDatabase;
    use WithWorkbench;
}
```

This ensures:
- Fast test execution
- No impact on development database
- Fresh database for each test class

## Test Coverage

The test suite covers:

- ✅ Form component configuration and validation
- ✅ Livewire component functionality
- ✅ File upload and storage
- ✅ Media retrieval and URLs
- ✅ Password protected folders
- ✅ Model trait integration
- ✅ Media attachment/detachment
- ✅ Custom properties and metadata
- ✅ Search and filtering
- ✅ Multi-tenancy and model isolation

## Writing New Tests

When adding new features, follow this structure:

```php
describe('Feature Name', function () {
    it('can do something specific', function () {
        // Arrange
        $model = Model::create([...]);

        // Act
        $result = $model->doSomething();

        // Assert
        expect($result)->toBeSomething();
    });

    it('handles edge case', function () {
        // Test edge cases
    });
});
```

## Continuous Integration

Tests are designed to run in CI environments. Ensure your CI configuration includes:

```yaml
- name: Run Tests
  run: composer test

- name: Run Tests with Coverage
  run: ./vendor/bin/pest --coverage --min=80
```

## Tips for Testing

1. **Use Fakes**: Always use `Storage::fake()` for file operations
2. **Clean State**: Each test should be independent
3. **Descriptive Names**: Test names should clearly describe what they test
4. **Arrange-Act-Assert**: Follow AAA pattern for clarity
5. **Edge Cases**: Don't forget to test error conditions and edge cases

## Common Issues

### Issue: Tests fail with "No such file or directory"

**Solution**: Make sure you're using `Storage::fake()` in your test setup:

```php
beforeEach(function () {
    Storage::fake('public');
    actingAs(User::factory()->create());
});
```

### Issue: "Class not found" errors

**Solution**: Ensure autoloading is configured correctly in `composer.json`:

```json
"autoload-dev": {
    "psr-4": {
        "TomatoPHP\\FilamentMediaManager\\Tests\\": "tests/src"
    }
}
```

Then run: `composer dump-autoload`

### Issue: Database errors

**Solution**: Make sure migrations are loaded in `TestCase.php`:

```php
protected function defineDatabaseMigrations(): void
{
    $this->loadMigrationsFrom(__DIR__ . '/../../database/migrations');
    $this->loadMigrationsFrom(__DIR__ . '/../database/migrations');
}
```

## Further Reading

- [Pest PHP Documentation](https://pestphp.com/docs)
- [Laravel Testing](https://laravel.com/docs/testing)
- [Filament Testing](https://filamentphp.com/docs/support/testing)
- [Spatie Media Library Testing](https://spatie.be/docs/laravel-medialibrary/testing)
</file>

<file path=".gitignore">
/.phpunit.cache
/node_modules
/public/build
/public/hot
/public/storage
/storage/*.key
/storage/pail
/vendor
.env
.env.backup
.env.production
.phpactor.json
.phpunit.result.cache
.DS_Store
Homestead.json
Homestead.yaml
auth.json
npm-debug.log
yarn-error.log
/.fleet
/.idea
/.vscode
/.zed
</file>

<file path=".php-cs-fixer.dist.php">
<?php

$finder = Symfony\Component\Finder\Finder::create()
    ->notPath('bootstrap/*')
    ->notPath('storage/*')
    ->notPath('resources/view/mail/*')
    ->in([
        __DIR__ . '/src',
        __DIR__ . '/tests',
    ])
    ->name('*.php')
    ->notName('*.blade.php')
    ->ignoreDotFiles(true)
    ->ignoreVCS(true);

return (new PhpCsFixer\Config())
    ->setRules([
        '@PSR2' => true,
        'array_syntax' => ['syntax' => 'short'],
        'ordered_imports' => ['sort_algorithm' => 'alpha'],
        'no_unused_imports' => true,
        'not_operator_with_successor_space' => true,
        'trailing_comma_in_multiline' => true,
        'phpdoc_scalar' => true,
        'unary_operator_spaces' => true,
        'binary_operator_spaces' => true,
        'blank_line_before_statement' => [
            'statements' => ['break', 'continue', 'declare', 'return', 'throw', 'try'],
        ],
        'phpdoc_single_line_var_spacing' => true,
        'phpdoc_var_without_name' => true,
        'method_argument_space' => [
            'on_multiline' => 'ensure_fully_multiline',
            'keep_multiple_spaces_after_comma' => true,
        ]
    ])
    ->setFinder($finder);
</file>

<file path="CODE_OF_CONDUCT.md">
# Contributor Covenant Code of Conduct

## Our Pledge

We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.

## Our Standards

Examples of behavior that contributes to a positive environment for our
community include:

* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
  and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
  overall community

Examples of unacceptable behavior include:

* The use of sexualized language or imagery, and sexual attention or
  advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
  address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
  professional setting

## Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.

Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.

## Scope

This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
.
All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the
reporter of any incident.

## Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:

### 1. Correction

**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.

**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.

### 2. Warning

**Community Impact**: A violation through a single incident or series
of actions.

**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.

### 3. Temporary Ban

**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.

**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.

### 4. Permanent Ban

**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior,  harassment of an
individual, or aggression toward or disparagement of classes of individuals.

**Consequence**: A permanent ban from any sort of public interaction within
the community.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).

[homepage]: https://www.contributor-covenant.org

For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.
</file>

<file path="fadymondy-tomato-media-manager.md">
---
name: Media Manager
slug: fadymondy-tomato-media-manager
author_slug: fadymondy
categories: [form-field, table-column, spatie]
description: Manage your media files using spatie media library with easy to use GUI for FilamentPHP
discord_url:
docs_url: https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/README.md
github_repository: tomatophp/filament-media-manager
has_dark_theme: true
has_translations: true
versions: [3,4]
publish_date: 2024-06-23
---
</file>

<file path="LICENSE.md">
The MIT License (MIT)

Copyright (c)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
</file>

<file path="phpstan.neon">
parameters:
    level: 5
    paths:
        - src
    excludePaths:
        - src/Http/Controllers/*
        - src/Http/Resources/*
    treatPhpDocTypesAsCertain: false
    ignoreErrors:
        - '#PHPDoc tag @method .* contains unknown class#'
        - '#Unsafe usage of new static\(\)#'
        - '#Parameter .* has invalid type Filament\\Forms\\Components\\Component#'
        - '#Trait .* is used zero times and is not analysed#'
        - '#Out of \d+ possible .+ types, only \d+ - [\d.]+ % actually have it#'
        - '#Access to an undefined property .+::\$#'
        - '#Call to an undefined method Filament\\Forms\\Components\\Repeater::#'
        - '#Parameter \#1 \$view of method Filament\\Support\\Components\\ViewComponent::view\(\) expects#'
        - '#Call to deprecated method#'
        - '#Class App\\Models\\User not found#'
        - '#Expression in empty\(\) is not falsy#'
        - '#Parameter \#1 \$size of method Filament\\Forms\\Components\\BaseFileUpload::maxSize\(\)#'
        - '#Relation .* is not found in .* model#'
</file>

<file path="phpunit.xml">
<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         backupGlobals="false"
         bootstrap="vendor/autoload.php"
         colors="true"
         processIsolation="false"
         stopOnFailure="false"
         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
         cacheDirectory=".phpunit.cache"
         backupStaticProperties="false"
>
    <testsuites>
        <testsuite name="Tests">
            <directory suffix=".php">./tests/</directory>
        </testsuite>
    </testsuites>
    <source>
        <include>
            <directory suffix=".php">./src</directory>
        </include>
    </source>
    <php>
        <env name="APP_KEY" value="base64:yk+bUVuZa1p86Dqjk9OjVK2R1pm6XHxC6xEKFq8utH0="/>
        <env name="DB_CONNECTION" value="testing"/>
    </php>
</phpunit>
</file>

<file path="pint.json">
{
    "preset": "laravel",
    "rules": {
        "blank_line_before_statement": true,
        "concat_space": {
            "spacing": "one"
        },
        "method_argument_space": true,
        "single_trait_insert_per_statement": true,
        "types_spaces": {
            "space": "single"
        }
    }
}
</file>

<file path="testbench.yaml">
providers:
  - BladeUI\Icons\BladeIconsServiceProvider
  - BladeUI\Heroicons\BladeHeroiconsServiceProvider
  - Filament\Actions\ActionsServiceProvider
  - Filament\FilamentServiceProvider
  - Filament\Forms\FormsServiceProvider
  - Filament\Infolists\InfolistsServiceProvider
  - Filament\Notifications\NotificationsServiceProvider
  - Filament\Support\SupportServiceProvider
  - Filament\Schemas\SchemasServiceProvider
  - Filament\Tables\TablesServiceProvider
  - Filament\Widgets\WidgetsServiceProvider
  - RyanChandler\BladeCaptureDirective\BladeCaptureDirectiveServiceProvider
  - TomatoPHP\FilamentMediaManager\FilamentMediaManagerServiceProvider
  - TomatoPHP\FilamentMediaManager\Tests\AdminPanelProvider
  - Spatie\MediaLibrary\MediaLibraryServiceProvider
workbench:
  welcome: true
  install: true
  start: /
  guard: testing
  discovers:
    web: true
    api: false
    commands: false
    views: true
</file>

<file path=".github/workflows/tests.yml">
name: "Tests"

on:
  workflow_dispatch:
  push:
    branches:
      - master
    paths:
      - '**.php'
  pull_request:
    types:
      - opened
      - synchronize
    branches:
      - master
    paths:
      - '**.php'
      - '.github/workflows/tests.yml'
      - 'phpunit.xml.dist'
      - 'composer.json'
      - 'composer.lock'

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: true
      matrix:
        os: [ubuntu-latest]
        php: [8.4, 8.3, 8.2]
        laravel: [12.*, 11.*]
        stability: [prefer-stable]
        include:
          - laravel: 12.*
            testbench: 10.*
            carbon: 3.*
            collision: 8.*
          - laravel: 11.*
            testbench: 9.*
            carbon: 3.*
            collision: 8.*
        exclude:
          - laravel: 11.*
            php: 8.1
    name: P${{ matrix.php }} - L${{ matrix.laravel }} - ${{ matrix.stability }} - ${{ matrix.os }}
    steps:
      - name: Checkout Code
        uses: actions/checkout@v5

      - name: Cache Dependencies
        uses: actions/cache@v4
        with:
          path: ~/.composer/cache/files
          key: dependencies-laravel-${{ matrix.laravel }}-php-${{ matrix.php }}-composer-${{ hashFiles('composer.json') }}

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: ${{ matrix.php }}
          extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv, imagick, fileinfo
          coverage: none

      - name: Install Dependencies
        run: |
          echo "::add-matcher::${{ runner.tool_cache }}/php.json"
          echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"

      - name: Install Dependencies
        run: |
          composer require "laravel/framework:${{ matrix.laravel }}" "orchestra/testbench:${{ matrix.testbench }}" "nesbot/carbon:${{ matrix.carbon }}" "nunomaduro/collision:${{ matrix.collision }}" --no-interaction --no-update
          composer update --${{ matrix.stability }} --prefer-dist --no-interaction
          composer db

      - name: Execute tests
        run: vendor/bin/pest
</file>

<file path=".github/FUNDING.yml">
github: [fadymondy]
</file>

<file path="database/migrations/2024_10_03_171807_create_folders_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('folders', function (Blueprint $table) {
            $table->id();

            // Morph
            $table->string('model_type')->nullable();
            $table->unsignedBigInteger('model_id')->nullable();

            // Folder
            $table->string('name')->index();
            $table->string('collection')->nullable()->index();
            $table->string('description')->nullable();
            $table->string('icon')->nullable();
            $table->string('color')->nullable();

            // Options
            $table->boolean('is_protected')->default(false)->nullable();
            $table->string('password')->nullable();
            $table->boolean('is_hidden')->default(false)->nullable();
            $table->boolean('is_favorite')->default(false)->nullable();

            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('folders');
    }
};
</file>

<file path="database/migrations/2024_10_03_171808_create_media_has_models_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('media_has_models', function (Blueprint $table) {
            $table->id();

            // Morph
            $table->string('model_type');
            $table->unsignedBigInteger('model_id');

            // Folder
            $table->foreignId('media_id')->constrained('media')->onDelete('cascade');

            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('media_has_models');
    }
};
</file>

<file path="resources/lang/ru/messages.php">
<?php

return [
    'empty' => [
        'title' => 'Медиа или папки отсутствуют',
    ],
    'folders' => [
        'title' => 'Медиа менеджер',
        'single' => 'Папка',
        'columns' => [
            'name' => 'Название',
            'collection' => 'Коллекция',
            'description' => 'Описание',
            'is_public' => 'Публичный',
            'has_user_access' => 'Есть доступ пользователя',
            'users' => 'Пользователи',
            'icon' => 'Иконка',
            'color' => 'Цвет',
            'is_protected' => 'Защищено',
            'password' => 'Пароль',
            'password_confirmation' => 'Подтверждение пароля',
        ],
        'filters' => [
            'all_folders' => 'Все папки',
            'protected_only' => 'Только защищенные',
            'public_only' => 'Только публичные',
            'created_from' => 'Создано с',
            'created_until' => 'Создано до',
        ],
        'group' => 'Контент',
    ],
    'media' => [
        'title' => 'Медиа',
        'single' => 'Медиа',
        'columns' => [
            'image' => 'Изображение',
            'model' => 'Модель',
            'collection_name' => 'Название коллекции',
            'size' => 'Размер',
            'order_column' => 'Очередность колонок',
        ],
        'filters' => [
            'size_from' => 'Размер от (КБ)',
            'size_to' => 'Размер до (КБ)',
            'created_from' => 'Создано с',
            'created_until' => 'Создано до',
        ],
        'actions' => [
            'sub_folder' => [
                'label' => 'Создать подпапку',
            ],
            'create' => [
                'label' => 'Добавить медиа',
                'form' => [
                    'file' => 'Файл',
                    'title' => 'Заголовок',
                    'description' => 'Описание',
                ],
            ],
            'delete' => [
                'label' => 'Удалить папку',
            ],
            'edit' => [
                'label' => 'Редактировать папку',
            ],
        ],
        'notifications' => [
            'create-media' => 'Медиа создано успешно',
            'delete-folder' => 'Папака удалена успешно',
            'edit-folder' => 'Папка отредактирована успешно',
        ],
        'meta' => [
            'model' => 'Модель',
            'file-name' => 'Название файла',
            'type' => 'Тип',
            'size' => 'Размер',
            'disk' => 'Диск',
            'url' => 'URL',
            'delete-media' => 'Удалить медиа',
        ],
    ],
];
</file>

<file path="resources/lang/tr/messages.php">
<?php

return [
    'empty' => [
        'title' => 'Medya veya Klasör Bulunamadı',
    ],
    'folders' => [
        'title' => 'Medya Yöneticisi',
        'single' => 'Klasör',
        'columns' => [
            'name' => 'Ad',
            'collection' => 'Koleksiyon',
            'description' => 'Açıklama',
            'is_public' => 'Herkese Açık mı',
            'has_user_access' => 'Kullanıcı Erişimi Var mı',
            'users' => 'Kullanıcılar',
            'icon' => 'Simge',
            'color' => 'Renk',
            'is_protected' => 'Korumalı mı',
            'password' => 'Parola',
            'password_confirmation' => 'Parola Onayı',
        ],
        'filters' => [
            'all_folders' => 'Tüm klasörler',
            'protected_only' => 'Yalnızca korumalı',
            'public_only' => 'Yalnızca genel',
            'created_from' => 'Oluşturma tarihi (başlangıç)',
            'created_until' => 'Oluşturma tarihi (bitiş)',
        ],
        'group' => 'İçerik',
    ],
    'media' => [
        'title' => 'Medya',
        'single' => 'Medya',
        'columns' => [
            'image' => 'Görsel',
            'model' => 'Model',
            'collection_name' => 'Koleksiyon Adı',
            'size' => 'Boyut',
            'order_column' => 'Sıra Sütunu',
        ],
        'filters' => [
            'size_from' => 'Boyut (başlangıç KB)',
            'size_to' => 'Boyut (bitiş KB)',
            'created_from' => 'Oluşturma tarihi (başlangıç)',
            'created_until' => 'Oluşturma tarihi (bitiş)',
        ],
        'actions' => [
            'sub_folder' => [
                'label' => 'Alt Klasör Oluştur',
            ],
            'create' => [
                'label' => 'Medya Ekle',
                'form' => [
                    'file' => 'Dosya',
                    'title' => 'Başlık',
                    'description' => 'Açıklama',
                ],
            ],
            'delete' => [
                'label' => 'Klasörü Sil',
            ],
            'edit' => [
                'label' => 'Klasörü Düzenle',
            ],
        ],
        'notifications' => [
            'create-media' => 'Medya başarıyla oluşturuldu',
            'delete-folder' => 'Klasör başarıyla silindi',
            'edit-folder' => 'Klasör başarıyla düzenlendi',
        ],
        'meta' => [
            'model' => 'Model',
            'file-name' => 'Dosya Adı',
            'type' => 'Tür',
            'size' => 'Boyut',
            'disk' => 'Disk',
            'url' => 'URL',
            'delete-media' => 'Medya Sil',
        ],
    ],
];
</file>

<file path="resources/views/columns/media-preview.blade.php">
@php
    $extension = strtolower(pathinfo($getRecord()->file_name, PATHINFO_EXTENSION));

    // File type icon mapping
    $fileIcons = [
        // Documents
        'pdf' => ['icon' => 'heroicon-o-document-text', 'color' => '#ef4444'],
        'doc' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
        'docx' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
        'odt' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
        'rtf' => ['icon' => 'heroicon-o-document-text', 'color' => '#6b7280'],
        'txt' => ['icon' => 'heroicon-o-document', 'color' => '#6b7280'],
        'md' => ['icon' => 'heroicon-o-document', 'color' => '#6b7280'],

        // Spreadsheets
        'xls' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
        'xlsx' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
        'ods' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
        'csv' => ['icon' => 'heroicon-o-table-cells', 'color' => '#10b981'],

        // Presentations
        'ppt' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
        'pptx' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
        'odp' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],

        // Archives
        'zip' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
        'rar' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
        '7z' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
        'tar' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
        'gz' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],

        // Code files
        'json' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
        'xml' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
        'html' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
        'css' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
        'js' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
        'ts' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
        'jsx' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
        'tsx' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
        'php' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
        'py' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
        'rb' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#ef4444'],
        'java' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
        'cpp' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
        'c' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
        'go' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
        'rust' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
        'swift' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],

        // Images (vector)
        'svg' => ['icon' => 'heroicon-o-photo', 'color' => '#f59e0b'],
        'eps' => ['icon' => 'heroicon-o-photo', 'color' => '#8b5cf6'],
        'ai' => ['icon' => 'heroicon-o-photo', 'color' => '#f97316'],

        // Others
        'psd' => ['icon' => 'heroicon-o-photo', 'color' => '#3b82f6'],
        'sketch' => ['icon' => 'heroicon-o-photo', 'color' => '#f59e0b'],
        'fig' => ['icon' => 'heroicon-o-photo', 'color' => '#ec4899'],
    ];

    $fileIcon = $fileIcons[$extension] ?? ['icon' => 'heroicon-o-document', 'color' => '#9ca3af'];
@endphp

<style>
    .table-media-preview {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100px;
        height: 70px;
        position: relative;
        overflow: hidden;
        margin: auto;
    }

    .table-media-preview-with-bg {
        border-radius: 5px;
        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        background-color: rgb(243 244 246);
    }

    .table-media-preview-with-bg:where(.dark, .dark *) {
        background-color: rgb(31 41 55);
    }

    .table-media-preview img {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 5px;
    }

    .table-media-preview video {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 5px;
    }

    .table-media-icon-large {
        width: 4rem;
        height: 4rem;
    }

    .table-media-file-icon {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        gap: 0.25rem;
        width: 100%;
        height: 100%;
    }

    .table-media-file-icon-image {
        width: 3.5rem;
        height: 3.5rem;
    }

    .table-media-file-extension {
        font-size: 0.625rem;
        font-weight: 600;
        text-transform: uppercase;
        color: rgb(107 114 128);
    }

    .table-media-file-extension:where(.dark, .dark *) {
        color: rgb(156 163 175);
    }
</style>

<div class="table-media-preview {{ str($getRecord()->mime_type)->contains(['image', 'video']) ? 'table-media-preview-with-bg' : '' }}">
    @if(str($getRecord()->mime_type)->contains('image'))
        <img src="{{ $getRecord()->getUrl() }}" alt="{{ $getRecord()->name }}" />
    @elseif(str($getRecord()->mime_type)->contains('video'))
        <video src="{{ $getRecord()->getUrl() }}"></video>
    @elseif(str($getRecord()->mime_type)->contains('audio'))
        <x-filament::icon name="heroicon-o-musical-note" class="table-media-icon-large" style="color: #ec4899;" />
    @else
        @php
            $hasPreview = false;
            $loadTypes = \TomatoPHP\FilamentMediaManager\Facade\FilamentMediaManager::getTypes();
            $type = null;
            foreach ($loadTypes as $getType) {
                if(str($getRecord()->file_name)->contains($getType->exstantion)){
                    $hasPreview = $getType->preview;
                    $type = $getType;
                }
            }
        @endphp
        @if($hasPreview && $type)
            <x-filament::icon :name="$type->icon" class="table-media-icon-large" style="color: {{ $fileIcon['color'] ?? '#9ca3af' }};" />
        @else
            <div class="table-media-file-icon">
                <x-filament::icon :name="$fileIcon['icon']" class="table-media-file-icon-image" style="color: {{ $fileIcon['color'] }};" />
                <span class="table-media-file-extension">{{ $extension }}</span>
            </div>
        @endif
    @endif
</div>
</file>

<file path="resources/views/components/folder-action-view.blade.php">
@php
    use Filament\Support\Enums\IconPosition;
    use Filament\Support\Enums\IconSize;
    use Filament\Support\Enums\Size;
    use Filament\Support\View\Components\BadgeComponent;
    use Filament\Support\View\Components\ButtonComponent;
    use Illuminate\View\ComponentAttributeBag;
@endphp

@props([
    'badge' => null,
    'badgeColor' => 'primary',
    'badgeSize' => Size::ExtraSmall,
    'color' => 'primary',
    'disabled' => false,
    'form' => null,
    'formId' => null,
    'href' => null,
    'icon' => null,
    'iconAlias' => null,
    'iconPosition' => IconPosition::Before,
    'iconSize' => null,
    'keyBindings' => null,
    'labeledFrom' => null,
    'labelSrOnly' => false,
    'loadingIndicator' => true,
    'outlined' => false,
    'size' => Size::Medium,
    'spaMode' => null,
    'tag' => 'button',
    'target' => null,
    'tooltip' => null,
    'type' => 'button',
])


<button
    wire:click="mountAction('getFolderAction', { item: {{$item}} })"
    style="background: transparent; border: none; cursor: pointer; padding: 0;"
>
    <style>
        .folder-container-{{$item->id}} {
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            gap: 0.5rem;
            padding: 0.5rem;
            border-radius: 0.5rem;
            transition: background-color 0.15s ease;
        }

        .folder-container-{{$item->id}}:hover {
            background-color: rgb(249 250 251);
        }

        .folder-container-{{$item->id}}:hover:where(.dark, .dark *) {
            background-color: rgb(55 65 81 / 0.5);
        }

        .folder-icon-{{$item->id}} {
            width: 100px;
            height: 70px;
            background-color: {{$item->color?? '#f3c623'}};
            border-radius: 5px;
            position: relative;
            margin: 10px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
        }

        .folder-icon-{{$item->id}}::before {
            content: "";
            width: 40px;
            height: 10px;
            background-color: {{$item->color?? '#f3c623'}};
            border-radius: 5px 5px 0 0;
            position: absolute;
            top: -10px;
            left: 10px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        }

        .folder-icon-content-{{$item->id}} {
            color: white;
            width: 2rem;
            height: 2rem;
        }

        .folder-lock-badge-{{$item->id}} {
            position: absolute;
            top: -8px;
            right: -8px;
            background-color: rgb(239 68 68);
            border-radius: 9999px;
            padding: 0.375rem;
            box-shadow: 0 2px 4px rgba(0,0,0,0.2);
            display: flex;
            align-items: center;
            justify-content: center;
            z-index: 10;
        }

        .folder-lock-badge-{{$item->id}}:where(.dark, .dark *) {
            background-color: rgb(220 38 38);
        }

        .folder-lock-icon-{{$item->id}} {
            width: 1rem;
            height: 1rem;
            color: white;
        }

        .folder-info-{{$item->id}} {
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
        }

        .folder-name-{{$item->id}} {
            font-weight: 600;
            font-size: 0.875rem;
            line-height: 1.25rem;
            text-align: center;
            max-width: 120px;
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
            color: rgb(17 24 39);
        }

        .folder-name-{{$item->id}}:where(.dark, .dark *) {
            color: rgb(249 250 251);
        }

        .folder-date-{{$item->id}} {
            color: rgb(107 114 128);
            font-size: 0.75rem;
            line-height: 1rem;
            text-align: center;
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
        }

        .folder-date-{{$item->id}}:where(.dark, .dark *) {
            color: rgb(156 163 175);
        }
    </style>
    <div class="folder-container-{{$item->id}}">
        <div class="folder-icon-{{$item->id}}">
            @if($item->icon)
                <x-filament::icon name="{{$item->icon}}" class="folder-icon-content-{{$item->id}}"/>
            @endif
            @if($item->is_protected)
                <div class="folder-lock-badge-{{$item->id}}">
                    <x-filament::icon name="heroicon-o-lock-closed" class="folder-lock-icon-{{$item->id}}" />
                </div>
            @endif
        </div>
        <div class="folder-info-{{$item->id}}">
            <h1 class="folder-name-{{$item->id}}"
                x-data
                x-tooltip="{
                    content: '{{ addslashes($item->name) }}',
                    theme: $root.closest('.dark') ? 'dark' : 'light',
                }">
                {{ $item->name }}
            </h1>
            <p class="folder-date-{{$item->id}}">
                {{ $item->created_at->diffForHumans() }}
            </p>
        </div>
    </div>
</button>
</file>

<file path="resources/views/livewire/media-picker.blade.php">
<div class="fi-modal-content space-y-4">
    {{-- Search Input --}}
    <x-filament::input.wrapper>
        <x-filament::input
            type="search"
            wire:model.live.debounce.300ms="search"
            placeholder="{{ trans('filament-media-manager::messages.picker.search') }}"
            autocomplete="off"
            name="media-search-{{ uniqid() }}"
            id="media-search-{{ uniqid() }}"
        >
            <x-slot name="prefix">
                <x-filament::icon
                    icon="heroicon-m-magnifying-glass"
                    class="h-5 w-5 text-gray-400 dark:text-gray-500"
                />
            </x-slot>
        </x-filament::input>
    </x-filament::input.wrapper>

    {{-- Navigation Bar --}}
    <div class="fi-section-header">
        <div class="fi-section-header-wrapper">
            {{-- Left: Folder Name --}}
            <div class="fi-section-header-heading">
                @if($currentFolder)
                    <h3 class="fi-section-header-title">
                        {{ $currentFolder->name }}
                    </h3>
                @else
                    <h3 class="fi-section-header-title">
                        {{ trans('filament-media-manager::messages.picker.title') }}
                    </h3>
                @endif
            </div>

            {{-- Right: Action Buttons --}}
            <div class="fi-section-header-actions">
                @if($currentFolder)
                    <x-filament::button
                        color="gray"
                        size="sm"
                        icon="heroicon-o-arrow-left"
                        wire:click="goBack"
                    >
                        {{ trans('filament-media-manager::messages.picker.back') }}
                    </x-filament::button>

                    {{ ($this->uploadMedia) }}
                @endif
            </div>
        </div>
    </div>

    <style>
        /* Section Header Styles */
        .fi-section-header {
            border-radius: 0.5rem;
            border: 1px solid rgb(0 0 0 / 0.1);
            background-color: white;
            padding: 0.75rem 1rem;
        }

        .dark .fi-section-header {
            border-color: rgb(255 255 255 / 0.1);
            background-color: rgb(255 255 255 / 0.05);
        }

        .fi-section-header-wrapper {
            display: flex;
            align-items: center;
            justify-content: space-between;
            gap: 1rem;
        }

        .fi-section-header-heading {
            min-width: 0;
            flex: 1;
        }

        .fi-section-header-title {
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
            font-size: 1rem;
            font-weight: 700;
            color: rgb(17 24 39);
        }

        .dark .fi-section-header-title {
            color: white;
        }

        .fi-section-header-actions {
            display: flex;
            flex-shrink: 0;
            align-items: center;
            gap: 0.5rem;
        }

        /* Grid Layout */
        .media-picker-grid {
            display: grid;
            grid-template-columns: repeat(2, minmax(0, 1fr));
            gap: 0.75rem;
        }

        @media (min-width: 640px) {
            .media-picker-grid {
                grid-template-columns: repeat(3, minmax(0, 1fr));
            }
        }

        @media (min-width: 768px) {
            .media-picker-grid {
                grid-template-columns: repeat(4, minmax(0, 1fr));
            }
        }

        @media (min-width: 1024px) {
            .media-picker-grid {
                grid-template-columns: repeat(6, minmax(0, 1fr));
            }
        }
    </style>

    {{-- Content --}}
    <div class="space-y-6">
        {{-- Folders Grid --}}
        @if($folders->count() > 0)
            <div class="space-y-3">
                <h3 class="text-sm font-semibold text-gray-950 dark:text-white">
                    {{ trans('filament-media-manager::messages.picker.folders') }}
                </h3>
                <div class="media-picker-grid">
                    @foreach($folders as $folder)
                        <button
                            type="button"
                            wire:click="openFolder({{ $folder->id }})"
                            style="background: transparent; border: none; cursor: pointer; padding: 0; width: 100%;"
                        >
                            <style>
                                .folder-container-picker-{{$folder->id}} {
                                    display: flex;
                                    flex-direction: column;
                                    justify-content: center;
                                    align-items: center;
                                    gap: 0.5rem;
                                    padding: 0.5rem;
                                    border-radius: 0.5rem;
                                    transition: background-color 0.15s ease;
                                }

                                .folder-container-picker-{{$folder->id}}:hover {
                                    background-color: rgb(249 250 251);
                                }

                                .dark .folder-container-picker-{{$folder->id}}:hover {
                                    background-color: rgb(55 65 81 / 0.5);
                                }

                                .folder-icon-picker-{{$folder->id}} {
                                    width: 100px;
                                    height: 70px;
                                    background-color: {{$folder->color ?? '#f3c623'}};
                                    border-radius: 5px;
                                    position: relative;
                                    margin: 10px;
                                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
                                    display: flex;
                                    flex-direction: column;
                                    align-items: center;
                                    justify-content: center;
                                }

                                .folder-icon-picker-{{$folder->id}}::before {
                                    content: "";
                                    width: 40px;
                                    height: 10px;
                                    background-color: {{$folder->color ?? '#f3c623'}};
                                    border-radius: 5px 5px 0 0;
                                    position: absolute;
                                    top: -10px;
                                    left: 10px;
                                    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
                                }

                                .folder-icon-content-picker-{{$folder->id}} {
                                    color: white;
                                    width: 2rem;
                                    height: 2rem;
                                }

                                .folder-lock-badge-picker-{{$folder->id}} {
                                    position: absolute;
                                    top: -8px;
                                    right: -8px;
                                    background-color: rgb(239 68 68);
                                    border-radius: 9999px;
                                    padding: 0.375rem;
                                    box-shadow: 0 2px 4px rgba(0,0,0,0.2);
                                    display: flex;
                                    align-items: center;
                                    justify-content: center;
                                    z-index: 10;
                                }

                                .dark .folder-lock-badge-picker-{{$folder->id}} {
                                    background-color: rgb(220 38 38);
                                }

                                .folder-lock-icon-picker-{{$folder->id}} {
                                    width: 1rem;
                                    height: 1rem;
                                    color: white;
                                }

                                .folder-info-picker-{{$folder->id}} {
                                    display: flex;
                                    flex-direction: column;
                                    align-items: center;
                                    justify-content: center;
                                }

                                .folder-name-picker-{{$folder->id}} {
                                    font-weight: 600;
                                    font-size: 0.875rem;
                                    line-height: 1.25rem;
                                    text-align: center;
                                    max-width: 120px;
                                    overflow: hidden;
                                    text-overflow: ellipsis;
                                    white-space: nowrap;
                                    color: rgb(17 24 39);
                                }

                                .dark .folder-name-picker-{{$folder->id}} {
                                    color: rgb(249 250 251);
                                }

                                .folder-date-picker-{{$folder->id}} {
                                    color: rgb(107 114 128);
                                    font-size: 0.75rem;
                                    line-height: 1rem;
                                    text-align: center;
                                    overflow: hidden;
                                    text-overflow: ellipsis;
                                    white-space: nowrap;
                                }

                                .dark .folder-date-picker-{{$folder->id}} {
                                    color: rgb(156 163 175);
                                }
                            </style>
                            <div class="folder-container-picker-{{$folder->id}}">
                                <div class="folder-icon-picker-{{$folder->id}}">
                                    @if($folder->icon)
                                        <x-filament::icon name="{{$folder->icon}}" class="folder-icon-content-picker-{{$folder->id}}"/>
                                    @endif
                                    @if($folder->is_protected)
                                        <div class="folder-lock-badge-picker-{{$folder->id}}">
                                            <x-filament::icon name="heroicon-o-lock-closed" class="folder-lock-icon-picker-{{$folder->id}}" />
                                        </div>
                                    @endif
                                </div>
                                <div class="folder-info-picker-{{$folder->id}}">
                                    <h1 class="folder-name-picker-{{$folder->id}}"
                                        x-data
                                        x-tooltip="{
                                            content: '{{ addslashes($folder->name) }}',
                                            theme: $root.closest('.dark') ? 'dark' : 'light',
                                        }">
                                        {{ $folder->name }}
                                    </h1>
                                    <p class="folder-date-picker-{{$folder->id}}">
                                        {{ $folder->created_at->diffForHumans() }}
                                    </p>
                                </div>
                            </div>
                        </button>
                    @endforeach
                </div>
            </div>
        @endif

        {{-- Media Grid --}}
        @if($media->count() > 0)
            <div class="space-y-3">
                <h3 class="text-sm font-semibold text-gray-950 dark:text-white">
                    {{ trans('filament-media-manager::messages.picker.media_files') }}
                </h3>
                <div class="media-picker-grid">
                    @foreach($media as $mediaItem)
                        <div
                            wire:key="media-{{ $mediaItem->uuid }}"
                            class="relative"
                        >
                            <button
                                type="button"
                                wire:click="toggleMediaSelection('{{ $mediaItem->uuid }}')"
                                style="background: transparent; border: none; cursor: pointer; padding: 0; width: 100%;"
                            >
                                @php
                                    $extension = strtolower(pathinfo($mediaItem->file_name, PATHINFO_EXTENSION));
                                    $title = $mediaItem->hasCustomProperty('title') ? (!empty($mediaItem->getCustomProperty('title')) ? $mediaItem->getCustomProperty('title') : $mediaItem->name) : $mediaItem->name;

                                    // File type icon mapping
                                    $fileIcons = [
                                        'pdf' => ['icon' => 'heroicon-o-document-text', 'color' => '#ef4444'],
                                        'doc' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
                                        'docx' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
                                        'xls' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
                                        'xlsx' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
                                        'ppt' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
                                        'pptx' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
                                        'zip' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                        'rar' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                        'json' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
                                        'xml' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
                                        'html' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
                                        'css' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                        'js' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
                                        'php' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
                                        'svg' => ['icon' => 'heroicon-o-photo', 'color' => '#f59e0b'],
                                    ];

                                    $fileIcon = $fileIcons[$extension] ?? ['icon' => 'heroicon-o-document', 'color' => '#9ca3af'];
                                @endphp

                                <style>
                                    .media-card-picker-{{$mediaItem->id}} {
                                        display: flex;
                                        flex-direction: column;
                                        align-items: center;
                                        justify-content: center;
                                        gap: 0.5rem;
                                        padding: 0.5rem;
                                        border-radius: 0.5rem;
                                        transition: background-color 0.15s ease;
                                        position: relative;
                                    }

                                    .media-card-picker-{{$mediaItem->id}}:hover {
                                        background-color: rgb(249 250 251);
                                    }

                                    .dark .media-card-picker-{{$mediaItem->id}}:hover {
                                        background-color: rgb(55 65 81 / 0.5);
                                    }

                                    .media-card-picker-{{$mediaItem->id}}.selected {
                                        background-color: rgb(239 246 255);
                                        border: 2px solid rgb(59 130 246);
                                    }

                                    .dark .media-card-picker-{{$mediaItem->id}}.selected {
                                        background-color: rgb(37 99 235 / 0.2);
                                        border-color: rgb(96 165 250);
                                    }

                                    .media-preview-picker-{{$mediaItem->id}} {
                                        display: flex;
                                        flex-direction: column;
                                        align-items: center;
                                        justify-content: center;
                                        width: 100px;
                                        height: 70px;
                                        position: relative;
                                        overflow: hidden;
                                        margin: 10px;
                                    }

                                    .media-preview-with-bg-picker-{{$mediaItem->id}} {
                                        border-radius: 5px;
                                        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
                                        background-color: rgb(243 244 246);
                                    }

                                    .dark .media-preview-with-bg-picker-{{$mediaItem->id}} {
                                        background-color: rgb(31 41 55);
                                    }

                                    .media-preview-picker-{{$mediaItem->id}} img {
                                        width: 100%;
                                        height: 100%;
                                        object-fit: cover;
                                        border-radius: 5px;
                                    }

                                    .media-preview-picker-{{$mediaItem->id}} video {
                                        width: 100%;
                                        height: 100%;
                                        object-fit: cover;
                                        border-radius: 5px;
                                    }

                                    .media-icon-large-picker-{{$mediaItem->id}} {
                                        width: 4rem;
                                        height: 4rem;
                                    }

                                    .media-file-icon-picker-{{$mediaItem->id}} {
                                        display: flex;
                                        flex-direction: column;
                                        align-items: center;
                                        justify-content: center;
                                        gap: 0.25rem;
                                        width: 100%;
                                        height: 100%;
                                    }

                                    .media-file-icon-image-picker-{{$mediaItem->id}} {
                                        width: 3.5rem;
                                        height: 3.5rem;
                                    }

                                    .media-file-extension-picker-{{$mediaItem->id}} {
                                        font-size: 0.625rem;
                                        font-weight: 600;
                                        text-transform: uppercase;
                                        color: rgb(107 114 128);
                                    }

                                    .dark .media-file-extension-picker-{{$mediaItem->id}} {
                                        color: rgb(156 163 175);
                                    }

                                    .media-info-picker-{{$mediaItem->id}} {
                                        display: flex;
                                        flex-direction: column;
                                        align-items: center;
                                        justify-content: center;
                                    }

                                    .media-title-picker-{{$mediaItem->id}} {
                                        font-weight: 600;
                                        font-size: 0.875rem;
                                        line-height: 1.25rem;
                                        text-align: center;
                                        max-width: 120px;
                                        overflow: hidden;
                                        text-overflow: ellipsis;
                                        white-space: nowrap;
                                        color: rgb(17 24 39);
                                    }

                                    .dark .media-title-picker-{{$mediaItem->id}} {
                                        color: rgb(249 250 251);
                                    }

                                    .media-timestamp-picker-{{$mediaItem->id}} {
                                        color: rgb(107 114 128);
                                        font-size: 0.75rem;
                                        line-height: 1rem;
                                        text-align: center;
                                        overflow: hidden;
                                        text-overflow: ellipsis;
                                        white-space: nowrap;
                                    }

                                    .dark .media-timestamp-picker-{{$mediaItem->id}} {
                                        color: rgb(156 163 175);
                                    }

                                    .media-check-badge-picker-{{$mediaItem->id}} {
                                        position: absolute;
                                        top: 2px;
                                        right: 2px;
                                        background-color: rgb(59 130 246);
                                        border-radius: 9999px;
                                        padding: 0.25rem;
                                        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
                                        display: flex;
                                        align-items: center;
                                        justify-content: center;
                                        z-index: 10;
                                    }

                                    .media-check-icon-picker-{{$mediaItem->id}} {
                                        width: 0.875rem;
                                        height: 0.875rem;
                                        color: white;
                                    }
                                </style>

                                <div class="media-card-picker-{{$mediaItem->id}} {{ in_array($mediaItem->uuid, $selectedMedia) ? 'selected' : '' }}">
                                    <div class="media-preview-picker-{{$mediaItem->id}} {{ str($mediaItem->mime_type)->contains(['image', 'video']) ? 'media-preview-with-bg-picker-' . $mediaItem->id : '' }}"
                                         x-data>
                                        @if(str($mediaItem->mime_type)->contains('image'))
                                            <img src="{{ $mediaItem->getUrl() }}" alt="{{ $title }}" />
                                        @elseif(str($mediaItem->mime_type)->contains('video'))
                                            <video src="{{ $mediaItem->getUrl() }}"></video>
                                        @elseif(str($mediaItem->mime_type)->contains('audio'))
                                            <x-filament::icon name="heroicon-o-musical-note" class="media-icon-large-picker-{{$mediaItem->id}}" style="color: #ec4899;" />
                                        @else
                                            <div class="media-file-icon-picker-{{$mediaItem->id}}">
                                                <x-filament::icon :name="$fileIcon['icon']" class="media-file-icon-image-picker-{{$mediaItem->id}}" style="color: {{ $fileIcon['color'] }};" />
                                                <span class="media-file-extension-picker-{{$mediaItem->id}}">{{ $extension }}</span>
                                            </div>
                                        @endif
                                    </div>

                                    <div class="media-info-picker-{{$mediaItem->id}}">
                                        <h1 class="media-title-picker-{{$mediaItem->id}}"
                                            x-data
                                            x-tooltip="{
                                                content: '{{ addslashes($title) }}',
                                                theme: $root.closest('.dark') ? 'dark' : 'light',
                                            }">
                                            {{ $title }}
                                        </h1>
                                        <p class="media-timestamp-picker-{{$mediaItem->id}}">
                                            {{ $mediaItem->created_at->diffForHumans() }}
                                        </p>
                                    </div>

                                    @if(in_array($mediaItem->uuid, $selectedMedia))
                                        <div class="media-check-badge-picker-{{$mediaItem->id}}">
                                            <x-filament::icon name="heroicon-m-check" class="media-check-icon-picker-{{$mediaItem->id}}" />
                                        </div>
                                    @endif
                                </div>
                            </button>
                        </div>
                    @endforeach
                </div>
            </div>
        @endif

        {{-- Empty State --}}
        @if($folders->count() === 0 && $media->count() === 0)
            <div class="fi-ta-empty-state px-6 py-12">
                <div class="fi-ta-empty-state-content mx-auto grid max-w-lg justify-items-center text-center">
                    <div class="fi-ta-empty-state-icon-ctn mb-4 rounded-full bg-gray-100 p-3 dark:bg-gray-500/20">
                        <x-filament::icon
                            icon="heroicon-o-folder-open"
                            class="fi-ta-empty-state-icon h-6 w-6 text-gray-500 dark:text-gray-400"
                        />
                    </div>
                    <h4 class="fi-ta-empty-state-heading text-base font-semibold leading-6 text-gray-950 dark:text-white">
                        {{ trans('filament-media-manager::messages.picker.empty') }}
                    </h4>
                </div>
            </div>
        @endif
    </div>

    {{-- Selected Items Preview (Multiple Mode Only) --}}
    @if($isMultiple && count($selectedMedia) > 0)
        @php
            // Ensure $selectedMedia is a flat array of UUIDs
            $uuids = collect($selectedMedia)->flatten()->filter()->unique()->toArray();
            $selectedMediaItems = \TomatoPHP\FilamentMediaManager\Models\Media::withoutGlobalScope('folder')->whereIn('uuid', $uuids)->get();
        @endphp
        <style>
            .fi-selected-preview-section {
                margin-top: 1rem;
                padding-top: 1rem;
                border-top: 1px solid rgb(0 0 0 / 0.1);
            }

            .fi-selected-preview-section:where(.dark,.dark *) {
                border-top-color: rgb(255 255 255 / 0.1);
            }

            .fi-selected-preview-header {
                display: flex;
                align-items: center;
                justify-content: space-between;
                margin-bottom: 0.75rem;
            }

            .fi-selected-preview-title {
                font-size: 0.875rem;
                font-weight: 600;
                color: rgb(17 24 39);
            }

            .fi-selected-preview-title:where(.dark,.dark *) {
                color: white;
            }

            .fi-selected-list-container {
                overflow: hidden;
                border-radius: 0.5rem;
                border: 1px solid rgb(0 0 0 / 0.1);
                background-color: white;
                box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
                padding: 0.5rem;
            }

            .fi-selected-list-container:where(.dark,.dark *) {
                border-color: rgb(255 255 255 / 0.1);
                background-color: var(--gray-950);
            }

            .fi-selected-list-item {
                display: flex;
                align-items: center;
                gap: 1rem;
                padding: 0.75rem;
                transition: background-color 0.15s;
                border-radius: 0.375rem;
            }

            .fi-selected-list-item:not(:first-child) {
                margin-top: 0.5rem;
            }

            .fi-selected-list-item:hover {
                background-color: rgb(249 250 251);
            }

            .fi-selected-list-item:where(.dark,.dark *):hover {
                background-color: rgb(255 255 255 / 0.05);
            }

            .fi-selected-preview-thumb {
                display: flex;
                width: 3.5rem;
                height: 3.5rem;
                flex-shrink: 0;
                align-items: center;
                justify-content: center;
                overflow: hidden;
                border-radius: 0.5rem;
                border: 1px solid rgb(0 0 0 / 0.1);
                background-color: rgb(249 250 251);
                padding: 0.25rem;
            }

            .fi-selected-preview-thumb:where(.dark,.dark *) {
                border-color: rgb(255 255 255 / 0.1);
                background-color: var(--gray-800);
            }

            .fi-selected-preview-thumb img {
                height: 100%;
                width: 100%;
                object-fit: cover;
                border-radius: 0.25rem;
            }

            .fi-selected-icon {
                height: 1.75rem;
                width: 1.75rem;
                color: rgb(107 114 128);
            }

            .fi-selected-icon:where(.dark,.dark *) {
                color: rgb(156 163 175);
            }

            .fi-selected-icon-danger {
                height: 1.75rem;
                width: 1.75rem;
                color: rgb(239 68 68);
            }

            .fi-selected-file-info {
                min-width: 0;
                flex: 1;
            }

            .fi-selected-file-name {
                overflow: hidden;
                text-overflow: ellipsis;
                white-space: nowrap;
                font-size: 0.875rem;
                font-weight: 600;
                color: rgb(17 24 39);
            }

            .fi-selected-file-name:where(.dark,.dark *) {
                color: white;
            }

            .fi-selected-file-filename {
                overflow: hidden;
                text-overflow: ellipsis;
                white-space: nowrap;
                font-size: 0.75rem;
                color: rgb(107 114 128);
            }

            .fi-selected-file-filename:where(.dark,.dark *) {
                color: rgb(156 163 175);
            }

            .fi-selected-file-meta {
                margin-top: 0.125rem;
                font-size: 0.75rem;
                color: rgb(107 114 128);
            }

            .fi-selected-file-meta:where(.dark,.dark *) {
                color: rgb(156 163 175);
            }

            .fi-action-buttons {
                display: flex;
                align-items: center;
                justify-content: space-between;
                gap: 0.75rem;
                border-top: 1px solid rgb(0 0 0 / 0.1);
                padding-top: 1rem;
            }

            .fi-action-buttons:where(.dark,.dark *) {
                border-top-color: rgb(255 255 255 / 0.1);
            }

            .fi-action-buttons-right {
                display: flex;
                align-items: center;
                gap: 0.75rem;
            }
        </style>

        <div class="fi-selected-preview-section">
            <div class="fi-selected-preview-header">
                <h4 class="fi-selected-preview-title">
                    {{ trans('filament-media-manager::messages.picker.selected') }} ({{ count($selectedMedia) }})
                </h4>
            </div>

            {{-- List Container --}}
            <div class="fi-selected-list-container">
                @foreach($selectedMediaItems as $mediaItem)
                    <div class="fi-selected-list-item">
                        {{-- Preview --}}
                        <div class="fi-selected-preview-thumb">
                            @if(str($mediaItem->mime_type)->contains('image'))
                                <img
                                    src="{{ $mediaItem->getUrl() }}"
                                    alt="{{ $mediaItem->file_name }}"
                                />
                            @elseif(str($mediaItem->mime_type)->contains('video'))
                                <x-filament::icon
                                    icon="heroicon-o-video-camera"
                                    class="fi-selected-icon"
                                />
                            @elseif(str($mediaItem->mime_type)->contains('audio'))
                                <x-filament::icon
                                    icon="heroicon-o-musical-note"
                                    class="fi-selected-icon"
                                />
                            @elseif(str($mediaItem->mime_type)->contains('pdf'))
                                <x-filament::icon
                                    icon="heroicon-o-document-text"
                                    class="fi-selected-icon-danger"
                                />
                            @else
                                <x-filament::icon
                                    icon="heroicon-o-document"
                                    class="fi-selected-icon"
                                />
                            @endif
                        </div>

                        {{-- File Info --}}
                        <div class="fi-selected-file-info">
                            <p class="fi-selected-file-name">
                                {{ $mediaItem->name }}
                            </p>
                            <p class="fi-selected-file-filename">
                                {{ $mediaItem->file_name }}
                            </p>
                            <p class="fi-selected-file-meta">
                                {{ number_format($mediaItem->size / 1024, 2) }} KB
                                @if($mediaItem->hasCustomProperty('description') && $mediaItem->getCustomProperty('description'))
                                    <span style="margin: 0 0.25rem;">•</span>
                                    {{ str($mediaItem->getCustomProperty('description'))->limit(50) }}
                                @endif
                            </p>
                        </div>

                        {{-- Remove Button --}}
                        <x-filament::icon-button
                            icon="heroicon-m-x-mark"
                            color="danger"
                            size="sm"
                            wire:click="removeSelection('{{ $mediaItem->uuid }}')"
                            :label="trans('filament-media-manager::messages.picker.remove')"
                        />
                    </div>
                @endforeach
            </div>
        </div>
    @endif

    {{-- Action Buttons --}}
    @if($isMultiple)
        <div class="fi-action-buttons">
            @if(count($selectedMedia) > 0)
                {{-- Left: Selected Count Badge --}}
                <div>
                    <x-filament::badge color="primary" size="lg">
                        {{ count($selectedMedia) }} {{ trans('filament-media-manager::messages.picker.selected') }}
                    </x-filament::badge>
                </div>

                {{-- Right: Action Buttons --}}
                <div class="fi-action-buttons-right">
                    <x-filament::button
                        type="button"
                        color="danger"
                        outlined
                        wire:click="$set('selectedMedia', [])"
                    >
                        {{ trans('filament-media-manager::messages.picker.clear_all') }}
                    </x-filament::button>

                    <x-filament::button
                        type="button"
                        wire:click="selectMedia"
                    >
                        {{ trans('filament-media-manager::messages.picker.select') }}
                    </x-filament::button>
                </div>
            @endif
        </div>
    @endif

    <x-filament-actions::modals />
</div>
</file>

<file path="resources/views/pages/folders.blade.php">
<div class="fi-section-content" style="padding: 32px;">
    <div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(130px, 1fr)); gap: 1rem;">
        @foreach($records as $item)
            @livewire(\TomatoPHP\FilamentMediaManager\Livewire\FolderComponent::class, ['item' => $item], key('folder-' . $item->id))
        @endforeach
    </div>
</div>
</file>

<file path="routes/api.php">
<?php

use Illuminate\Support\Facades\Route;

Route::middleware(config('filament-media-manager.api.middlewares'))->prefix(config('filament-media-manager.api.prefix'))->name('media-manager.')->group(function () {
    Route::get('/folders', [\TomatoPHP\FilamentMediaManager\Http\Controllers\FolderController::class, 'index'])->name('folders.index');
    Route::get('/folders/{id}', [\TomatoPHP\FilamentMediaManager\Http\Controllers\FolderController::class, 'show'])->name('folders.show');
});
</file>

<file path="src/Facade/FilamentMediaManager.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Facade;

use Illuminate\Support\Facades\Facade;

/**
 * @method static void register(MediaManagerType|array $type)
 * @method static array getTypes()
 */
class FilamentMediaManager extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'filament-media-manager';
    }
}
</file>

<file path="src/Form/FileInput.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Form;

use Filament\Forms\Components\BaseFileUpload;
use Filament\Forms\Components\SpatieMediaLibraryFileUpload;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\MediaCollections\Models\Media;

class FileInput extends SpatieMediaLibraryFileUpload
{
    public function setUp(): void
    {
        parent::setUp();

        $this->loadStateFromRelationshipsUsing(static function (FileInput $component, HasMedia $record): void {
            /** @var Model&HasMedia $record */
            $media = $record->media()->where('uuid', $component->getState())->get()
                ->when(
                    $component->hasMediaFilter(),
                    fn (Collection $media) => $component->filterMedia($media)
                )
                ->mapWithKeys(function (Media $media): array {
                    $uuid = $media->getAttributeValue('uuid');

                    return [$uuid => $uuid];
                })
                ->toArray();

            $component->state($media);
        });

        $this->afterStateHydrated(static function (BaseFileUpload $component, string | array | null $state): void {});

        $this->saveRelationshipsUsing(static function (SpatieMediaLibraryFileUpload $component) {});

        $this->reorderUploadedFilesUsing(static function (SpatieMediaLibraryFileUpload $component, ?Model $record, array $state): array {
            return $state;
        });
    }
}
</file>

<file path="src/Http/Controllers/FolderController.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use TomatoPHP\FilamentMediaManager\Models\Folder;

class FolderController extends Controller
{
    public function index(Request $request)
    {
        $folders = config('filament-media-manager.model.folder')::query();

        if ($request->has('search')) {
            $folders->where('name', 'like', '%' . $request->search . '%');
        }

        return response()->json([
            'data' => config('filament-media-manager.api.resources.folders')::collection($folders->paginate(10)),
        ], 200);
    }

    public function show(int $id)
    {
        $folder = Folder::query()->findOrFail($id);

        return response()->json([
            'data' => config('filament-media-manager.api.resources.folder')::make($folder),
        ], 200);
    }
}
</file>

<file path="src/Http/Resources/FolderResource.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;
use Spatie\MediaLibrary\MediaCollections\Models\Media;
use TomatoPHP\FilamentMediaManager\Models\Folder;

class FolderResource extends JsonResource
{
    public function toArray($request)
    {
        $media = Media::query()
            ->where('collection_name', $this->collection);

        $subFolders = Folder::query()
            ->where('model_id', $this->id)
            ->where('model_type', "TomatoPHP\FilamentMediaManager\Models\Folder");

        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'media' => config('filament-media-manager.api.resources.media')::collection($media->get()),
            'folders' => config('filament-media-manager.api.resources.folders')::collection($subFolders->get()),
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}
</file>

<file path="src/Http/Resources/MediaResource.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class MediaResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'uuid' => $this->uuid,
            'name' => $this->name,
            'file_name' => $this->file_name,
            'mime_type' => $this->mime_type,
            'size' => $this->size,
            'custom_properties' => $this->custom_properties,
            'url' => $this->original_url,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}
</file>

<file path="src/Models/Media.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Models;

use Illuminate\Database\Eloquent\Builder;

class Media extends \Spatie\MediaLibrary\MediaCollections\Models\Media
{
    protected static function booted(): void
    {
        static::addGlobalScope('folder', function (Builder $query) {
            $folder = Folder::find(session()->get('folder_id'));
            if ($folder) {
                if (! $folder->model_type) {
                    $query->where('collection_name', $folder->collection);
                } else {
                    $query
                        ->where('model_type', $folder->model_type)
                        ->where('model_id', $folder->model_id)
                        ->where('collection_name', $folder->collection);
                }
            }
        });
    }
}
</file>

<file path="src/Resources/Actions/CreateSubFolderAction.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\Actions;

use Filament\Actions;
use Filament\Forms;
use Filament\Notifications\Notification;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Illuminate\Support\Str;
use TomatoPHP\FilamentIcons\Components\IconPicker;
use TomatoPHP\FilamentMediaManager\Models\Folder;

class CreateSubFolderAction
{
    public static function make(int $folder_id): Actions\Action
    {
        return Actions\Action::make('create_sub_folder')
            ->hidden(fn () => ! filament('filament-media-manager')->allowSubFolders)
            ->mountUsing(function () use ($folder_id) {
                session()->put('folder_id', $folder_id);
            })
            ->color('info')
            ->hiddenLabel()
            ->tooltip(trans('filament-media-manager::messages.media.actions.sub_folder.label'))
            ->label(trans('filament-media-manager::messages.media.actions.sub_folder.label'))
            ->icon('heroicon-o-folder-minus')
            ->fillForm(fn () => [
                'name' => '',
                'collection' => '',
                'description' => '',
                'icon' => '',
                'color' => '',
                'is_protected' => false,
                'password' => '',
                'password_confirmation' => '',
            ])
            ->schema([
                Forms\Components\TextInput::make('name')
                    ->label(trans('filament-media-manager::messages.folders.columns.name'))
                    ->columnSpanFull()
                    ->lazy()
                    ->afterStateUpdated(function (Set $set, Get $get) {
                        $set('collection', Str::slug($get('name')));
                    })
                    ->required()
                    ->maxLength(255),
                Forms\Components\TextInput::make('collection')
                    ->label(trans('filament-media-manager::messages.folders.columns.collection'))
                    ->columnSpanFull()
                    ->unique(Folder::class)
                    ->required()
                    ->maxLength(255),
                Forms\Components\Textarea::make('description')
                    ->label(trans('filament-media-manager::messages.folders.columns.description'))
                    ->columnSpanFull()
                    ->maxLength(255),
                IconPicker::make('icon')
                    ->label(trans('filament-media-manager::messages.folders.columns.icon')),
                Forms\Components\ColorPicker::make('color')
                    ->label(trans('filament-media-manager::messages.folders.columns.color')),
                Forms\Components\Toggle::make('is_protected')
                    ->label(trans('filament-media-manager::messages.folders.columns.is_protected'))
                    ->live()
                    ->columnSpanFull(),
                Forms\Components\TextInput::make('password')
                    ->label(trans('filament-media-manager::messages.folders.columns.password'))
                    ->hidden(fn (Get $get) => ! $get('is_protected'))
                    ->password()
                    ->revealable()
                    ->required()
                    ->maxLength(255),
                Forms\Components\TextInput::make('password_confirmation')
                    ->label(trans('filament-media-manager::messages.folders.columns.password_confirmation'))
                    ->hidden(fn (Get $get) => ! $get('is_protected'))
                    ->password()
                    ->required()
                    ->revealable()
                    ->maxLength(255),
            ])
            ->action(function (array $data) use ($folder_id) {
                $folder = Folder::find($folder_id);
                if ($folder) {
                    $data['user_id'] = auth()->user()->id;
                    $data['user_type'] = get_class(auth()->user());
                    $data['model_id'] = $folder_id;
                    $data['model_type'] = Folder::class;
                    Folder::query()->create($data);
                }

                Notification::make()
                    ->title('Folder Created')
                    ->body('Folder Created Successfully')
                    ->success()
                    ->send();
            });
    }
}
</file>

<file path="src/Resources/FolderResource/Pages/CreateFolder.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\FolderResource\Pages;

use Filament\Resources\Pages\CreateRecord;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource;

class CreateFolder extends CreateRecord
{
    protected static string $resource = FolderResource::class;
}
</file>

<file path="src/Resources/FolderResource/Pages/EditFolder.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\FolderResource\Pages;

use Filament\Actions;
use Filament\Resources\Pages\EditRecord;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource;

class EditFolder extends EditRecord
{
    protected static string $resource = FolderResource::class;

    protected function getHeaderActions(): array
    {
        return [
            Actions\DeleteAction::make(),
        ];
    }
}
</file>

<file path="src/Resources/MediaResource/Pages/CreateMedia.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\MediaResource\Pages;

use Filament\Resources\Pages\CreateRecord;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource;

class CreateMedia extends CreateRecord
{
    protected static string $resource = MediaResource::class;
}
</file>

<file path="src/Resources/MediaResource/Pages/EditMedia.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\MediaResource\Pages;

use Filament\Actions;
use Filament\Resources\Pages\EditRecord;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource;

class EditMedia extends EditRecord
{
    protected static string $resource = MediaResource::class;

    protected function getHeaderActions(): array
    {
        return [
            Actions\DeleteAction::make(),
        ];
    }
}
</file>

<file path="src/Traits/InteractsWithMediaFolders.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Traits;

trait InteractsWithMediaFolders
{
    public function folders()
    {
        return $this->morphToMany(config('filament-media-manager.model.folder'), 'model', 'folder_has_models', 'model_id', 'folder_id');
    }

    public function myFolders()
    {
        return $this->morphMany(config('filament-media-manager.model.folder'), 'user');
    }
}
</file>

<file path="src/Traits/InteractsWithMediaManager.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Traits;

use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\DB;
use TomatoPHP\FilamentMediaManager\Models\Media;

trait InteractsWithMediaManager
{
    /**
     * Get media attached via MediaManagerPicker by collection name
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerMedia(?string $collectionName = null): Collection
    {
        $query = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id);

        // Filter by collection name if specified
        if ($collectionName !== null) {
            $query->where('collection_name', $collectionName);
        } else {
            $query->whereNull('collection_name');
        }

        $mediaData = $query->orderBy('order_column')
            ->get(['media_id', 'order_column']);

        if ($mediaData->isEmpty()) {
            return new Collection;
        }

        $mediaIds = $mediaData->pluck('media_id')->toArray();
        $media = Media::withoutGlobalScope('folder')->whereIn('id', $mediaIds)->get()->keyBy('id');

        // Return media sorted by order_column as Eloquent Collection
        $sorted = $mediaData->map(function ($item) use ($media) {
            return $media->get($item->media_id);
        })->filter()->values()->all();

        return new Collection($sorted);
    }

    /**
     * Get media attached via MediaManagerPicker by UUIDs
     *
     * @param  array  $uuids  Array of media UUIDs
     */
    public function getMediaManagerMediaByUuids(array $uuids): Collection
    {
        if (empty($uuids)) {
            return new Collection;
        }

        return Media::withoutGlobalScope('folder')
            ->whereIn('uuid', $uuids)
            ->get();
    }

    /**
     * Get media attached via MediaManagerInput (using Spatie's media library)
     *
     * @param  string  $collectionName  The media collection name
     */
    public function getMediaManagerInputMedia(string $collectionName = 'default'): Collection
    {
        if (! method_exists($this, 'getMedia')) {
            return new Collection;
        }

        return $this->getMedia($collectionName);
    }

    /**
     * Attach media to model via MediaManagerPicker
     *
     * @param  array  $mediaUuids  Array of media UUIDs
     * @param  string|null  $collectionName  Optional collection name
     */
    public function attachMediaManagerMedia(array $mediaUuids, ?string $collectionName = null): void
    {
        $media = Media::withoutGlobalScope('folder')
            ->whereIn('uuid', $mediaUuids)
            ->get()
            ->keyBy('uuid');

        // Get current max order for this collection
        $maxOrderQuery = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id);

        if ($collectionName !== null) {
            $maxOrderQuery->where('collection_name', $collectionName);
        } else {
            $maxOrderQuery->whereNull('collection_name');
        }

        $maxOrder = $maxOrderQuery->max('order_column') ?? -1;
        $order = $maxOrder + 1;

        foreach ($mediaUuids as $uuid) {
            $mediaItem = $media->get($uuid);
            if (! $mediaItem) {
                continue;
            }

            DB::table('media_has_models')->updateOrInsert(
                [
                    'model_type' => get_class($this),
                    'model_id' => $this->id,
                    'media_id' => $mediaItem->id,
                    'collection_name' => $collectionName,
                ],
                [
                    'order_column' => $order++,
                    'created_at' => now(),
                    'updated_at' => now(),
                ]
            );
        }
    }

    /**
     * Detach media from model via MediaManagerPicker
     *
     * @param  array|null  $mediaUuids  Array of media UUIDs to detach, or null to detach all
     * @param  string|null  $collectionName  Optional collection name
     */
    public function detachMediaManagerMedia(?array $mediaUuids = null, ?string $collectionName = null): void
    {
        $query = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id);

        if ($collectionName !== null) {
            $query->where('collection_name', $collectionName);
        } elseif ($collectionName === null && $mediaUuids === null) {
            // Only apply whereNull when detaching all and no collection specified
            $query->whereNull('collection_name');
        }

        if ($mediaUuids !== null) {
            $mediaIds = Media::withoutGlobalScope('folder')
                ->whereIn('uuid', $mediaUuids)
                ->pluck('id')
                ->toArray();

            if (! empty($mediaIds)) {
                $query->whereIn('media_id', $mediaIds);
            }
        }

        $query->delete();
    }

    /**
     * Sync media with model (detach all and attach new)
     *
     * @param  array  $mediaUuids  Array of media UUIDs (order preserved)
     * @param  string|null  $collectionName  Optional collection name
     */
    public function syncMediaManagerMedia(array $mediaUuids, ?string $collectionName = null): void
    {
        // Clear existing attachments for this collection
        $deleteQuery = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id);

        if ($collectionName !== null) {
            $deleteQuery->where('collection_name', $collectionName);
        } else {
            $deleteQuery->whereNull('collection_name');
        }

        $deleteQuery->delete();

        if (empty($mediaUuids)) {
            return;
        }

        // Attach new media with order
        $media = Media::withoutGlobalScope('folder')
            ->whereIn('uuid', $mediaUuids)
            ->get()
            ->keyBy('uuid');

        $order = 0;
        foreach ($mediaUuids as $uuid) {
            $mediaItem = $media->get($uuid);
            if (! $mediaItem) {
                continue;
            }

            DB::table('media_has_models')->insert([
                'model_type' => get_class($this),
                'model_id' => $this->id,
                'media_id' => $mediaItem->id,
                'collection_name' => $collectionName,
                'order_column' => $order++,
                'created_at' => now(),
                'updated_at' => now(),
            ]);
        }
    }

    /**
     * Check if model has specific media attached
     *
     * @param  string  $mediaUuid  Media UUID to check
     * @param  string|null  $collectionName  Optional collection name
     */
    public function hasMediaManagerMedia(string $mediaUuid, ?string $collectionName = null): bool
    {
        $media = Media::withoutGlobalScope('folder')
            ->where('uuid', $mediaUuid)
            ->first();

        if (! $media) {
            return false;
        }

        $query = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id)
            ->where('media_id', $media->id);

        if ($collectionName !== null) {
            $query->where('collection_name', $collectionName);
        }

        return $query->exists();
    }

    /**
     * Get first media item from MediaManagerPicker
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getFirstMediaManagerMedia(?string $collectionName = null): ?Media
    {
        return $this->getMediaManagerMedia($collectionName)->first();
    }

    /**
     * Get media URL from MediaManagerPicker (first item)
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerUrl(?string $collectionName = null): ?string
    {
        $media = $this->getFirstMediaManagerMedia($collectionName);

        if (! $media) {
            return null;
        }

        return $media->getUrl();
    }

    /**
     * Get all media URLs from MediaManagerPicker
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerUrls(?string $collectionName = null): array
    {
        return $this->getMediaManagerMedia($collectionName)
            ->map(fn ($mediaItem) => $mediaItem->getUrl())
            ->toArray();
    }

    /**
     * Get responsive images for media from MediaManagerPicker
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     * @return \Illuminate\Support\Collection Collection of media with responsive images data
     */
    public function getMediaManagerResponsiveImages(?string $collectionName = null): Collection
    {
        $query = DB::table('media_has_models')
            ->where('model_type', get_class($this))
            ->where('model_id', $this->id)
            ->where('responsive_images', true);

        if ($collectionName !== null) {
            $query->where('collection_name', $collectionName);
        } else {
            $query->whereNull('collection_name');
        }

        $mediaData = $query->orderBy('order_column')
            ->get(['media_id', 'order_column']);

        if ($mediaData->isEmpty()) {
            return new Collection;
        }

        $mediaIds = $mediaData->pluck('media_id')->toArray();
        $media = Media::withoutGlobalScope('folder')->whereIn('id', $mediaIds)->get()->keyBy('id');

        // Return media sorted by order_column with responsive images
        $sorted = $mediaData->map(function ($item) use ($media) {
            $mediaItem = $media->get($item->media_id);
            if (! $mediaItem) {
                return null;
            }

            return [
                'media' => $mediaItem,
                'url' => $mediaItem->getUrl(),
                'responsive_urls' => $mediaItem->getResponsiveImageUrls(),
                'srcset' => $mediaItem->getSrcset(),
            ];
        })->filter()->values()->all();

        return new Collection($sorted);
    }

    /**
     * Get responsive images srcset attribute for first media item
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerSrcset(?string $collectionName = null): ?string
    {
        $responsiveImages = $this->getMediaManagerResponsiveImages($collectionName);

        if ($responsiveImages->isEmpty()) {
            return null;
        }

        return $responsiveImages->first()['srcset'] ?? null;
    }

    /**
     * Get all responsive images srcset attributes
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerSrcsets(?string $collectionName = null): array
    {
        return $this->getMediaManagerResponsiveImages($collectionName)
            ->pluck('srcset')
            ->filter()
            ->toArray();
    }

    /**
     * Get responsive image URLs for first media item
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getMediaManagerResponsiveUrls(?string $collectionName = null): ?array
    {
        $responsiveImages = $this->getMediaManagerResponsiveImages($collectionName);

        if ($responsiveImages->isEmpty()) {
            return null;
        }

        return $responsiveImages->first()['responsive_urls'] ?? null;
    }

    /**
     * Get all responsive image URLs for all media
     *
     * @param  string|null  $collectionName  Optional collection name to filter by
     */
    public function getAllMediaManagerResponsiveUrls(?string $collectionName = null): array
    {
        return $this->getMediaManagerResponsiveImages($collectionName)
            ->pluck('responsive_urls')
            ->filter()
            ->toArray();
    }
}
</file>

<file path="tests/src/InteractsWithMediaManagerTest.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Tests;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use TomatoPHP\FilamentMediaManager\Tests\Models\Product;
use TomatoPHP\FilamentMediaManager\Tests\Models\User;

use function Pest\Laravel\actingAs;

beforeEach(function () {
    Storage::fake('public');
    actingAs(User::factory()->create());
});

describe('InteractsWithMediaManager Trait', function () {
    it('can get media manager media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        // Attach via pivot table
        DB::table('media_has_models')->insert([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'media_id' => $media->id,
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        $result = $product->getMediaManagerMedia();

        expect($result)->toHaveCount(1);
        expect($result->first()->uuid)->toBe($media->uuid);
    });

    it('returns empty collection when no media', function () {
        $product = Product::create(['name' => 'Test Product']);

        $result = $product->getMediaManagerMedia();

        expect($result)->toHaveCount(0);
    });

    it('can get media by uuids', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $result = $product->getMediaManagerMediaByUuids([$media1->uuid, $media2->uuid]);

        expect($result)->toHaveCount(2);
        expect($result->pluck('uuid')->toArray())->toContain($media1->uuid, $media2->uuid);
    });

    it('can get media manager input media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $product->addMedia(UploadedFile::fake()->image('test1.jpg'))->toMediaCollection('images');
        $product->addMedia(UploadedFile::fake()->image('test2.jpg'))->toMediaCollection('images');

        $result = $product->getMediaManagerInputMedia('images');

        expect($result)->toHaveCount(2);
    });

    it('can attach media manager media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);

        $count = DB::table('media_has_models')
            ->where('model_type', Product::class)
            ->where('model_id', $product->id)
            ->count();

        expect($count)->toBe(2);
    });

    it('prevents duplicate attachments', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media->uuid]);
        $product->attachMediaManagerMedia([$media->uuid]); // Try to attach again

        $count = DB::table('media_has_models')
            ->where('model_type', Product::class)
            ->where('model_id', $product->id)
            ->count();

        expect($count)->toBe(1); // Should still be 1
    });

    it('can detach specific media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);
        $product->detachMediaManagerMedia([$media1->uuid]);

        $count = DB::table('media_has_models')
            ->where('model_type', Product::class)
            ->where('model_id', $product->id)
            ->count();

        expect($count)->toBe(1);
    });

    it('can detach all media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);
        $product->detachMediaManagerMedia(); // Detach all

        $count = DB::table('media_has_models')
            ->where('model_type', Product::class)
            ->where('model_id', $product->id)
            ->count();

        expect($count)->toBe(0);
    });

    it('can sync media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');
        $media3 = $product->addMedia(UploadedFile::fake()->image('test3.jpg'))
            ->toMediaCollection('images');

        // Initially attach media1 and media2
        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);

        // Sync to only media3 (should detach media1 and media2, attach media3)
        $product->syncMediaManagerMedia([$media3->uuid]);

        $attachedUuids = DB::table('media_has_models')
            ->where('media_has_models.model_type', Product::class)
            ->where('media_has_models.model_id', $product->id)
            ->join('media', 'media_has_models.media_id', '=', 'media.id')
            ->pluck('media.uuid')
            ->toArray();

        expect($attachedUuids)->toHaveCount(1);
        expect($attachedUuids)->toContain($media3->uuid);
        expect($attachedUuids)->not->toContain($media1->uuid, $media2->uuid);
    });

    it('can check if media exists', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media->uuid]);

        expect($product->hasMediaManagerMedia($media->uuid))->toBeTrue();
        expect($product->hasMediaManagerMedia('non-existent-uuid'))->toBeFalse();
    });

    it('can get first media', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);

        $first = $product->getFirstMediaManagerMedia();

        expect($first)->not->toBeNull();
        expect($first->uuid)->toBeIn([$media1->uuid, $media2->uuid]);
    });

    it('returns null when getting first media on empty collection', function () {
        $product = Product::create(['name' => 'Test Product']);

        $first = $product->getFirstMediaManagerMedia();

        expect($first)->toBeNull();
    });

    it('can get media url', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media->uuid]);

        $url = $product->getMediaManagerUrl();

        expect($url)->not->toBeNull();
        expect($url)->toContain('test.jpg');
    });

    it('returns null when getting url with no media', function () {
        $product = Product::create(['name' => 'Test Product']);

        $url = $product->getMediaManagerUrl();

        expect($url)->toBeNull();
    });

    it('can get all media urls', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media1 = $product->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product->attachMediaManagerMedia([$media1->uuid, $media2->uuid]);

        $urls = $product->getMediaManagerUrls();

        expect($urls)->toHaveCount(2);
        expect($urls[0])->toContain('test');
        expect($urls[1])->toContain('test');
    });

    it('returns empty array when getting urls with no media', function () {
        $product = Product::create(['name' => 'Test Product']);

        $urls = $product->getMediaManagerUrls();

        expect($urls)->toHaveCount(0);
    });

    it('can filter media by field name', function () {
        $product = Product::create(['name' => 'Test Product']);
        $media = $product->addMedia(UploadedFile::fake()->image('test.jpg'))
            ->withCustomProperties(['field_name' => 'avatar'])
            ->toMediaCollection('images');

        DB::table('media_has_models')->insert([
            'model_type' => Product::class,
            'model_id' => $product->id,
            'media_id' => $media->id,
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        $result = $product->getMediaManagerMedia('avatar');

        expect($result)->toHaveCount(1);
        expect($result->first()->getCustomProperty('field_name'))->toBe('avatar');
    });
});

describe('InteractsWithMediaManager with Multiple Models', function () {
    it('isolates media between different models', function () {
        $product1 = Product::create(['name' => 'Product 1']);
        $product2 = Product::create(['name' => 'Product 2']);

        $media1 = $product1->addMedia(UploadedFile::fake()->image('test1.jpg'))
            ->toMediaCollection('images');
        $media2 = $product2->addMedia(UploadedFile::fake()->image('test2.jpg'))
            ->toMediaCollection('images');

        $product1->attachMediaManagerMedia([$media1->uuid]);
        $product2->attachMediaManagerMedia([$media2->uuid]);

        $product1Media = $product1->getMediaManagerMedia();
        $product2Media = $product2->getMediaManagerMedia();

        expect($product1Media)->toHaveCount(1);
        expect($product2Media)->toHaveCount(1);
        expect($product1Media->first()->uuid)->toBe($media1->uuid);
        expect($product2Media->first()->uuid)->toBe($media2->uuid);
    });
});
</file>

<file path="module.json">
{
    "name": "FilamentMediaManager",
    "alias": "filament-media-manager",
    "description": {
        "ar": "قم بادارة ملفات الوسائط الخاصة بك باستخدام مكتبة الوسائط من spatie بواجهة رسومية سهلة الاستخدام لـ FilamentPHP",
        "en": "Manage your media files using spatie media library with easy to use GUI for FilamentPHP",
        "gr": "Manage your media files using spatie media library with easy to use GUI for FilamentPHP",
        "sp": "Manage your media files using spatie media library with easy to use GUI for FilamentPHP"
    },
    "keywords": [],
    "priority": 0,
    "providers": [
        "TomatoPHP\\FilamentMediaManager\\FilamentMediaManagerServiceProvider"
    ],
    "files": [],
    "title": {
        "ar": "مدير الوسائط",
        "en": "Media Manager",
        "gr": "Media Manager",
        "sp": "Media Manager"
    },
    "color": "#cc1448",
    "icon": "heroicon-c-photo",
    "placeholder": "https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/3x1io-tomato-media-manager.jpg",
    "type": "plugin",
    "version": "v1.1.3",
    "github" : "https://github.com/tomatophp/filament-media-manager",
    "docs" : "https://github.com/tomatophp/filament-media-manager"
}
</file>

<file path="database/migrations/2024_10_03_171809_create_folder_has_models_table.php">
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('folder_has_models', function (Blueprint $table) {
            $table->id();

            // Morph
            $table->string('model_type');
            $table->unsignedBigInteger('model_id');

            // Folder
            $table->foreignId('folder_id')->constrained('folders')->onDelete('cascade');

            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('folder_has_models');
    }
};
</file>

<file path="resources/views/forms/media-manager-picker.blade.php">
@php
    $statePath = $getStatePath();
    $isMultiple = $isMultiple();
    $state = $getState();
    $mediaItems = [];

    if ($state) {
        $uuids = is_array($state) ? $state : [$state];
        $media = \TomatoPHP\FilamentMediaManager\Models\Media::whereIn('uuid', $uuids)->get()->keyBy('uuid');

        // Order media items according to state array order
        foreach ($uuids as $uuid) {
            if ($media->has($uuid)) {
                $mediaItems[] = $media->get($uuid);
            }
        }
    }
@endphp

<x-dynamic-component :component="$getFieldWrapperView()" :field="$field">
    <style>
        .fi-picker-list-container {
            overflow: hidden;
            border-radius: 0.5rem;
            border: 1px solid rgb(0 0 0 / 0.1);
            background-color: white;
            box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
            margin-top: 1rem;
            padding: 0.5rem;
        }

        .fi-picker-list-container:where(.dark,.dark *) {
            border-color: rgb(255 255 255 / 0.1);
            background-color: var(--gray-950);
        }

        .fi-picker-list-item {
            display: flex;
            align-items: center;
            gap: 1rem;
            padding: 0.75rem;
            transition: background-color 0.15s;
            border-radius: 0.375rem;
        }

        .fi-picker-list-item:not(:first-child) {
            margin-top: 0.5rem;
        }

        .fi-picker-list-item:hover {
            background-color: rgb(249 250 251);
        }

        .fi-picker-list-item:where(.dark,.dark *):hover {
            background-color: rgb(255 255 255 / 0.05);
        }

        .fi-picker-preview-thumb {
            display: flex;
            width: 3.5rem;
            height: 3.5rem;
            flex-shrink: 0;
            align-items: center;
            justify-content: center;
            overflow: hidden;
            border-radius: 0.5rem;
            border: 1px solid rgb(0 0 0 / 0.1);
            background-color: rgb(249 250 251);
            padding: 0.25rem;
        }

        .fi-picker-preview-thumb:where(.dark,.dark *) {
            border-color: rgb(255 255 255 / 0.1);
            background-color: var(--gray-800);
        }

        .fi-picker-preview-thumb img {
            height: 100%;
            width: 100%;
            object-fit: cover;
            border-radius: 0.25rem;
        }

        .fi-picker-icon {
            height: 1.75rem;
            width: 1.75rem;
            color: rgb(107 114 128);
        }

        .fi-picker-icon:where(.dark,.dark *) {
            color: rgb(156 163 175);
        }

        .fi-picker-icon-danger {
            height: 1.75rem;
            width: 1.75rem;
            color: rgb(239 68 68);
        }

        .fi-picker-file-info {
            min-width: 0;
            flex: 1;
        }

        .fi-picker-file-name {
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
            font-size: 0.875rem;
            font-weight: 600;
            color: rgb(17 24 39);
        }

        .fi-picker-file-name:where(.dark,.dark *) {
            color: white;
        }

        .fi-picker-file-filename {
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
            font-size: 0.75rem;
            color: rgb(107 114 128);
        }

        .fi-picker-file-filename:where(.dark,.dark *) {
            color: rgb(156 163 175);
        }

        .fi-picker-file-meta {
            margin-top: 0.125rem;
            font-size: 0.75rem;
            color: rgb(107 114 128);
        }

        .fi-picker-file-meta:where(.dark,.dark *) {
            color: rgb(156 163 175);
        }

        .fi-picker-empty-state-container {
            overflow: hidden;
            border-radius: 0.5rem;
            border: 1px solid rgb(0 0 0 / 0.1);
            background-color: white;
            box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
            margin-top: 1rem;
        }

        .fi-picker-empty-state-container:where(.dark,.dark *) {
            border-color: rgb(255 255 255 / 0.1);
            background-color: var(--gray-950);
        }

        .sortable-ghost {
            opacity: 0.4;
        }
    </style>

    <div
        x-data="{
            state: $wire.{{ $applyStateBindingModifiers("\$entangle('{$statePath}')") }},
            pickerKey: '{{ $getId() }}',
            isMultiple: {{ $isMultiple ? 'true' : 'false' }},
            sortableInstance: null,

            initSortable() {
                if (!this.isMultiple) return;

                // Destroy existing instance
                if (this.sortableInstance) {
                    this.sortableInstance.destroy();
                    this.sortableInstance = null;
                }

                const container = this.$refs.mediaList;
                if (!container || !window.Sortable) return;

                // Only init if we have items
                const items = container.querySelectorAll('.fi-picker-list-item');
                if (items.length <= 1) return;

                this.sortableInstance = window.Sortable.create(container, {
                    animation: 150,
                    handle: '.fi-picker-drag-handle',
                    ghostClass: 'sortable-ghost',
                    onEnd: (evt) => {
                        // Get current state
                        const items = Array.isArray(this.state) ? [...this.state] : [this.state];

                        // Move the item
                        const [movedItem] = items.splice(evt.oldIndex, 1);
                        items.splice(evt.newIndex, 0, movedItem);

                        // Update state - this will trigger Livewire to re-render
                        this.state = items;
                    }
                });
            },

            destroySortable() {
                if (this.sortableInstance) {
                    this.sortableInstance.destroy();
                    this.sortableInstance = null;
                }
            }
        }"
        x-init="
            let isProcessing = false;

            // Listen for media selection events
            window.addEventListener('media-selected-' + pickerKey, (event) => {
                if (isProcessing) return;
                isProcessing = true;

                const newState = event.detail?.media || event.detail;
                state = newState;

                $wire.set('{{ $statePath }}', newState).then(() => {
                    $wire.call('unmountAction', 'getBrowseAction');

                    setTimeout(() => {
                        isProcessing = false;
                    }, 300);
                });
            });

            // Watch state changes and reinit sortable
            $watch('state', () => {
                $nextTick(() => initSortable());
            });

            // Initialize on mount
            $nextTick(() => initSortable());
        "
        x-on:destroy="destroySortable()"
        class="space-y-3"
    >
        {{-- Preview Section --}}
        @if(!empty($mediaItems) && count($mediaItems) > 0)
            {{-- List Container --}}
            <div class="fi-picker-list-container" x-ref="mediaList">
                @foreach($mediaItems as $media)
                    <div class="fi-picker-list-item" data-uuid="{{ $media->uuid }}" wire:key="media-{{ $media->uuid }}">
                        {{-- Drag Handle (only show if multiple) --}}
                        @if($isMultiple && count($mediaItems) > 1)
                            <div class="fi-picker-drag-handle" style="cursor: grab; padding: 0.5rem; margin-left: -0.5rem;">
                                <x-filament::icon
                                    icon="heroicon-o-bars-3"
                                    class="h-5 w-5 text-gray-400 dark:text-gray-500"
                                />
                            </div>
                        @endif

                        {{-- Preview --}}
                        <div class="fi-picker-preview-thumb">
                            @if(str_starts_with($media->mime_type, 'image/'))
                                <img
                                    src="{{ $media->getUrl() }}"
                                    alt="{{ $media->name }}"
                                />
                            @elseif(str($media->mime_type)->contains('video'))
                                <x-filament::icon
                                    icon="heroicon-o-video-camera"
                                    class="fi-picker-icon"
                                />
                            @elseif(str($media->mime_type)->contains('audio'))
                                <x-filament::icon
                                    icon="heroicon-o-musical-note"
                                    class="fi-picker-icon"
                                />
                            @elseif(str($media->mime_type)->contains('pdf'))
                                <x-filament::icon
                                    icon="heroicon-o-document-text"
                                    class="fi-picker-icon-danger"
                                />
                            @else
                                <x-filament::icon
                                    icon="heroicon-o-document"
                                    class="fi-picker-icon"
                                />
                            @endif
                        </div>

                        {{-- File Info --}}
                        <div class="fi-picker-file-info">
                            <p class="fi-picker-file-name">
                                {{ $media->name }}
                            </p>
                            <p class="fi-picker-file-filename">
                                {{ $media->file_name }}
                            </p>
                            <p class="fi-picker-file-meta">
                                {{ number_format($media->size / 1024, 2) }} KB
                                @if($media->hasCustomProperty('description') && $media->getCustomProperty('description'))
                                    <span style="margin: 0 0.25rem;">•</span>
                                    {{ str($media->getCustomProperty('description'))->limit(50) }}
                                @endif
                            </p>
                        </div>

                        {{-- Remove Button --}}
                        {{ $getAction('removeMediaItem')->arguments(['uuid' => $media->uuid]) }}
                    </div>
                @endforeach
            </div>
        @else
            <div class="fi-picker-empty-state-container">
                <div class="fi-ta-empty-state px-6 py-12">
                    <div class="fi-ta-empty-state-content mx-auto grid max-w-lg justify-items-center text-center">
                        <div class="fi-ta-empty-state-icon-ctn mb-4 rounded-full bg-gray-100 p-3 dark:bg-gray-500/20">
                            <x-filament::icon
                                icon="heroicon-o-photo"
                                class="fi-ta-empty-state-icon h-6 w-6 text-gray-500 dark:text-gray-400"
                            />
                        </div>
                        <h4 class="fi-ta-empty-state-heading text-base font-semibold leading-6 text-gray-950 dark:text-white">
                            {{ trans('filament-media-manager::messages.picker.no_media_selected') }}
                        </h4>
                        <p class="fi-ta-empty-state-description mt-1 text-sm text-gray-500 dark:text-gray-400">
                            {{ __('Click "Browse Media" to select files') }}
                        </p>
                    </div>
                </div>
            </div>
        @endif

        {{-- Actions --}}
        <div class="flex flex-wrap items-center gap-2" style="margin-top: 1rem;">
            {{ $getAction('getBrowseAction') }}

            @if(!empty($mediaItems) && count($mediaItems) > 0)
                {{ $getAction('getRemoveAction') }}
            @endif
        </div>
    </div>
</x-dynamic-component>
</file>

<file path="src/Form/MediaManagerPicker.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Form;

use Closure;
use Filament\Actions\Action;
use Filament\Forms\Components\Field;
use Illuminate\Database\Eloquent\Model;
use TomatoPHP\FilamentMediaManager\Models\Media;

class MediaManagerPicker extends Field
{
    protected string $view = 'filament-media-manager::forms.media-manager-picker';

    protected string | Closure | null $diskName = null;

    protected bool | Closure $isMultiple = true;

    protected string | Closure | null $collectionName = null;

    protected int | Closure | null $maxItems = null;

    protected int | Closure | null $minItems = null;

    protected bool | Closure $generateResponsiveImages = false;

    protected function setUp(): void
    {
        parent::setUp();

        $this->registerActions([
            fn (MediaManagerPicker $component): Action => $component->getBrowseAction(),
            fn (MediaManagerPicker $component): Action => $component->getRemoveAction(),
            fn (MediaManagerPicker $component): Action => $component->getRemoveMediaItemAction(),
        ]);

        $this->afterStateHydrated(static function (MediaManagerPicker $component, ?Model $record): void {
            if (! $record || ! $record->exists) {
                return;
            }

            // Load media from media_has_models pivot table with ordering and collection filtering
            $query = \DB::table('media_has_models')
                ->where('model_type', get_class($record))
                ->where('model_id', $record->id);

            // Filter by collection name if specified
            $collectionName = $component->getCollectionName();
            if ($collectionName !== null) {
                $query->where('collection_name', $collectionName);
            } else {
                $query->whereNull('collection_name');
            }

            $mediaData = $query->orderBy('order_column')
                ->get(['media_id', 'order_column']);

            if ($mediaData->isEmpty()) {
                $component->state($component->isMultiple() ? [] : null);

                return;
            }

            $mediaIds = $mediaData->pluck('media_id')->toArray();
            $media = Media::whereIn('id', $mediaIds)->get()->keyBy('id');

            // Sort media by order_column
            $orderedMedia = $mediaData->map(function ($item) use ($media) {
                return $media->get($item->media_id);
            })->filter();

            if ($component->isMultiple()) {
                $component->state($orderedMedia->pluck('uuid')->toArray());
            } else {
                $component->state($orderedMedia->first()?->uuid);
            }
        });

        $this->dehydrated(false);

        $this->saveRelationshipsUsing(static function (MediaManagerPicker $component, ?Model $record) {
            if (! $record || ! $record->exists) {
                return;
            }

            $state = $component->getState();
            $collectionName = $component->getCollectionName();

            // Clear existing attachments for this collection
            $deleteQuery = \DB::table('media_has_models')
                ->where('model_type', get_class($record))
                ->where('model_id', $record->id);

            if ($collectionName !== null) {
                $deleteQuery->where('collection_name', $collectionName);
            } else {
                $deleteQuery->whereNull('collection_name');
            }

            $deleteQuery->delete();

            if (empty($state)) {
                return;
            }

            // Get media by UUIDs and maintain order
            $uuids = is_array($state) ? $state : [$state];
            $media = Media::whereIn('uuid', $uuids)->get()->keyBy('uuid');

            // Create new attachments with order, collection name, and responsive images flag
            $order = 0;
            $responsiveImages = $component->shouldGenerateResponsiveImages();

            foreach ($uuids as $uuid) {
                $mediaItem = $media->get($uuid);
                if ($mediaItem) {
                    // Generate responsive images if enabled
                    if ($responsiveImages && $mediaItem->hasResponsiveImages()) {
                        $mediaItem->registerMediaConversions();
                    }

                    \DB::table('media_has_models')->insert([
                        'model_type' => get_class($record),
                        'model_id' => $record->id,
                        'media_id' => $mediaItem->id,
                        'collection_name' => $collectionName,
                        'responsive_images' => $responsiveImages,
                        'order_column' => $order++,
                        'created_at' => now(),
                        'updated_at' => now(),
                    ]);
                }
            }
        });
    }

    public function getBrowseAction(): Action
    {
        return Action::make('getBrowseAction')
            ->label(trans('filament-media-manager::messages.picker.browse'))
            ->icon('heroicon-o-folder-open')
            ->modalContent(fn (MediaManagerPicker $component) => view('filament-media-manager::components.media-picker-modal', [
                'pickerKey' => $component->getId(),
                'isMultiple' => $component->isMultiple(),
                'collectionName' => $component->getCollectionName(),
                'maxItems' => $component->getMaxItems(),
                'minItems' => $component->getMinItems(),
                'currentState' => $component->getState(),
            ]))
            ->modalWidth('7xl')
            ->modalSubmitAction(false)
            ->modalCancelActionLabel(__('Close'))
            ->closeModalByClickingAway(false)
            ->extraModalFooterActions([
                // Ensure the cancel button only closes this modal, not parent modals
            ]);
    }

    public function getRemoveAction(): Action
    {
        return Action::make('getRemoveAction')
            ->label(trans('filament-media-manager::messages.picker.remove'))
            ->icon('heroicon-o-x-mark')
            ->color('danger')
            ->requiresConfirmation()
            ->action(function (MediaManagerPicker $component) {
                $component->state($component->isMultiple() ? [] : null);
            });
    }

    public function getRemoveMediaItemAction(): Action
    {
        return Action::make('removeMediaItem')
            ->label(trans('filament-media-manager::messages.picker.remove'))
            ->icon('heroicon-m-x-mark')
            ->color('danger')
            ->size('sm')
            ->requiresConfirmation()
            ->modalHeading(trans('filament-media-manager::messages.picker.confirm_remove'))
            ->modalDescription(trans('filament-media-manager::messages.picker.confirm_remove_message'))
            ->modalSubmitActionLabel(trans('filament-media-manager::messages.picker.remove'))
            ->action(function (MediaManagerPicker $component, array $arguments) {
                $uuid = $arguments['uuid'] ?? null;
                if (! $uuid) {
                    return;
                }

                $currentState = $component->getState();
                if ($component->isMultiple() && is_array($currentState)) {
                    $component->state(array_values(array_diff($currentState, [$uuid])));
                } elseif (! $component->isMultiple() && $currentState === $uuid) {
                    $component->state(null);
                }
            });
    }

    public function multiple(bool | Closure $condition = true): static
    {
        $this->isMultiple = $condition;

        return $this;
    }

    public function single(bool | Closure $condition = true): static
    {
        $this->isMultiple = ! $condition;

        return $this;
    }

    public function isMultiple(): bool
    {
        return $this->evaluate($this->isMultiple);
    }

    public function maxItems(int | Closure | null $count): static
    {
        $this->maxItems = $count;

        return $this;
    }

    public function getMaxItems(): ?int
    {
        return $this->evaluate($this->maxItems);
    }

    public function minItems(int | Closure | null $count): static
    {
        $this->minItems = $count;

        return $this;
    }

    public function getMinItems(): ?int
    {
        return $this->evaluate($this->minItems);
    }

    public function collection(string | Closure | null $name): static
    {
        $this->collectionName = $name;

        return $this;
    }

    public function getCollectionName(): ?string
    {
        return $this->evaluate($this->collectionName);
    }

    public function disk(string | Closure | null $name): static
    {
        $this->diskName = $name;

        return $this;
    }

    public function getDiskName(): ?string
    {
        return $this->evaluate($this->diskName);
    }

    public function responsiveImages(bool | Closure $condition = true): static
    {
        $this->generateResponsiveImages = $condition;

        return $this;
    }

    public function shouldGenerateResponsiveImages(): bool
    {
        return $this->evaluate($this->generateResponsiveImages);
    }
}
</file>

<file path="src/Livewire/MediaPicker.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Livewire;

use Filament\Actions\Action;
use Filament\Actions\Concerns\InteractsWithActions;
use Filament\Actions\Contracts\HasActions;
use Filament\Forms\Components\FileUpload;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Schemas\Concerns\InteractsWithSchemas;
use Filament\Schemas\Contracts\HasSchemas;
use Livewire\Attributes\On;
use Livewire\Component;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Models\Media;

class MediaPicker extends Component implements HasActions, HasSchemas
{
    use InteractsWithActions;
    use InteractsWithSchemas;

    public ?int $currentFolderId = null;

    public bool $isMultiple = true;

    public array $selectedMedia = [];

    public ?string $collectionName = null;

    public string $pickerKey = '';

    public string $search = '';

    public ?int $pendingFolderId = null;

    public ?int $maxItems = null;

    public ?int $minItems = null;

    public function mount(
        string $pickerKey,
        bool $isMultiple = true,
        ?string $collectionName = null,
        ?int $maxItems = null,
        ?int $minItems = null,
        $initialState = null
    ): void {
        $this->pickerKey = $pickerKey;
        $this->isMultiple = $isMultiple;
        $this->collectionName = $collectionName;
        $this->maxItems = $maxItems;
        $this->minItems = $minItems;

        // Initialize selectedMedia with current state
        if ($initialState) {
            if ($isMultiple && is_array($initialState)) {
                $this->selectedMedia = $initialState;
            } elseif (! $isMultiple && ! is_array($initialState)) {
                $this->selectedMedia = [$initialState];
            }
        }
    }

    public function openFolder(int $folderId): void
    {
        $folder = Folder::find($folderId);

        if (! $folder) {
            return;
        }

        // Check if folder is protected
        if ($folder->is_protected) {
            $this->pendingFolderId = $folderId;
            $this->mountAction('verifyPassword', ['folder' => $folder]);

            return;
        }

        // Don't reset selections when navigating
        $this->currentFolderId = $folderId;
    }

    public function verifyPassword(): Action
    {
        return Action::make('verifyPassword')
            ->modalHeading(fn (array $arguments) => __('Enter Password for') . ' ' . $arguments['folder']->name)
            ->modalIcon('heroicon-o-lock-closed')
            ->schema([
                TextInput::make('password')
                    ->label(__('Password'))
                    ->password()
                    ->revealable()
                    ->required()
                    ->maxLength(255)
                    ->autocomplete('new-password')
                    ->id('folder-password-' . uniqid()),
            ])
            ->action(function (array $arguments, array $data) {
                $folder = $arguments['folder'];

                if ($folder->password !== $data['password']) {
                    Notification::make()
                        ->title(__('Password is incorrect'))
                        ->danger()
                        ->send();

                    $this->pendingFolderId = null;

                    return;
                }

                // Password correct, open folder
                $this->currentFolderId = $this->pendingFolderId;
                $this->pendingFolderId = null;

                Notification::make()
                    ->title(__('Access granted'))
                    ->success()
                    ->send();
            })
            ->modalSubmitActionLabel(__('Confirm'));
    }

    public function uploadMedia(): Action
    {
        return Action::make('uploadMedia')
            ->label(__('Upload Media'))
            ->icon('heroicon-o-arrow-up-tray')
            ->color('primary')
            ->visible(fn () => $this->currentFolderId !== null)
            ->schema([
                FileUpload::make('files')
                    ->label(__('Files'))
                    ->multiple()
                    ->required()
                    ->maxSize(10240)
                    ->storeFiles(false),
            ])
            ->action(function (array $data) {
                $folder = Folder::find($this->currentFolderId);

                if (! $folder) {
                    return;
                }

                $uploadedMedia = [];

                foreach ($data['files'] as $file) {
                    // Determine which model to attach media to
                    if ($folder->model_type && $folder->model_id) {
                        // Attach to folder's specific model instance
                        $model = app($folder->model_type)->find($folder->model_id);
                    } elseif ($folder->model) {
                        // Use folder's model if available
                        $model = $folder->model;
                    } else {
                        // Attach to folder itself for collection folders
                        $model = $folder;
                    }

                    if (! $model) {
                        continue;
                    }

                    // Pass file directly like CreateMediaAction does
                    $media = $model
                        ->addMedia($file)
                        ->toMediaCollection($folder->collection ?? 'default');

                    $uploadedMedia[] = $media->uuid;
                }

                Notification::make()
                    ->title(__('Media uploaded successfully'))
                    ->success()
                    ->send();

                // Auto-select uploaded media
                if ($this->isMultiple) {
                    foreach ($uploadedMedia as $uuid) {
                        if ($this->maxItems && count($this->selectedMedia) >= $this->maxItems) {
                            break;
                        }
                        if (! in_array($uuid, $this->selectedMedia)) {
                            $this->selectedMedia[] = $uuid;
                        }
                    }
                } else {
                    $this->selectedMedia = [$uploadedMedia[0] ?? null];
                    if ($uploadedMedia) {
                        $this->selectMedia();
                    }
                }
            });
    }

    public function goBack(): void
    {
        if ($this->currentFolderId) {
            $currentFolder = Folder::find($this->currentFolderId);

            if ($currentFolder) {
                // If in an instance folder, go back to collection folder
                if ($currentFolder->model_type && $currentFolder->model_id && $currentFolder->collection) {
                    // Find the collection folder
                    $collectionFolder = Folder::where('model_type', $currentFolder->model_type)
                        ->whereNull('model_id')
                        ->where('collection', $currentFolder->collection)
                        ->first();
                    $this->currentFolderId = $collectionFolder?->id;
                }
                // If in a collection folder, go back to model type folder
                elseif ($currentFolder->model_type && ! $currentFolder->model_id && $currentFolder->collection) {
                    // Find the model type folder
                    $modelTypeFolder = Folder::where('model_type', $currentFolder->model_type)
                        ->whereNull('model_id')
                        ->whereNull('collection')
                        ->first();
                    $this->currentFolderId = $modelTypeFolder?->id;
                }
                // Otherwise use model_id or go to root
                else {
                    $this->currentFolderId = $currentFolder->model_id;
                }
            } else {
                $this->currentFolderId = null;
            }
        }
        // Keep selections when going back
    }

    public function toggleMediaSelection(string $mediaUuid): void
    {
        if ($this->isMultiple) {
            if (in_array($mediaUuid, $this->selectedMedia)) {
                $this->selectedMedia = array_values(array_diff($this->selectedMedia, [$mediaUuid]));
            } else {
                // Check max items limit
                if ($this->maxItems && count($this->selectedMedia) >= $this->maxItems) {
                    Notification::make()
                        ->title(__('Maximum :count items allowed', ['count' => $this->maxItems]))
                        ->warning()
                        ->send();

                    return;
                }
                $this->selectedMedia[] = $mediaUuid;
            }
        } else {
            $this->selectedMedia = [$mediaUuid];
            // Auto-select and close for single selection
            $this->selectMedia();
        }
    }

    public function removeSelection(string $mediaUuid): void
    {
        $this->selectedMedia = array_values(array_diff($this->selectedMedia, [$mediaUuid]));
    }

    public function selectMedia(): void
    {
        if (empty($this->selectedMedia)) {
            Notification::make()
                ->title(__('No media selected'))
                ->warning()
                ->send();

            return;
        }

        // Check minimum items
        if ($this->minItems && count($this->selectedMedia) < $this->minItems) {
            Notification::make()
                ->title(__('Minimum :count items required', ['count' => $this->minItems]))
                ->warning()
                ->send();

            return;
        }

        $count = count($this->selectedMedia);
        $selectedData = $this->isMultiple ? $this->selectedMedia : $this->selectedMedia[0];

        // Show success notification
        Notification::make()
            ->title(__('Successfully selected :count item(s)', ['count' => $count]))
            ->success()
            ->send();

        // Dispatch window event with consistent structure wrapped in 'media' property
        $this->js(
            "window.dispatchEvent(new CustomEvent('media-selected-{$this->pickerKey}', {
                detail: { media: " . json_encode($selectedData) . ' }
            }));'
        );

        // Reset state but don't close the modal - user can click "Close" button
        $this->selectedMedia = [];
        $this->currentFolderId = null;
        $this->search = '';
    }

    public function getFoldersProperty()
    {
        // Remove user access global scope to show all folders
        $query = Folder::withoutGlobalScope('user');

        if ($this->currentFolderId) {
            $currentFolder = Folder::find($this->currentFolderId);

            if ($currentFolder) {
                // If current folder has model_type but no collection, show collection folders
                if ($currentFolder->model_type && ! $currentFolder->collection) {
                    $query->where('model_type', $currentFolder->model_type)
                        ->whereNull('model_id')
                        ->whereNotNull('collection');
                }
                // If current folder has model_type and collection, show instance folders
                elseif ($currentFolder->model_type && $currentFolder->collection && ! $currentFolder->model_id) {
                    $query->where('model_type', $currentFolder->model_type)
                        ->whereNotNull('model_id')
                        ->where('collection', $currentFolder->collection);
                }
                // Otherwise show subfolders using model_id
                else {
                    $query->where('model_id', $this->currentFolderId);
                }
            }
        } else {
            // Root level: match FolderResource query logic exactly
            // Wrap in closure to properly group with other conditions
            $query->where(function ($q) {
                $q->where('model_id', null)
                    ->where('collection', null)
                    ->orWhere('model_type', null);
            });
        }

        if ($this->collectionName) {
            $query->where('collection', $this->collectionName);
        }

        // Apply search filter
        if (filled($this->search)) {
            $query->where('name', 'like', '%' . $this->search . '%');
        }

        return $query->get();
    }

    public function getMediaProperty()
    {
        // No media at root level or model type level
        if (! $this->currentFolderId) {
            if (filled($this->search) && $this->collectionName) {
                $query = Media::withoutGlobalScope('folder')
                    ->where('collection_name', $this->collectionName)
                    ->where(function ($q) {
                        $q->where('file_name', 'like', '%' . $this->search . '%')
                            ->orWhere('name', 'like', '%' . $this->search . '%');
                    });

                return $query->get();
            }

            return collect();
        }

        $folder = Folder::find($this->currentFolderId);

        if (! $folder) {
            return collect();
        }

        // Remove the global scope temporarily to get media
        $query = Media::withoutGlobalScope('folder');

        // Filter media based on folder structure (same logic as Media model's global scope)
        if ($folder->collection) {
            if ($folder->model_type && $folder->model_id) {
                // Instance folder - show only media belonging to this specific model instance
                $query->where('model_type', $folder->model_type)
                    ->where('model_id', $folder->model_id)
                    ->where('collection_name', $folder->collection);
            } elseif ($folder->model_type && ! $folder->model_id) {
                // Collection folder - show media without model_id (not belonging to specific instances)
                $query->where('collection_name', $folder->collection)
                    ->whereNull('model_id');
            } else {
                // Regular folder - show all media in collection
                $query->where('collection_name', $folder->collection);
            }
        } else {
            // If no collection, don't show any media
            return collect();
        }

        // Apply search filter
        if (filled($this->search)) {
            $query->where(function ($q) {
                $q->where('file_name', 'like', '%' . $this->search . '%')
                    ->orWhere('name', 'like', '%' . $this->search . '%');
            });
        }

        return $query->get();
    }

    public function getCurrentFolderProperty(): ?Folder
    {
        return $this->currentFolderId ? Folder::find($this->currentFolderId) : null;
    }

    public function render()
    {
        return view('filament-media-manager::livewire.media-picker', [
            'folders' => $this->folders,
            'media' => $this->media,
            'currentFolder' => $this->currentFolder,
        ]);
    }
}
</file>

<file path="src/Resources/Actions/CreateMediaAction.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\Actions;

use Filament\Actions;
use Filament\Forms;
use Filament\Notifications\Notification;
use TomatoPHP\FilamentMediaManager\Models\Folder;

class CreateMediaAction
{
    public static function make(int $folder_id): Actions\Action
    {
        return Actions\Action::make('create_media')
            ->mountUsing(function () use ($folder_id) {
                session()->put('folder_id', $folder_id);
            })
            ->label(trans('filament-media-manager::messages.media.actions.create.label'))
            ->icon('heroicon-o-plus')
            ->form([
                Forms\Components\FileUpload::make('file')
                    ->label(trans('filament-media-manager::messages.media.actions.create.form.file'))
                    ->maxSize('100000')
                    ->columnSpanFull()
                    ->required()
                    ->storeFiles(false),
                Forms\Components\TextInput::make('title')
                    ->label(trans('filament-media-manager::messages.media.actions.create.form.title'))
                    ->columnSpanFull(),
                Forms\Components\Textarea::make('description')
                    ->label(trans('filament-media-manager::messages.media.actions.create.form.description'))
                    ->columnSpanFull(),
            ])
            ->action(function (array $data) use ($folder_id) {
                $folder = Folder::find($folder_id);
                if ($folder) {
                    if ($folder->model) {
                        $folder->model->addMedia($data['file'])
                            ->withCustomProperties([
                                'title' => $data['title'],
                                'description' => $data['description'],
                            ])
                            ->toMediaCollection($folder->collection);
                    } else {
                        $folder->addMedia($data['file'])
                            ->withCustomProperties([
                                'title' => $data['title'],
                                'description' => $data['description'],
                            ])
                            ->toMediaCollection($folder->collection);
                    }

                }

                Notification::make()->title(trans('filament-media-manager::messages.media.notifications.create-media'))->send();
            });
    }
}
</file>

<file path="src/Resources/Actions/DeleteFolderAction.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\Actions;

use Filament\Actions;
use Filament\Notifications\Notification;

class DeleteFolderAction
{
    public static function make(int $folder_id): Actions\Action
    {
        return Actions\Action::make('delete_folder')
            ->mountUsing(function () use ($folder_id) {
                session()->put('folder_id', $folder_id);
            })
            ->hiddenLabel()
            ->requiresConfirmation()
            ->tooltip(trans('filament-media-manager::messages.media.actions.delete.label'))
            ->label(trans('filament-media-manager::messages.media.actions.delete.label'))
            ->icon('heroicon-o-trash')
            ->color('danger')
            ->action(function () use ($folder_id) {
                $folder = config('filament-media-manager.model.folder')::find($folder_id);
                $folder->delete();
                session()->forget('folder_id');

                Notification::make()->title(trans('filament-media-manager::messages.media.notifications.delete-folder'))->send();

                return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.folders.index');
            });
    }
}
</file>

<file path="src/Services/Contracts/MediaManagerType.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Services\Contracts;

class MediaManagerType
{
    public ?string $exstantion = null;

    public ?string $icon = null;

    public ?string $preview = null;

    public ?array $js = null;

    public ?array $css = null;

    public static function make(?string $exstantion = null): static
    {
        return (new static)->exstantion($exstantion);
    }

    public function exstantion(?string $exstantion = null): static
    {
        $this->exstantion = $exstantion;

        return $this;
    }

    public function icon(?string $icon = null): static
    {
        $this->icon = $icon;

        return $this;
    }

    public function preview(?string $preview = null): static
    {
        $this->preview = $preview;

        return $this;
    }

    public function js(string | array | null $js = null): static
    {
        if (is_array($js)) {
            $this->js = $js;
        } else {
            $this->js[] = $js;
        }

        return $this;
    }

    public function css(string | array | null $css = null): static
    {
        if (is_array($css)) {
            $this->css = $css;
        } else {
            $this->css[] = $css;
        }

        return $this;
    }
}
</file>

<file path="src/Services/FilamentMediaManagerServices.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Services;

use Filament\Support\Assets\Css;
use Filament\Support\Assets\Js;
use Filament\Support\Facades\FilamentAsset;
use TomatoPHP\FilamentMediaManager\Services\Contracts\MediaManagerType;

class FilamentMediaManagerServices
{
    protected array $types = [];

    public function register(MediaManagerType | array $type)
    {
        if (is_array($type)) {
            foreach ($type as $t) {
                $this->register($t);
            }
        } else {
            if ($type->js) {
                foreach ($type->js as $key => $jsItem) {
                    FilamentAsset::register([
                        Js::make($type->exstantion . '_js_' . $key, $jsItem),
                    ]);
                }
            }
            if ($type->css) {
                foreach ($type->css as $key => $cssItem) {
                    FilamentAsset::register([
                        Css::make($type->exstantion . '_css_' . $key, $cssItem),
                    ]);
                }
            }

            $this->types[] = $type;
        }
    }

    public function getTypes()
    {
        return $this->types;
    }
}
</file>

<file path=".github/workflows/fix-php-code-styling.yml">
name: 'PHP Code Styling'

on:
  workflow_dispatch:
  push:
    branches:
      - master
    paths:
      - '**.php'

permissions:
  contents: write

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v5
        with:
          ref: ${{ github.head_ref }}

      - name: Fix PHP code style issues
        uses: aglipanci/laravel-pint-action@v2

      - name: Commit changes
        uses: stefanzweifel/git-auto-commit-action@v7
        with:
          commit_message: "Format Code"
          commit_user_name: 'GitHub Actions'
</file>

<file path="src/Console/FilamentMediaManagerInstall.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Console;

use Illuminate\Console\Command;
use TomatoPHP\ConsoleHelpers\Traits\RunCommand;

class FilamentMediaManagerInstall extends Command
{
    use RunCommand;

    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $name = 'filament-media-manager:install';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'install package and publish assets';

    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $this->info('Publish Vendor Assets');

        \Artisan::call('migrate');

        \Artisan::call('optimize:clear');

        $this->info('Filament Media Manager installed successfully.');
    }
}
</file>

<file path="src/Resources/MediaResource.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources;

use BackedEnum;
use Filament\Actions;
use Filament\Forms;
use Filament\Resources\Resource;
use Filament\Schemas\Schema;
use Filament\Tables;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Models\Media;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource\Pages;

class MediaResource extends Resource
{
    protected static bool $isScopedToTenant = false;

    protected static BackedEnum | string | null $navigationIcon = 'heroicon-o-rectangle-stack';

    protected static bool $shouldRegisterNavigation = false;

    public static function getModel(): string
    {
        return config('filament-media-manager.model.media'); // TODO: Change the autogenerated stub
    }

    public static function getPluralLabel(): ?string
    {
        return trans('filament-media-manager::messages.media.title');
    }

    public static function getLabel(): ?string
    {
        return trans('filament-media-manager::messages.media.single'); // TODO: Change the autogenerated stub
    }

    public static function setBreadcrumb(?string $breadcrumb): void
    {
        self::$breadcrumb = $breadcrumb;
    }

    public static function form(Schema $form): Schema
    {
        return $form;
    }

    public static function table(Table $table): Table
    {
        return $table
            ->modifyQueryUsing(function (Builder $query) {
                if (request()->has('folder_id') && ! empty('folder_id')) {
                    $folder = Folder::find(request()->get('folder_id'));
                    if ($folder) {
                        $query->where('collection_name', $folder->collection);
                    }
                }
            })
            ->emptyState(fn () => view('filament-media-manager::pages.media'))
            ->content(function () {
                return view('filament-media-manager::pages.media');
            })
            ->columns([
                Tables\Columns\Layout\Stack::make([
                    Tables\Columns\ViewColumn::make('preview')
                        ->label(trans('filament-media-manager::messages.media.columns.image'))
                        ->view('filament-media-manager::columns.media-preview'),
                ]),
                Tables\Columns\Layout\Stack::make([
                    Tables\Columns\TextColumn::make('model.name')
                        ->label(trans('filament-media-manager::messages.media.columns.model'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('collection_name')
                        ->label(trans('filament-media-manager::messages.media.columns.collection_name'))
                        ->badge()
                        ->icon('heroicon-o-folder')
                        ->searchable(),
                ]),
                Tables\Columns\Layout\Stack::make([
                    Tables\Columns\TextColumn::make('name')
                        ->label(trans('filament-media-manager::messages.media.columns.name'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('file_name')
                        ->label(trans('filament-media-manager::messages.media.columns.file_name'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('mime_type')
                        ->label(trans('filament-media-manager::messages.media.columns.mime_type'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('disk')
                        ->label(trans('filament-media-manager::messages.media.columns.disk'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('conversions_disk')
                        ->label(trans('filament-media-manager::messages.media.columns.conversions_disk'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('size')
                        ->label(trans('filament-media-manager::messages.media.columns.size'))
                        ->numeric()
                        ->sortable(),
                    Tables\Columns\TextColumn::make('order_column')
                        ->label(trans('filament-media-manager::messages.media.columns.order_column'))
                        ->numeric()
                        ->sortable(),
                    Tables\Columns\TextColumn::make('created_at')
                        ->dateTime()
                        ->sortable(),
                    Tables\Columns\TextColumn::make('updated_at')
                        ->dateTime()
                        ->sortable(),
                ]),
            ])
            ->contentGrid([
                'md' => 2,
                'xl' => 3,
            ])
            ->defaultSort('order_column', 'asc')
            ->recordActions([
                Actions\EditAction::make(),
            ])
            ->filters([
                Tables\Filters\SelectFilter::make('mime_type')
                    ->label(trans('filament-media-manager::messages.media.columns.mime_type'))
                    ->options([
                        'image' => 'Images',
                        'video' => 'Videos',
                        'audio' => 'Audio',
                        'application/pdf' => 'PDF',
                        'application/zip' => 'Archives',
                        'text' => 'Text Files',
                    ])
                    ->query(function (Builder $query, array $data): Builder {
                        if (! empty($data['value'])) {
                            return $query->where('mime_type', 'like', '%' . $data['value'] . '%');
                        }

                        return $query;
                    }),
                Tables\Filters\SelectFilter::make('collection_name')
                    ->label(trans('filament-media-manager::messages.media.columns.collection_name'))
                    ->options(function () {
                        return Media::query()
                            ->whereNotNull('collection_name')
                            ->distinct()
                            ->pluck('collection_name', 'collection_name')
                            ->toArray();
                    })
                    ->searchable()
                    ->preload(),
                Tables\Filters\SelectFilter::make('disk')
                    ->label(trans('filament-media-manager::messages.media.columns.disk'))
                    ->options(function () {
                        return Media::query()
                            ->whereNotNull('disk')
                            ->distinct()
                            ->pluck('disk', 'disk')
                            ->toArray();
                    }),
                Tables\Filters\Filter::make('size')
                    ->form([
                        Forms\Components\TextInput::make('size_from')
                            ->label(trans('filament-media-manager::messages.media.filters.size_from'))
                            ->numeric(),
                        Forms\Components\TextInput::make('size_to')
                            ->label(trans('filament-media-manager::messages.media.filters.size_to'))
                            ->numeric(),
                    ])
                    ->query(function (Builder $query, array $data): Builder {
                        return $query
                            ->when(
                                $data['size_from'],
                                fn (Builder $query, $size): Builder => $query->where('size', '>=', $size * 1024),
                            )
                            ->when(
                                $data['size_to'],
                                fn (Builder $query, $size): Builder => $query->where('size', '<=', $size * 1024),
                            );
                    }),
                Tables\Filters\Filter::make('created_at')
                    ->form([
                        Forms\Components\DatePicker::make('created_from')
                            ->label(trans('filament-media-manager::messages.media.filters.created_from')),
                        Forms\Components\DatePicker::make('created_until')
                            ->label(trans('filament-media-manager::messages.media.filters.created_until')),
                    ])
                    ->query(function (Builder $query, array $data): Builder {
                        return $query
                            ->when(
                                $data['created_from'],
                                fn (Builder $query, $date): Builder => $query->whereDate('created_at', '>=', $date),
                            )
                            ->when(
                                $data['created_until'],
                                fn (Builder $query, $date): Builder => $query->whereDate('created_at', '<=', $date),
                            );
                    }),
            ])
            ->defaultPaginationPageOption(12)
            ->paginationPageOptions([
                '12',
                '24',
                '48',
                '96',
            ])
            ->toolbarActions([
                Actions\BulkActionGroup::make([
                    Actions\DeleteBulkAction::make(),
                ]),
            ]);
    }

    public static function getRelations(): array
    {
        return [
            //
        ];
    }

    public static function getPages(): array
    {
        return [
            'index' => Pages\ListMedia::route('/'),
        ];
    }
}
</file>

<file path="src/FilamentMediaManagerServiceProvider.php">
<?php

namespace TomatoPHP\FilamentMediaManager;

use Illuminate\Support\ServiceProvider;
use Livewire\Livewire;
use TomatoPHP\FilamentMediaManager\Services\FilamentMediaManagerServices;

class FilamentMediaManagerServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Register generate command
        $this->commands([
            \TomatoPHP\FilamentMediaManager\Console\FilamentMediaManagerInstall::class,
        ]);

        // Register Config file
        $this->mergeConfigFrom(__DIR__ . '/../config/filament-media-manager.php', 'filament-media-manager');

        // Publish Config
        $this->publishes([
            __DIR__ . '/../config/filament-media-manager.php' => config_path('filament-media-manager.php'),
        ], 'filament-media-manager-config');

        // Register Migrations
        $this->loadMigrationsFrom(__DIR__ . '/../database/migrations');

        // Publish Migrations
        $this->publishes([
            __DIR__ . '/../database/migrations' => database_path('migrations'),
        ], 'filament-media-manager-migrations');
        // Register views
        $this->loadViewsFrom(__DIR__ . '/../resources/views', 'filament-media-manager');

        // Publish Views
        $this->publishes([
            __DIR__ . '/../resources/views' => resource_path('views/vendor/filament-media-manager'),
        ], 'filament-media-manager-views');

        // Register Langs
        $this->loadTranslationsFrom(__DIR__ . '/../resources/lang', 'filament-media-manager');

        // Publish Lang
        $this->publishes([
            __DIR__ . '/../resources/lang' => base_path('lang/vendor/filament-media-manager'),
        ], 'filament-media-manager-lang');

        if (config('filament-media-manager.api.active')) {
            // Register Routes
            $this->loadRoutesFrom(__DIR__ . '/../routes/api.php');
        }

        $this->app->bind('filament-media-manager', function () {
            return new FilamentMediaManagerServices;
        });

        Livewire::component('folder-component', \TomatoPHP\FilamentMediaManager\Livewire\FolderComponent::class);
        Livewire::component('media-picker', \TomatoPHP\FilamentMediaManager\Livewire\MediaPicker::class);
    }

    public function boot(): void
    {
        // you boot methods here
    }
}
</file>

<file path="CHANGELOG.md">
# Changelog

All notable changes to `filament-media-manager` will be documented in this file.

## v4.0.3 - 2025-10-20

### 🎯 New Features

#### Collection Names Support
- **Multi-Picker Support** - Added collection name support for multiple pickers on the same page
  - New `collection_name` column in `media_has_models` pivot table
  - Use `->collection('name')` method to specify collection for each picker
  - Each picker maintains its own separate media attachments
  - Collection filtering in all trait methods
  - Backward compatible (null collection name supported)

- **Migration**: `2024_10_21_000000_add_collection_name_to_media_has_models_table.php`
  - Added `collection_name` (nullable string) column
  - Added `responsive_images` (boolean, default false) column
  - Supports rollback with proper column cleanup

- **Updated Methods with Collection Support**:
  ```php
  // Define separate collections for different pickers
  Forms\Components\MediaManagerPicker::make('featured_image')
      ->collection('featured')
      ->single();

  Forms\Components\MediaManagerPicker::make('gallery_images')
      ->collection('gallery')
      ->multiple();

  // Retrieve media by collection
  $product->getMediaManagerMedia('featured');
  $product->getMediaManagerMedia('gallery');
  $product->getMediaManagerUrl('featured');
  $product->getMediaManagerUrls('gallery');
  ```

#### Responsive Images Support
- **Spatie Media Library Integration** - Added responsive images support using Spatie's built-in functionality
  - New `->responsiveImages()` method on MediaManagerPicker
  - Automatic responsive image generation when enabled
  - Responsive images flag stored in pivot table
  - Multiple methods to retrieve responsive image URLs and srcset

- **New Trait Methods for Responsive Images**:
  - `getMediaManagerResponsiveImages(?string $collectionName = null)` - Get media with responsive image data
  - `getMediaManagerSrcset(?string $collectionName = null)` - Get srcset attribute for first media
  - `getMediaManagerSrcsets(?string $collectionName = null)` - Get all srcset attributes
  - `getMediaManagerResponsiveUrls(?string $collectionName = null)` - Get responsive URLs for first media
  - `getAllMediaManagerResponsiveUrls(?string $collectionName = null)` - Get all responsive URLs

- **Usage Example**:
  ```php
  // Enable responsive images
  Forms\Components\MediaManagerPicker::make('hero_image')
      ->collection('hero')
      ->single()
      ->responsiveImages();

  // In Blade templates
  <img src="{{ $model->getMediaManagerUrl('hero') }}"
       srcset="{{ $model->getMediaManagerSrcset('hero') }}"
       alt="Hero Image">

  // Get detailed responsive data
  $responsiveImages = $model->getMediaManagerResponsiveImages('gallery');
  // Returns: ['media' => $media, 'url' => $url, 'responsive_urls' => [...], 'srcset' => '...']
  ```

#### Media Ordering & Reordering
- **Drag & Drop Reordering** - Added drag and drop functionality to reorder media items in MediaManagerPicker
  - Visual drag handle (three bars icon) appears when multiple items are selected
  - Smooth animation during drag (150ms)
  - Ghost effect while dragging (40% opacity)
  - Cursor changes to "grab" on hover over drag handle
  - Only displays for multiple selection mode with 2+ items
  - Proper cleanup and reinitialization of Sortable instances

- **Order Column Support** - Added `order_column` to `media_has_models` pivot table
  - New migration: `2024_10_20_000000_add_order_column_to_media_has_models_table.php`
  - Unsigned integer column with index for performance
  - Nullable to support backward compatibility
  - Automatically managed during attach/sync operations

- **Order Persistence**
  - Media items maintain their order across save/load operations
  - Order preserved when using `attachMediaManagerMedia()`
  - Order preserved when using `syncMediaManagerMedia()`
  - Order reflected in all `getMediaManagerMedia()` calls
  - Order properly hydrated when editing existing records

### 🔧 Bug Fixes

#### MediaManagerPicker Selection Issues
- **Fixed: Media selection not being set to form** - Resolved inconsistent event detail structure
  - Changed from direct data to wrapped structure: `{ media: ... }`
  - Ensures reliable state updates across all scenarios
  - Handles both single and multiple selection modes
  - Fixed race conditions with `isProcessing` flag

- **Fixed: Reordering persistence** - Completely rewrote view logic for reliable drag & drop
  - Server-side ordering now respects state array order
  - Alpine.js state properly synced with Livewire
  - Added `wire:key` for proper Livewire DOM tracking
  - State watcher reinitializes Sortable after re-renders
  - Prevents order from reverting after drag operations

#### InteractsWithMediaManager Trait Updates
- **Collection Name Parameter** - Changed `getMediaManagerUrl()` and `getMediaManagerUrls()` methods
  - Previously: Accepted `$conversion` parameter for image transformations
  - Now: Accepts `$collectionName` parameter to filter by media collection
  - More useful for retrieving specific media groups (e.g., 'gallery', 'thumbnails', 'documents')
  - Breaking change from previous implementation

- **Updated Methods with Ordering**:
  ```php
  // Now returns media in order
  $product->getMediaManagerMedia('gallery');
  $product->getMediaManagerUrl('thumbnails'); // Get first from thumbnails collection
  $product->getMediaManagerUrls('documents'); // Get all URLs from documents collection

  // Order is preserved when syncing
  $product->syncMediaManagerMedia(['uuid-3', 'uuid-1', 'uuid-2']);
  ```

### 📝 Technical Changes

#### Migration Changes
- `media_has_models` table:
  - Added `order_column` (unsigned integer, nullable, indexed)
  - Supports rollback with proper index cleanup

#### View Refactoring
- `resources/views/forms/media-manager-picker.blade.php`
  - Complete rewrite with cleaner Alpine.js logic
  - Removed complex nested x-data scopes
  - Server-side rendering with proper ordering
  - Simplified Sortable.js initialization
  - Added proper instance cleanup on destroy
  - Uses `wire:key` for DOM tracking
  - State watcher for automatic Sortable reinitialization

#### Backend Updates
- `src/Form/MediaManagerPicker.php`
  - Added `$collectionName` property and `collection()` method
  - Added `$generateResponsiveImages` property and `responsiveImages()` method
  - Added `shouldGenerateResponsiveImages()` getter method
  - `afterStateHydrated()`: Now loads and sorts media by `order_column` and filters by `collection_name`
  - `saveRelationshipsUsing()`: Saves media with sequential order values, collection name, and responsive images flag
  - Generates responsive images when flag is enabled

- `src/Traits/InteractsWithMediaManager.php`
  - **Collection Name Support**: All methods updated to accept optional `$collectionName` parameter
  - `getMediaManagerMedia(?string $collectionName)`: Filters by collection name and returns sorted by order
  - `attachMediaManagerMedia(array $uuids, ?string $collectionName)`: Supports collection-specific attachments
  - `detachMediaManagerMedia(?array $uuids, ?string $collectionName)`: Supports collection-specific detachment
  - `syncMediaManagerMedia(array $uuids, ?string $collectionName)`: Collection-aware sync operation
  - `hasMediaManagerMedia(string $uuid, ?string $collectionName)`: Collection-aware existence check
  - `getFirstMediaManagerMedia(?string $collectionName)`: Returns first from specific collection
  - `getMediaManagerUrl(?string $collectionName)`: Gets URL from specific collection
  - `getMediaManagerUrls(?string $collectionName)`: Gets all URLs from specific collection
  - **New Responsive Images Methods**:
    - `getMediaManagerResponsiveImages(?string $collectionName)`: Get media with responsive data
    - `getMediaManagerSrcset(?string $collectionName)`: Get srcset for first media
    - `getMediaManagerSrcsets(?string $collectionName)`: Get all srcsets
    - `getMediaManagerResponsiveUrls(?string $collectionName)`: Get responsive URLs for first media
    - `getAllMediaManagerResponsiveUrls(?string $collectionName)`: Get all responsive URLs

- `src/Livewire/MediaPicker.php`
  - `selectMedia()`: Fixed event detail structure with consistent wrapping

### 🧪 Testing

- ✅ All 97 existing tests passing
- ✅ Order persistence tested across all trait methods
- ✅ Drag and drop functionality verified
- ✅ State synchronization tested
- ✅ Collection filtering tested
- ✅ Backward compatibility maintained

### ⚠️ Breaking Changes

- **InteractsWithMediaManager Trait**:
  - `getMediaManagerUrl(?string $collectionName = null)` - Parameter changed from `$conversion` to `$collectionName`
  - `getMediaManagerUrls(?string $collectionName = null)` - Parameter changed from `$conversion` to `$collectionName`
  - If you were using these methods with conversion parameters, you'll need to update your code
  - Image conversions should now be handled separately using Spatie Media Library's conversion methods

### 📋 Migration Guide

If upgrading from v4.0.0 or v4.0.2:

1. **Run the new migrations**:
   ```bash
   php artisan migrate
   ```
   This will add:
   - `order_column` (if upgrading from v4.0.0)
   - `collection_name` column
   - `responsive_images` column

2. **Update trait method calls** if using conversions:
   ```php
   // Old (v4.0.0)
   $product->getMediaManagerUrl('thumb'); // Got thumbnail conversion

   // New (v4.0.3)
   $product->getMediaManagerUrl('gallery'); // Gets first from 'gallery' collection

   // For conversions, use Spatie directly:
   $media = $product->getFirstMediaManagerMedia('gallery');
   $thumbnailUrl = $media?->getUrl('thumb');
   ```

3. **Using multiple pickers on the same page**:
   ```php
   // Now you can use collection names to separate pickers
   Forms\Components\MediaManagerPicker::make('featured_image')
       ->collection('featured')
       ->single();

   Forms\Components\MediaManagerPicker::make('gallery_images')
       ->collection('gallery')
       ->multiple();

   // Each will maintain separate media attachments
   ```

4. **Using responsive images**:
   ```php
   // Enable responsive images
   Forms\Components\MediaManagerPicker::make('hero_image')
       ->collection('hero')
       ->responsiveImages();

   // Retrieve responsive images
   $srcset = $model->getMediaManagerSrcset('hero');
   ```

5. **Backward Compatibility**:
   - Existing media without `order_column` values will still work (nullable column). Order will be applied on next save.
   - Existing media without `collection_name` will work as before (defaults to null)
   - Responsive images are opt-in via `->responsiveImages()` method

---

## v4.0.0 - 2025-10-07

### <ďż˝ Major Release - Filament v4 Support

This major version brings full compatibility with Filament v4 along with significant improvements to the MediaManagerPicker component and new model integration features.

### ( New Features

#### MediaManagerPicker Component
- **Enhanced UI/UX**
  - Completely redesigned modal layout with folder navigation on the left and media grid on the right
  - Live preview section showing selected items with thumbnails, file info, and individual remove buttons
  - Success notifications with selection count
  - Auto-close modal after selection with proper state management
  - Full dark mode support using Filament v4 color system

- **Selection Management**
  - Support for single and multiple selection modes via `->single()` and `->multiple()`
  - Added `->maxItems(n)` to limit maximum selections
  - Added `->minItems(n)` to enforce minimum selections
  - Real-time validation with user-friendly warning notifications
  - Selection state preserved when navigating between folders

- **File Upload in Modal**
  - Upload files directly from the MediaManagerPicker modal
  - Auto-select uploaded files after successful upload
  - Respects max items limit during auto-selection
  - Fixed file upload error handling

- **Password Protected Folders**
  - Secure folder access with password verification
  - Password input with reveal toggle
  - Prevented browser autocomplete on password fields
  - Fixed folder opening after correct password entry

- **Search & Navigation**
  - Search across folders and media files
  - Fixed browser autocomplete on search fields
  - Breadcrumb navigation with back button
  - Support for folder hierarchy (model type ďż˝ collection ďż˝ instance)

#### InteractsWithMediaManager Trait
- **New Model Trait** for easy media management in Eloquent models
- **11 Helper Methods** including:
  - `getMediaManagerMedia()` - Get all attached media
  - `getMediaManagerMediaByUuids()` - Get specific media by UUIDs
  - `getMediaManagerInputMedia()` - Get Spatie collection media
  - `attachMediaManagerMedia()` - Attach media programmatically
  - `detachMediaManagerMedia()` - Detach media
  - `syncMediaManagerMedia()` - Sync media (replace all)
  - `hasMediaManagerMedia()` - Check if media exists
  - `getFirstMediaManagerMedia()` - Get first media item
  - `getMediaManagerUrl()` - Get media URL with conversions
  - `getMediaManagerUrls()` - Get all media URLs
- **Complete Documentation** in `docs/TRAITS.md`

#### MediaManagerPicker Form Component
- **Empty State Styling** - Filament v4 styled empty state with proper icons and messaging
- **Section Border** - Added styled container around empty state matching Filament's design system
- **Preview List** - Media items displayed as list with thumbnails, file info, and remove buttons
- **Individual Item Removal** - Remove items with confirmation modal

### = Bug Fixes

#### File Upload
- Fixed "FileDoesNotExist" error by using `->storeFiles(false)` and passing files directly to Spatie Media Library
- Proper file handling for TemporaryUploadedFile instances
- Fixed file path issues on upload

#### Selection & State Management
- Fixed media selection only working in secure folders
- Fixed modal not closing after selection
- Fixed selected media not attaching to form
- Fixed nested array error in `whereIn` query by adding `flatten()` filter
- Fixed duplicate event processing with `isProcessing` flag
- Fixed modal remounting instead of closing

#### Event System
- Switched from Livewire events to window CustomEvents for better reliability
- Fixed event propagation across folder navigation
- Handled both event data formats (`{media: array}` and direct array)
- Fixed "Could not find Livewire component in DOM tree" error

#### Folder Navigation
- Fixed files from sub-folders appearing in parent folders
- Implemented proper hierarchical filtering based on folder structure
- Fixed media query to respect folder organization

#### UI/UX Fixes
- Fixed password input autocomplete interference with search field
- Fixed browser email autocomplete on password fields
- Fixed search field autocomplete
- Added unique IDs to form fields to prevent autocomplete conflicts
- Fixed dark mode styling for all components
- Added padding around preview items for better spacing

#### Modal Management
- Fixed modal close by clearing `mountedActions` array properly
- Fixed redirect issue when trying to close modal with button clicks
- Removed ESC key fallback that caused issues
- Proper modal lifecycle management

### = Changes

#### Breaking Changes
- **Filament v4 Required** - This version is compatible with Filament v4 only
- **Updated CSS Classes** - Changed to Filament v4 class structure (e.g., `fi-ta-empty-state`)
- **Dark Mode Pattern** - Updated to use `.classname:where(.dark,.dark *)` pattern
- **CSS Variables** - Now uses Filament v4 CSS variables (e.g., `var(--gray-950)`)

#### Improvements
- **Performance** - Optimized media queries with proper scope handling
- **Code Quality** - Removed debug console.log statements
- **Event Handling** - More reliable event system using native browser events
- **State Synchronization** - Better `$wire.set()` usage for state management
- **Validation** - Improved min/max items validation with clear user feedback

### =ďż˝ Documentation

- **Updated README.md** with:
  - MediaManagerPicker features and usage
  - InteractsWithMediaManager trait documentation
  - Usage examples for all major features
  - Updated feature list with emojis
- **New TRAITS.md** - Complete guide for the InteractsWithMediaManager trait
- **New CHANGELOG.md** - This comprehensive changelog
- **New tests/README.md** - Comprehensive testing guide

### 🧪 Testing

- **MediaManagerPickerTest** - 30+ test cases covering component configuration, folder navigation, password protection, and file upload
- **MediaManagerInputTest** - 35+ test cases covering file uploads, media retrieval, deletion, and validation
- **InteractsWithMediaManagerTest** - 20+ test cases covering all 11 trait methods
- **Test Infrastructure**: Product model factory, in-memory SQLite, comprehensive documentation

### 🔧 Technical Details

#### Files Modified
- `src/Livewire/MediaPicker.php` - Enhanced with password protection, upload, selection management
- `src/Form/MediaManagerPicker.php` - Added remove action, browse action improvements
- `resources/views/livewire/media-picker.blade.php` - Complete UI overhaul
- `resources/views/forms/media-manager-picker.blade.php` - Preview list, empty state, event handling
- `resources/views/components/media-picker-modal.blade.php` - Initial state support
- `resources/lang/en/messages.php` - Added new translation keys
- `resources/lang/ar/messages.php` - Added Arabic translations

#### Files Created
- `src/Traits/InteractsWithMediaManager.php` - New trait for model integration
- `docs/TRAITS.md` - Trait documentation
- `CHANGELOG.md` - This changelog

#### Files Created (Tests)
- `tests/src/MediaManagerPickerTest.php` - Comprehensive MediaManagerPicker tests
- `tests/src/MediaManagerInputTest.php` - Comprehensive MediaManagerInput tests
- `tests/src/InteractsWithMediaManagerTest.php` - Trait functionality tests
- `tests/src/Models/Product.php` - Test model with media support
- `tests/database/factories/ProductFactory.php` - Product factory for testing
- `tests/database/migrations/2025_10_07_000001_create_products_table.php` - Products table migration
- `tests/README.md` - Testing documentation and guide

### 🙏 Credits

Special thanks to all contributors and users who provided feedback during the development of v4.0.0.

---

## Previous Versions

For changelog of versions before v4.0.0, please refer to the git history or previous documentation.
</file>

<file path="src/Resources/Actions/EditCurrentFolderAction.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\Actions;

use Filament\Actions;
use Filament\Forms;
use Filament\Notifications\Notification;
use Filament\Schemas\Components\Grid;
use Filament\Schemas\Components\Utilities\Get;
use TomatoPHP\FilamentIcons\Components\IconPicker;

class EditCurrentFolderAction
{
    public static function make(int $folder_id): Actions\Action
    {
        $form = config('filament-media-manager.model.folder')::query()->where('id', $folder_id)->with('users')->first()?->toArray();
        $form['users'] = collect($form['users'])->pluck('id')->toArray();

        return Actions\Action::make('edit_current_folder')
            ->hiddenLabel()
            ->mountUsing(function () use ($folder_id) {
                session()->put('folder_id', $folder_id);
            })
            ->tooltip(trans('filament-media-manager::messages.media.actions.edit.label'))
            ->label(trans('filament-media-manager::messages.media.actions.edit.label'))
            ->icon('heroicon-o-pencil-square')
            ->color('warning')
            ->schema(function () {
                return [
                    Grid::make([
                        'sm' => 1,
                        'md' => 2,
                    ])
                        ->schema([
                            Forms\Components\TextInput::make('name')
                                ->label(trans('filament-media-manager::messages.folders.columns.name'))
                                ->columnSpanFull()
                                ->required()
                                ->maxLength(255),
                            Forms\Components\Textarea::make('description')
                                ->label(trans('filament-media-manager::messages.folders.columns.description'))
                                ->columnSpanFull()
                                ->maxLength(255),
                            IconPicker::make('icon')
                                ->label(trans('filament-media-manager::messages.folders.columns.icon')),
                            Forms\Components\ColorPicker::make('color')
                                ->label(trans('filament-media-manager::messages.folders.columns.color')),
                            Forms\Components\Toggle::make('is_protected')
                                ->label(trans('filament-media-manager::messages.folders.columns.is_protected'))
                                ->live()
                                ->columnSpanFull(),
                            Forms\Components\TextInput::make('password')
                                ->label(trans('filament-media-manager::messages.folders.columns.password'))
                                ->hidden(fn (Get $get) => ! $get('is_protected'))
                                ->confirmed()
                                ->password()
                                ->revealable()
                                ->required()
                                ->maxLength(255),
                            Forms\Components\TextInput::make('password_confirmation')
                                ->label(trans('filament-media-manager::messages.folders.columns.password_confirmation'))
                                ->hidden(fn (Get $get) => ! $get('is_protected'))
                                ->password()
                                ->required()
                                ->revealable()
                                ->maxLength(255),
                            Forms\Components\Toggle::make('is_public')
                                ->visible(filament('filament-media-manager')->allowUserAccess)
                                ->label(trans('filament-media-manager::messages.folders.columns.is_public'))
                                ->live()
                                ->columnSpanFull(),
                            Forms\Components\Toggle::make('has_user_access')
                                ->visible(filament('filament-media-manager')->allowUserAccess)
                                ->hidden(fn (Get $get) => $get('is_public'))
                                ->label(trans('filament-media-manager::messages.folders.columns.has_user_access'))
                                ->live()
                                ->columnSpanFull(),
                            Forms\Components\Select::make('users')
                                ->required()
                                ->visible(filament('filament-media-manager')->allowUserAccess)
                                ->hidden(fn (Get $get) => ! $get('has_user_access'))
                                ->label(trans('filament-media-manager::messages.folders.columns.users'))
                                ->searchable()
                                ->multiple()
                                ->options(config('filament-media-manager.user.model', \App\Models\User::class)::query()->where('id', '!=', auth()->user()->id)->pluck(config('filament-media-manager.user.column_name'), 'id')->toArray()),
                        ]),
                ];
            })
            ->fillForm($form)
            ->action(function (array $data) use ($folder_id) {
                $folder = config('filament-media-manager.model.folder')::find($folder_id);
                $folder->update($data);

                if (isset($data['users'])) {
                    $folder->users()->sync($data['users']);
                }

                Notification::make()
                    ->body(trans('filament-media-manager::messages.media.notifications.edit-folder'))
                    ->success()
                    ->send();
            });
    }
}
</file>

<file path="src/Resources/FolderResource/Pages/ListFolders.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\FolderResource\Pages;

use Filament\Actions;
use Filament\Resources\Pages\ManageRecords;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource;

class ListFolders extends ManageRecords
{
    protected static string $resource = FolderResource::class;

    protected function getHeaderActions(): array
    {
        return [
            Actions\CreateAction::make(),
        ];
    }

    public function mount(): void
    {
        parent::mount();

        session()->forget('folder_id');
        session()->forget('folder_password');
    }
}
</file>

<file path="src/Models/Folder.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;

class Folder extends Model implements HasMedia
{
    use HasFactory;
    use InteractsWithMedia;

    protected $fillable = [
        'parent_id',
        'model_type',
        'model_id',
        'name',
        'collection',
        'description',
        'icon',
        'color',
        'is_protected',
        'password',
        'is_hidden',
        'is_favorite',
        'is_public',
        'has_user_access',
        'user_id',
        'user_type',
    ];

    protected $casts = [
        'is_protected' => 'boolean',
        'is_hidden' => 'boolean',
        'is_favorite' => 'boolean',
        'is_public' => 'boolean',
        'has_user_access' => 'boolean',
    ];

    public function model()
    {
        return $this->morphTo();
    }

    public function user()
    {
        return $this->morphTo();
    }

    public function users()
    {
        return $this->morphedByMany(config('filament-media-manager.user.model', \App\Models\User::class), 'model', 'folder_has_models', 'folder_id', 'model_id');
    }

    protected static function boot()
    {
        parent::boot(); // TODO: Change the autogenerated stub

        static::addGlobalScope('user', function ($query) {
            if (filament('filament-media-manager')->allowUserAccess && auth()->check()) {
                $query
                    ->where('user_id', auth()->id())
                    ->orWhere('is_public', false)
                    ->where('has_user_access', true)
                    ->whereHas('users', function ($query) {
                        $query->where('model_id', auth()->id())
                            ->where('model_type', get_class(auth()->user()));
                    })
                    ->orWhere('is_public', true);
            }
        });

    }

    public function folders()
    {
        return $this->hasMany(Folder::class, 'parent_id');
    }

    public function parent()
    {
        return $this->belongsTo(Folder::class, 'parent_id');
    }

    /**
     * Create a new factory instance for the model.
     */
    protected static function newFactory()
    {
        return \TomatoPHP\FilamentMediaManager\Tests\Database\Factories\FolderFactory::new();
    }
}
</file>

<file path="src/Resources/FolderResource.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources;

use BackedEnum;
use Filament\Actions;
use Filament\Forms;
use Filament\Resources\Resource;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Filament\Schemas\Schema;
use Filament\Tables;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Str;
use TomatoPHP\FilamentIcons\Components\IconPicker;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource\Pages;

class FolderResource extends Resource
{
    protected static bool $isScopedToTenant = false;

    protected static BackedEnum | string | null $navigationIcon = 'heroicon-o-folder';

    public static function getModel(): string
    {
        return config('filament-media-manager.model.folder'); // TODO: Change the autogenerated stub
    }

    public static function getNavigationLabel(): string
    {
        $plugin = filament('filament-media-manager');

        return $plugin->navigationLabel ?? trans('filament-media-manager::messages.folders.title');
    }

    public static function getNavigationIcon(): string
    {
        $plugin = filament('filament-media-manager');

        return $plugin->navigationIcon ?? static::$navigationIcon ?? 'heroicon-o-folder';
    }

    public static function getPluralLabel(): ?string
    {
        if (request()->has('model_type') && ! request()->has('collection')) {
            return str(request()->get('model_type'))->afterLast('\\')->title();
        } elseif (request()->has('model_type') && request()->has('collection')) {
            return str(request()->get('collection'))->title();
        } else {
            $plugin = filament('filament-media-manager');

            return $plugin->navigationLabel ?? trans('filament-media-manager::messages.folders.title');
        }
    }

    public static function getLabel(): ?string
    {
        return trans('filament-media-manager::messages.folders.single'); // TODO: Change the autogenerated stub
    }

    public static function getNavigationGroup(): ?string
    {
        $plugin = filament('filament-media-manager');

        return $plugin->navigationGroup ?? trans('filament-media-manager::messages.folders.group'); // TODO: Change the autogenerated stub
    }

    public static function getNavigationSort(): ?int
    {
        return config('filament-media-manager.navigation_sort', null);
    }

    public static function form(Schema $form): Schema
    {
        return $form
            ->schema([
                Forms\Components\Hidden::make('user_id')->visible(filament('filament-media-manager')->allowUserAccess)->default(auth()->id()),
                Forms\Components\Hidden::make('user_type')->visible(filament('filament-media-manager')->allowUserAccess)->default(get_class(auth()->user())),
                Forms\Components\TextInput::make('name')
                    ->label(trans('filament-media-manager::messages.folders.columns.name'))
                    ->columnSpanFull()
                    ->lazy()
                    ->afterStateUpdated(function (Set $set, Get $get) {
                        $set('collection', Str::slug($get('name')));
                    })
                    ->required()
                    ->maxLength(255),
                Forms\Components\TextInput::make('collection')
                    ->label(trans('filament-media-manager::messages.folders.columns.collection'))
                    ->columnSpanFull()
                    ->unique()
                    ->required()
                    ->maxLength(255),
                Forms\Components\Textarea::make('description')
                    ->label(trans('filament-media-manager::messages.folders.columns.description'))
                    ->columnSpanFull()
                    ->maxLength(255),
                IconPicker::make('icon')
                    ->label(trans('filament-media-manager::messages.folders.columns.icon')),
                Forms\Components\ColorPicker::make('color')
                    ->label(trans('filament-media-manager::messages.folders.columns.color')),
                Forms\Components\Toggle::make('is_protected')
                    ->label(trans('filament-media-manager::messages.folders.columns.is_protected'))
                    ->live()
                    ->columnSpanFull(),
                Forms\Components\TextInput::make('password')
                    ->label(trans('filament-media-manager::messages.folders.columns.password'))
                    ->hidden(fn (Get $get) => ! $get('is_protected'))
                    ->password()
                    ->revealable()
                    ->required()
                    ->maxLength(255),
                Forms\Components\TextInput::make('password_confirmation')
                    ->label(trans('filament-media-manager::messages.folders.columns.password_confirmation'))
                    ->hidden(fn (Get $get) => ! $get('is_protected'))
                    ->password()
                    ->required()
                    ->revealable()
                    ->maxLength(255),
            ])->columns(2);
    }

    public static function table(Table $table): Table
    {
        return $table
            ->modifyQueryUsing(function (Builder $query) {
                if (request()->has('model_type') && ! request()->has('collection')) {
                    $query->where('model_type', request()->get('model_type'))
                        ->where('model_id', null)
                        ->whereNotNull('collection');
                } elseif (request()->has('model_type') && request()->has('collection')) {
                    $query->where('model_type', request()->get('model_type'))
                        ->whereNotNull('model_id')
                        ->where('collection', request()->get('collection'));
                } else {
                    $query->where('model_id', null)
                        ->where('collection', null)->orWhere('model_type', null);
                }
            })
            ->content(function () {
                return view('filament-media-manager::pages.folders');
            })
            ->columns([
                Tables\Columns\Layout\Stack::make([
                    Tables\Columns\TextColumn::make('name')
                        ->label(trans('filament-media-manager::messages.folders.columns.name'))
                        ->sortable()
                        ->searchable(),
                    Tables\Columns\TextColumn::make('description')
                        ->label(trans('filament-media-manager::messages.folders.columns.description'))
                        ->searchable(),
                    Tables\Columns\TextColumn::make('icon')
                        ->label(trans('filament-media-manager::messages.folders.columns.icon'))
                        ->sortable()
                        ->searchable(),
                    Tables\Columns\TextColumn::make('color')
                        ->label(trans('filament-media-manager::messages.folders.columns.color'))
                        ->sortable()
                        ->searchable(),
                    Tables\Columns\IconColumn::make('is_protected')
                        ->label(trans('filament-media-manager::messages.folders.columns.is_protected'))
                        ->sortable()
                        ->boolean(),
                    Tables\Columns\TextColumn::make('created_at')
                        ->dateTime()
                        ->sortable(),
                    Tables\Columns\TextColumn::make('updated_at')
                        ->dateTime()
                        ->sortable(),
                ]),
            ])
            ->defaultPaginationPageOption(12)
            ->paginationPageOptions([
                '12',
                '24',
                '48',
                '96',
            ])
            ->filters([
                Tables\Filters\TernaryFilter::make('is_protected')
                    ->label(trans('filament-media-manager::messages.folders.columns.is_protected'))
                    ->placeholder(trans('filament-media-manager::messages.folders.filters.all_folders'))
                    ->trueLabel(trans('filament-media-manager::messages.folders.filters.protected_only'))
                    ->falseLabel(trans('filament-media-manager::messages.folders.filters.public_only')),
                Tables\Filters\Filter::make('created_at')
                    ->form([
                        Forms\Components\DatePicker::make('created_from')
                            ->label(trans('filament-media-manager::messages.folders.filters.created_from')),
                        Forms\Components\DatePicker::make('created_until')
                            ->label(trans('filament-media-manager::messages.folders.filters.created_until')),
                    ])
                    ->query(function (Builder $query, array $data): Builder {
                        return $query
                            ->when(
                                $data['created_from'],
                                fn (Builder $query, $date): Builder => $query->whereDate('created_at', '>=', $date),
                            )
                            ->when(
                                $data['created_until'],
                                fn (Builder $query, $date): Builder => $query->whereDate('created_at', '<=', $date),
                            );
                    }),
            ])
            ->recordActions([
                Actions\EditAction::make(),
                Actions\DeleteAction::make(),
            ])
            ->toolbarActions([
                Actions\BulkActionGroup::make([
                    Actions\DeleteBulkAction::make(),
                ]),
            ]);
    }

    public static function getRelations(): array
    {
        return [
            //
        ];
    }

    public static function getPages(): array
    {
        return [
            'index' => Pages\ListFolders::route('/'),
        ];
    }
}
</file>

<file path="config/filament-media-manager.php">
<?php

return [
    'model' => [
        'folder' => \TomatoPHP\FilamentMediaManager\Models\Folder::class,
        'media' => \TomatoPHP\FilamentMediaManager\Models\Media::class,
    ],

    'api' => [
        'active' => false,
        'middlewares' => [
            'api',
            'auth:sanctum',
        ],
        'prefix' => 'api/media-manager',
        'resources' => [
            'folders' => \TomatoPHP\FilamentMediaManager\Http\Resources\FoldersResource::class,
            'folder' => \TomatoPHP\FilamentMediaManager\Http\Resources\FolderResource::class,
            'media' => \TomatoPHP\FilamentMediaManager\Http\Resources\MediaResource::class,
        ],
    ],

    'user' => [
        'model' => \App\Models\User::class, // Change this to your user model
        'column_name' => 'name', // Change the value if your field in users table is different from "name"
    ],

    'navigation_sort' => 0,
];
</file>

<file path="src/Resources/MediaResource/Pages/ListMedia.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Resources\MediaResource\Pages;

use Filament\Actions;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;
use Filament\Resources\Pages\ManageRecords;
use Illuminate\Contracts\Support\Htmlable;
use TomatoPHP\FilamentMediaManager\Models\Folder;
use TomatoPHP\FilamentMediaManager\Models\Media;
use TomatoPHP\FilamentMediaManager\Resources\Actions\CreateMediaAction;
use TomatoPHP\FilamentMediaManager\Resources\Actions\CreateSubFolderAction;
use TomatoPHP\FilamentMediaManager\Resources\Actions\DeleteFolderAction;
use TomatoPHP\FilamentMediaManager\Resources\Actions\EditCurrentFolderAction;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource;

class ListMedia extends ManageRecords
{
    protected static string $resource = MediaResource::class;

    public ?int $folder_id = null;

    public ?Folder $folder = null;

    public function getTitle(): string | Htmlable
    {
        return $this->folder->name;
    }

    public function getSubheading(): string | Htmlable
    {
        return $this->folder->description ?? '';
    }

    public function mount(): void
    {
        parent::mount(); // TODO: Change the autogenerated stub

        if (! request()->has('folder_id')) {
            abort(404, 'Folder ID is required');
        }

        $folder = Folder::find(request()->get('folder_id'));
        if (! $folder) {
            abort(404, 'Folder ID is required');
        } else {
            if ($folder->is_protected && ! session()->has('folder_password')) {
                abort(403, 'You Cannot Access This Folder');
            }
        }

        $this->folder = $folder;
        $this->folder_id = request()->get('folder_id');
        session()->put('folder_id', $this->folder_id);
    }

    protected function getHeaderActions(): array
    {
        $folder_id = $this->folder_id;

        $folder = config('filament-media-manager.model.folder')::find($folder_id);

        if (filament('filament-media-manager')->allowUserAccess && (! empty($folder->user_id))) {
            if ($folder->user_id === auth()->user()->id && $folder->user_type === get_class(auth()->user())) {
                return [
                    CreateMediaAction::make($folder_id),
                    CreateSubFolderAction::make($folder_id),
                    DeleteFolderAction::make($folder_id),
                    EditCurrentFolderAction::make($folder_id),
                ];
            } else {
                return [];
            }
        } else {
            return [
                CreateMediaAction::make($folder_id),
                CreateSubFolderAction::make($folder_id),
                DeleteFolderAction::make($folder_id),
                EditCurrentFolderAction::make($folder_id),
            ];
        }
    }

    public function folderAction(?Folder $item = null)
    {
        return Actions\Action::make('folderAction')
            ->requiresConfirmation(function (array $arguments) {
                if ($arguments['record']['is_protected']) {
                    return true;
                } else {
                    return false;
                }
            })
            ->schema(function (array $arguments) {
                if ($arguments['record']['is_protected']) {
                    return [
                        TextInput::make('password')
                            ->password()
                            ->revealable()
                            ->required()
                            ->maxLength(255),
                    ];
                } else {
                    return null;
                }
            })
            ->action(function (array $arguments, array $data) {
                if ($arguments['record']['is_protected']) {
                    if ($arguments['record']['password'] != $data['password']) {
                        Notification::make()
                            ->title('Password is incorrect')
                            ->danger()
                            ->send();

                        return;
                    } else {
                        session()->put('folder_password', $data['password']);
                    }
                }
                if (! $arguments['record']['model_type']) {
                    if (filament()->getTenant()) {
                        return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/media?folder_id=' . $arguments['record']['id']));
                    } else {
                        return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.media.index', ['folder_id' => $arguments['record']['id']]);
                    }
                }
                if (! $arguments['record']['model_id'] && ! $arguments['record']['collection']) {
                    if (filament()->getTenant()) {
                        return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/folders?model_type=' . $arguments['record']['model_type']));
                    } else {
                        return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.folders.index', ['model_type' => $arguments['record']['model_type']]);
                    }
                } elseif (! $arguments['record']['model_id']) {
                    if (filament()->getTenant()) {
                        return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/folders?model_type=' . $arguments['record']['model_type'] . '&collection=' . $arguments['record']['collection']));
                    } else {
                        return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.folders.index', ['model_type' => $arguments['record']['model_type'], 'collection' => $arguments['record']['collection']]);
                    }
                } else {
                    if (filament()->getTenant()) {
                        return redirect()->to(url(filament()->getCurrentPanel()->getId() . '/' . filament()->getTenant()->id . '/media?folder_id=' . $arguments['record']['id']));
                    } else {
                        return redirect()->route('filament.' . filament()->getCurrentPanel()->getId() . '.resources.media.index', ['folder_id' => $arguments['record']['id']]);
                    }
                }
            })
            ->view('filament-media-manager::pages.folder-action', ['item' => $item]);
    }

    public function editMedia(): Actions\Action
    {
        return Actions\Action::make('editMedia')
            ->label(trans('filament-media-manager::messages.media.meta.edit-media'))
            ->icon('heroicon-s-pencil')
            ->color('primary')
            ->fillForm(function (array $arguments): array {
                $media = Media::find($arguments['record']['id']);

                return [
                    'title' => $media->getCustomProperty('title'),
                    'description' => $media->getCustomProperty('description'),
                    'alt' => $media->getCustomProperty('alt'),
                ];
            })
            ->schema([
                \Filament\Forms\Components\TextInput::make('title')
                    ->label('Title')
                    ->maxLength(255),
                \Filament\Forms\Components\Textarea::make('description')
                    ->label('Description')
                    ->rows(3)
                    ->maxLength(500),
                \Filament\Forms\Components\TextInput::make('alt')
                    ->label('Alt Text')
                    ->maxLength(255),
            ])
            ->action(function (array $arguments, array $data) {
                $media = Media::find($arguments['record']['id']);

                $media->setCustomProperty('title', $data['title']);
                $media->setCustomProperty('description', $data['description']);
                $media->setCustomProperty('alt', $data['alt']);
                $media->save();
            })
            ->successNotificationTitle('Media updated successfully');
    }

    public function deleteMedia(): Actions\Action
    {
        return Actions\Action::make('deleteMedia')
            ->label(trans('filament-media-manager::messages.media.meta.delete-media'))
            ->icon('heroicon-s-trash')
            ->color('danger')
            ->requiresConfirmation()
            ->action(function (array $arguments) {
                $media = Media::find($arguments['record']['id']);
                $media->delete();
            })
            ->successNotificationTitle(trans('filament-media-manager::messages.media.notifications.delete-folder'));

    }
}
</file>

<file path="composer.json">
{
    "name": "tomatophp/filament-media-manager",
    "type": "library",
    "description": "Manage your media files using spatie media library with easy to use GUI for FilamentPHP",
    "keywords": [
        "php",
        "laravel",
        "filament",
        "media",
        "manager",
        "spatie",
        "media-library"
    ],
    "license": "MIT",
    "autoload": {
        "psr-4": {
            "TomatoPHP\\FilamentMediaManager\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "TomatoPHP\\FilamentMediaManager\\Tests\\": "tests/src",
            "TomatoPHP\\FilamentMediaManager\\Tests\\Database\\Factories\\": "tests/database/factories"
        }
    },
    "extra": {
        "laravel": {
            "providers": [
                "TomatoPHP\\FilamentMediaManager\\FilamentMediaManagerServiceProvider"
            ]
        }
    },
    "authors": [
        {
            "name": "Fady Mondy",
            "email": "info@3x1.io"
        }
    ],
    "scripts": {
        "testbench": "vendor/bin/testbench package:discover --ansi",
        "db": "vendor/bin/testbench package:create-sqlite-db && vendor/bin/testbench migrate",
        "analyse": "vendor/bin/phpstan analyse src tests",
        "test": "vendor/bin/pest",
        "test-coverage": "vendor/bin/pest --coverage",
        "format": "vendor/bin/pint"
    },
    "config": {
        "sort-packages": true,
        "allow-plugins": {
            "pestphp/pest-plugin": true,
            "phpstan/extension-installer": true
        }
    },
    "require": {
        "php": "^8.2|^8.3|^8.4",
        "tomatophp/console-helpers": "^1.1",
        "spatie/laravel-medialibrary": "^10.0|^11.15",
        "tomatophp/filament-icons": "^v4.0",
        "filament/spatie-laravel-media-library-plugin": "^v4.0",
        "filament/filament": "^v4.0"
    },
    "require-dev": {
        "larastan/larastan": "^2.9||^3.0",
        "laravel/pint": "^1.14",
        "nunomaduro/collision": "^8.1.1||^7.10.0",
        "orchestra/testbench": "^10.0.0||^9.0.0",
        "pestphp/pest": "^3.0",
        "pestphp/pest-plugin-arch": "^3.0",
        "pestphp/pest-plugin-laravel": "^3.0",
        "pestphp/pest-plugin-livewire": "^3.0",
        "pestphp/pest-plugin-type-coverage": "^3.5",
        "phpstan/extension-installer": "^1.3||^2.0",
        "phpstan/phpstan": "^2.1",
        "phpstan/phpstan-deprecation-rules": "^1.1||^2.0",
        "phpstan/phpstan-phpunit": "^1.3||^2.0"
    },
    "version": "4.0.3"
}
</file>

<file path="resources/lang/ar/messages.php">
<?php

return [
    'empty' => [
        'title' => 'لا يوجد وسائط أو مجلدات',
    ],
    'folders' => [
        'title' => 'مدير الوسائط',
        'single' => 'مجلد',
        'columns' => [
            'name' => 'الاسم',
            'collection' => 'المجموعة',
            'description' => 'الوصف',
            'icon' => 'الايقونة',
            'color' => 'اللون',
            'is_protected' => 'محمي بكلمة مرور',
            'password' => 'كلمة المرور',
            'password_confirmation' => 'تأكيد كلمة المرور',
        ],
        'filters' => [
            'all_folders' => 'كل المجلدات',
            'protected_only' => 'المحمية فقط',
            'public_only' => 'العامة فقط',
            'created_from' => 'تم الإنشاء من',
            'created_until' => 'تم الإنشاء حتى',
        ],
        'group' => 'المحتوي',
    ],
    'media' => [
        'title' => 'الوسائط',
        'single' => 'وسائط',
        'columns' => [
            'image' => 'الصورة',
            'model' => 'النموذج',
            'collection_name' => 'اسم المجموعة',
            'size' => 'الججم',
            'order_column' => 'عمود الترتيب',
        ],
        'filters' => [
            'size_from' => 'الحجم من (كيلوبايت)',
            'size_to' => 'الحجم إلى (كيلوبايت)',
            'created_from' => 'تم الإنشاء من',
            'created_until' => 'تم الإنشاء حتى',
        ],
        'actions' => [
            'sub_folder' => [
                'label' => 'إنشاء مجلد فرعي',
            ],
            'create' => [
                'label' => 'إضافة وسائط',
                'form' => [
                    'file' => 'الملف',
                    'title' => 'العنوان',
                    'description' => 'الوصف',
                ],
            ],
            'delete' => [
                'label' => 'حذف المجلد',
            ],
            'edit' => [
                'label' => 'تعديل المجلد',
            ],
        ],
        'notifications' => [
            'create-media' => 'تم إنشاء الوسائط بنجاح',
            'delete-folder' => 'تم حذف المجلد بنجاح',
            'edit-folder' => 'تم تعديل المجلد بنجاح',
        ],
        'meta' => [
            'model' => 'نموذج',
            'file-name' => 'اسم الملف',
            'type' => 'نوع',
            'size' => 'حجم',
            'disk' => 'قرص',
            'url' => 'رابط',
            'delete-media' => 'حذف الوسائط',
        ],
    ],
    'picker' => [
        'title' => 'اختر الوسائط',
        'browse' => 'تصفح الوسائط',
        'remove' => 'إزالة',
        'select' => 'اختيار',
        'cancel' => 'إلغاء',
        'back' => 'رجوع',
        'search' => 'بحث في المجلدات والملفات...',
        'select_folder' => 'اختر مجلد لتصفح ملفات الوسائط',
        'folders' => 'المجلدات',
        'media_files' => 'ملفات الوسائط',
        'empty' => 'لا توجد مجلدات أو ملفات وسائط',
        'no_media_selected' => 'لم يتم اختيار وسائط',
        'selected' => 'محدد',
        'clear_all' => 'مسح الكل',
        'confirm_remove' => 'إزالة الوسائط',
        'confirm_remove_message' => 'هل أنت متأكد من إزالة هذا العنصر؟',
    ],
];
</file>

<file path="src/FilamentMediaManagerPlugin.php">
<?php

namespace TomatoPHP\FilamentMediaManager;

use Filament\Contracts\Plugin;
use Filament\Panel;
use Livewire\Livewire;
use TomatoPHP\FilamentMediaManager\Livewire\MediaPicker;
use TomatoPHP\FilamentMediaManager\Resources\FolderResource;
use TomatoPHP\FilamentMediaManager\Resources\MediaResource;

class FilamentMediaManagerPlugin implements Plugin
{
    public ?bool $allowSubFolders = false;

    public ?bool $allowUserAccess = false;

    public ?string $navigationLabel = null;

    public ?string $navigationGroup = null;

    public ?string $navigationIcon = null;

    public function getId(): string
    {
        return 'filament-media-manager';
    }

    public function allowSubFolders(bool $condation = true): static
    {
        $this->allowSubFolders = $condation;

        return $this;
    }

    public function allowUserAccess(bool $condation = true): static
    {
        $this->allowUserAccess = $condation;

        return $this;
    }

    public function navigationLabel(string $label): static
    {
        $this->navigationLabel = $label;

        return $this;
    }

    public function navigationGroup(string $group): static
    {
        $this->navigationGroup = $group;

        return $this;
    }

    public function navigationIcon(string $icon): static
    {
        $this->navigationIcon = $icon;

        return $this;
    }

    public function register(Panel $panel): void
    {
        $panel->resources([
            FolderResource::class,
            MediaResource::class,
        ]);
    }

    public function boot(Panel $panel): void
    {
        Livewire::component('media-picker', MediaPicker::class);
    }

    public static function make(): static
    {
        return new static;
    }
}
</file>

<file path="resources/lang/en/messages.php">
<?php

return [
    'empty' => [
        'title' => 'No Media or Folders Found',
    ],
    'folders' => [
        'title' => 'Media Manager',
        'single' => 'Folder',
        'columns' => [
            'name' => 'Name',
            'collection' => 'Collection',
            'description' => 'Description',
            'is_public' => 'Is Public',
            'has_user_access' => 'Has User Access',
            'users' => 'Users',
            'icon' => 'Icon',
            'color' => 'Color',
            'is_protected' => 'Is Protected',
            'password' => 'Password',
            'password_confirmation' => 'Password Confirmation',
        ],
        'filters' => [
            'all_folders' => 'All folders',
            'protected_only' => 'Protected only',
            'public_only' => 'Public only',
            'created_from' => 'Created from',
            'created_until' => 'Created until',
        ],
        'group' => 'Content',
    ],
    'media' => [
        'title' => 'Media',
        'single' => 'Media',
        'columns' => [
            'image' => 'Image',
            'model' => 'Model',
            'collection_name' => 'Collection Name',
            'size' => 'Size',
            'order_column' => 'Order Column',
        ],
        'filters' => [
            'size_from' => 'Size from (KB)',
            'size_to' => 'Size to (KB)',
            'created_from' => 'Created from',
            'created_until' => 'Created until',
        ],
        'actions' => [
            'sub_folder' => [
                'label' => 'Create Sub Folder',
            ],
            'create' => [
                'label' => 'Add Media',
                'form' => [
                    'file' => 'File',
                    'title' => 'Title',
                    'description' => 'Description',
                ],
            ],
            'delete' => [
                'label' => 'Delete Folder',
            ],
            'edit' => [
                'label' => 'Edit Folder',
            ],
        ],
        'notifications' => [
            'create-media' => 'Media created successfully',
            'delete-folder' => 'Folder deleted successfully',
            'edit-folder' => 'Folder edited successfully',
        ],
        'meta' => [
            'model' => 'Model',
            'file-name' => 'File Name',
            'type' => 'Type',
            'size' => 'Size',
            'disk' => 'Disk',
            'url' => 'URL',
            'edit-media' => 'Edit Media',
            'delete-media' => 'Delete Media',
        ],
    ],
    'picker' => [
        'title' => 'Select Media',
        'browse' => 'Browse Media',
        'remove' => 'Remove',
        'select' => 'Select',
        'cancel' => 'Cancel',
        'back' => 'Back',
        'search' => 'Search folders and files...',
        'select_folder' => 'Select a folder to browse media files',
        'folders' => 'Folders',
        'media_files' => 'Media Files',
        'empty' => 'No folders or media files found',
        'no_media_selected' => 'No media selected',
        'selected' => 'selected',
        'clear_all' => 'Clear all',
        'confirm_remove' => 'Remove Media',
        'confirm_remove_message' => 'Are you sure you want to remove this media item?',
    ],
];
</file>

<file path="src/Form/MediaManagerInput.php">
<?php

namespace TomatoPHP\FilamentMediaManager\Form;

use Closure;
use Filament\Actions\Action;
use Filament\Forms\Components\Component;
use Filament\Forms\Components\Repeater;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use League\Flysystem\UnableToCheckFileExistence;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\MediaCollections\FileAdder;
use Spatie\MediaLibrary\MediaCollections\MediaCollection;
use Spatie\MediaLibrary\MediaCollections\Models\Media as SpatieMedia;
use Throwable;
use TomatoPHP\FilamentMediaManager\Models\Media;

class MediaManagerInput extends Repeater
{
    protected array $form = [];

    protected string | Closure | null $diskName = null;

    protected string | Closure | null $folderTitleFieldName = null;

    protected bool $isSingle = false;

    protected function setUp(): void
    {
        parent::setUp();

        // Configure repeater based on single mode
        if ($this->isSingle) {
            $this->minItems(1);
            $this->maxItems(1);
            $this->defaultItems(1);
            $this->reorderable(false);
            $this->addActionLabel(trans('filament-media-manager::messages.media.actions.create.label'));
        }

        $this->saveRelationshipsUsing(static function (Repeater $component, HasMedia $record): void {
            $childComponents = $component->getChildComponents();
            /** @var FileInput|null $mediaComponent */
            $mediaComponent = ! empty($childComponents) ? $childComponents[0] : null;
            $setState = $component->getState();

            if (! $mediaComponent) {
                return;
            }

            // If state is null, empty, or not an array, nothing to process
            if ($setState === null || ! is_array($setState) || empty($setState)) {
                return;
            }

            // Collect existing media UUIDs (only strings, not TemporaryUploadedFile objects)
            $collectMediaIds = [];
            foreach ($setState as $getMediaItems) {
                if (isset($getMediaItems['file'])) {
                    $file = $getMediaItems['file'];

                    // Handle array of files
                    if (is_array($file)) {
                        foreach ($file as $key => $value) {
                            // If it's a UUID string in array keys or values, collect it
                            if (is_string($key) && Str::isUuid($key)) {
                                $collectMediaIds[] = $key;
                            } elseif (is_string($value) && Str::isUuid($value)) {
                                $collectMediaIds[] = $value;
                            }
                        }
                    }
                    // Handle single UUID string (existing media)
                    elseif (is_string($file) && Str::isUuid($file)) {
                        $collectMediaIds[] = $file;
                    }
                    // TemporaryUploadedFile objects are new uploads, not existing media
                }
            }
            $getState = [];

            // Only delete media that's been removed (not in the current state)
            if (! empty($collectMediaIds)) {
                $record->media()->where('collection_name', $component->name)->whereNotIn('uuid', $collectMediaIds)->delete();
            }

            $counter = 0;
            foreach ($setState as $item) {
                // Skip if no file data
                if (! isset($item['file'])) {
                    continue;
                }

                $state = array_filter(array_map(function (TemporaryUploadedFile | string $file) use ($mediaComponent, $record, $component, $item, &$counter) {
                    if (! $file instanceof TemporaryUploadedFile) {
                        $media = SpatieMedia::whereUuid($file)->first();

                        if ($media) {
                            $customProperties = collect($item)->filter(fn ($value, $key) => $key !== 'file')->toArray();
                            foreach ($customProperties as $key => $property) {
                                $media->setCustomProperty($key, $property);
                            }
                            $media->order_column = $counter;
                            $media->save();
                            $counter++;
                        }

                        return $file;
                    }

                    if (! method_exists($record, 'addMediaFromString')) {
                        return $file;
                    }

                    try {
                        if (! $file->exists()) {
                            return null;
                        }
                    } catch (UnableToCheckFileExistence $exception) {
                        return null;
                    }

                    /** @var FileAdder $mediaAdder */
                    $mediaAdder = $record->addMediaFromString($file->get());

                    $filename = $mediaComponent->shouldPreserveFilenames() ? $file->getClientOriginalName() : (Str::ulid() . '.' . $file->getClientOriginalExtension());

                    $media = $mediaAdder
                        ->addCustomHeaders($mediaComponent->getCustomHeaders())
                        ->usingFileName($filename)
                        ->usingName($mediaComponent->getMediaName($file) ?? pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME))
                        ->storingConversionsOnDisk($mediaComponent->getConversionsDisk() ?? '')
                        ->withCustomProperties(collect($item)->filter(fn ($value, $key) => $key !== 'file')->toArray())
                        ->withManipulations($mediaComponent->getManipulations())
                        ->withResponsiveImagesIf($mediaComponent->hasResponsiveImages())
                        ->withProperties($mediaComponent->getProperties())
                        ->setOrder($counter)
                        ->toMediaCollection($component->name ?? 'default', $component->getDiskName());

                    $homeFolder = config('filament-media-manager.model.folder')::where('model_type', get_class($record))
                        ->where('model_id', null)
                        ->where('collection', null)
                        ->first();
                    if (! $homeFolder) {
                        $data = [
                            'model_type' => get_class($record),
                            'model_id' => null,
                            'name' => Str::of(get_class($record))->afterLast('\\')->title()->toString(),
                        ];
                        if (filament('filament-media-manager')->allowUserAccess) {
                            $data['user_id'] = auth()->user()->id;
                            $data['user_type'] = get_class(auth()->user());
                        }
                        $homeFolder = config('filament-media-manager.model.folder')::create($data);
                    }

                    $collectionFolder = config('filament-media-manager.model.folder')::where('model_type', get_class($record))
                        ->where('model_id', null)
                        ->where('collection', $component->name)
                        ->first();
                    if (! $collectionFolder) {
                        $data = [
                            'collection' => $component->name,
                            'model_type' => get_class($record),
                            'name' => Str::of($component->name)->title()->toString(),
                        ];
                        if (filament('filament-media-manager')->allowUserAccess) {
                            $data['user_id'] = auth()->user()->id;
                            $data['user_type'] = get_class(auth()->user());
                        }
                        $collectionFolder = config('filament-media-manager.model.folder')::create($data);
                    }

                    $folder = config('filament-media-manager.model.folder')::where('collection', $component->name)
                        ->where('model_type', get_class($record))
                        ->where('model_id', $record->id)
                        ->first();

                    if (! $folder) {
                        $data = [
                            'collection' => $component->name,
                            'model_type' => get_class($record),
                            'model_id' => $record->id,
                            'name' => $component->folderTitleFieldName ? $record->{$component->folderTitleFieldName} : Str::of(get_class($record))->afterLast('\\')->title()->toString() . '[' . $record->id . ']',
                        ];

                        if (filament('filament-media-manager')->allowUserAccess) {
                            $data['user_id'] = auth()->user()->id;
                            $data['user_type'] = get_class(auth()->user());
                        }

                        $folder = config('filament-media-manager.model.folder')::create($data);
                    }

                    $file->delete();

                    // Increment counter for next media
                    $counter++;

                    // Return the media UUID
                    return $media->uuid;
                }, Arr::wrap($item['file'])));

                // Process each UUID returned from the upload
                foreach ($state as $uuid) {
                    if ($uuid) {
                        $getState[] = array_merge([
                            'file' => $uuid,
                        ], collect($item)->filter(fn ($value, $key) => $key !== 'file')->toArray());
                    }
                }
            }

            $component->state($getState);

        });

        $this->reorderAction(static function (Action $action): void {
            $action->action(function (array $arguments, Repeater $component): void {
                $items = [
                    ...array_flip($arguments['items']),
                    ...$component->getState(),
                ];
                $counter = 0;
                foreach ($items as $item) {
                    if (is_array($item) && isset($item['file']) && is_array($item['file']) && ! empty($item['file'])) {
                        $media = Media::where('uuid', array_keys($item['file'])[0])->first();
                        if ($media) {
                            $media->update([
                                'order_column' => $counter,
                            ]);
                        }
                    }
                    $counter++;
                }

                $component->state($items);

                $component->callAfterStateUpdated();
            });
        });

        $this->deleteAction(static function (Action $action): void {
            $action
                ->requiresConfirmation()
                ->action(function (array $arguments, Repeater $component) {
                    $items = $component->getState();
                    $media = Media::where('uuid', $items[$arguments['item']])->first();
                    if ($media) {
                        $media->delete();
                    }

                    unset($items[$arguments['item']]);

                    $component->state($items);

                    $component->callAfterStateUpdated();
                });
        });

        $this->loadStateFromRelationshipsUsing(static function (Repeater $component, HasMedia $record): void {
            $childComponents = $component->getChildComponents();
            /** @var FileInput|null $mediaComponent */
            $mediaComponent = ! empty($childComponents) ? $childComponents[0] : null;
            /** @var Model&HasMedia $record */
            $media = $record->load('media')->getMedia($component->name ?? 'default');

            if (! $mediaComponent) {
                return;
            }

            $state = [];
            foreach ($media as $item) {
                $url = null;

                if ($mediaComponent->getVisibility() === 'private') {
                    $conversion = $mediaComponent->getConversion();

                    try {
                        $url = $item?->getTemporaryUrl(
                            now()->addMinutes(5),
                            (filled($conversion) && $item->hasGeneratedConversion($conversion)) ? $conversion : '',
                        );
                    } catch (Throwable $exception) {
                        // This driver does not support creating temporary URLs.
                    }
                }

                if ($mediaComponent->getConversion() && $item?->hasGeneratedConversion($mediaComponent->getConversion())) {
                    $url ??= $item->getUrl($mediaComponent->getConversion());
                }

                $url ??= $item?->getUrl();

                $state[] = array_merge([
                    'file' => $item->uuid,
                ], $item->custom_properties);
            }
            $component->state($state);
        });
    }

    /**
     * @param  array<Component> | Closure  $components
     */
    public function schema(array | Closure $components): static
    {
        $this->childComponents(array_merge([
            FileInput::make('file')
                ->disk($this->diskName)
                ->required()
                ->storeFiles(false)
                ->collection($this->name),
        ], $components));

        return $this;
    }

    public function getDiskName(): string
    {
        if ($diskName = $this->evaluate($this->diskName)) {
            return $diskName;
        }

        /** @var Model&HasMedia $model */
        $model = $this->getModelInstance();

        $collection = $this->name ?? 'default';

        /** @phpstan-ignore-next-line */
        $diskNameFromRegisteredConversions = $model
            ->getRegisteredMediaCollections()
            ->filter(fn (MediaCollection $mediaCollection): bool => $mediaCollection->name === $collection)
            ->first()
            ?->diskName;

        return $diskNameFromRegisteredConversions ?? config('filament.default_filesystem_disk');
    }

    public function disk(string | Closure | null $name): static
    {
        $this->diskName = $name;

        return $this;
    }

    public function folderTitleFieldName(string | Closure | null $folderTitleFieldName): static
    {
        $this->folderTitleFieldName = $folderTitleFieldName;

        return $this;
    }

    public function single(bool $condition = true): static
    {
        $this->isSingle = $condition;

        if ($condition) {
            $this->minItems(1);
            $this->maxItems(1);
            $this->defaultItems(1);
            $this->reorderable(false);
            $this->addActionLabel(trans('filament-media-manager::messages.media.actions.create.label'));
        }

        return $this;
    }
}
</file>

<file path="resources/views/pages/media.blade.php">
@php
    $currentFolder = \TomatoPHP\FilamentMediaManager\Models\Folder::find($this->folder_id);
    if(filament('filament-media-manager')->allowSubFolders){
        $folders = \TomatoPHP\FilamentMediaManager\Models\Folder::query()
            ->where('model_type', \TomatoPHP\FilamentMediaManager\Models\Folder::class)
            ->where('model_id', $this->folder_id)
            ->get();
    }
    else {
        $folders = [];
    }

@endphp

<style>
    .media-grid {
        display: grid;
        grid-template-columns: repeat(2, minmax(0, 1fr));
        gap: 0.5rem;
        padding: 1rem;
        background-color: rgb(249 250 251);
        border-radius: 0.5rem;
    }

    .media-grid:where(.dark, .dark *) {
        background-color: transparent;
    }

    @media (min-width: 640px) {
        .media-grid {
            grid-template-columns: repeat(3, minmax(0, 1fr));
        }
    }

    @media (min-width: 768px) {
        .media-grid {
            grid-template-columns: repeat(4, minmax(0, 1fr));
        }
    }

    @media (min-width: 1024px) {
        .media-grid {
            grid-template-columns: repeat(6, minmax(0, 1fr));
        }
    }

    @media (min-width: 1280px) {
        .media-grid {
            grid-template-columns: repeat(8, minmax(0, 1fr));
        }
    }

    .media-trigger-slot {
        width: 100%;
        height: 100%;
    }

    .media-card {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        gap: 0.5rem;
        padding: 0.5rem;
        border-radius: 0.5rem;
        transition: background-color 0.15s ease;
    }

    .media-card:hover {
        background-color: rgb(249 250 251);
    }

    .media-card:hover:where(.dark, .dark *) {
        background-color: rgb(55 65 81 / 0.5);
    }

    .media-preview {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100px;
        height: 70px;
        position: relative;
        overflow: hidden;
        margin: 10px;
    }

    .media-preview-with-bg {
        border-radius: 5px;
        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        background-color: rgb(243 244 246);
    }

    .media-preview-with-bg:where(.dark, .dark *) {
        background-color: rgb(31 41 55);
    }

    .media-preview img {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 5px;
    }

    .media-preview video {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 5px;
    }

    .media-icon-large {
        width: 4rem;
        height: 4rem;
    }

    .media-file-icon {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        gap: 0.25rem;
        width: 100%;
        height: 100%;
    }

    .media-file-icon-image {
        width: 3.5rem;
        height: 3.5rem;
    }

    .media-file-extension {
        font-size: 0.625rem;
        font-weight: 600;
        text-transform: uppercase;
        color: rgb(107 114 128);
    }

    .media-file-extension:where(.dark, .dark *) {
        color: rgb(156 163 175);
    }

    .media-info {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
    }

    .media-title {
        font-weight: 600;
        font-size: 0.875rem;
        line-height: 1.25rem;
        text-align: center;
        max-width: 120px;
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
        color: rgb(17 24 39);
    }

    .media-title:where(.dark, .dark *) {
        color: rgb(249 250 251);
    }

    .media-subtitle {
        font-weight: 700;
        color: rgb(17 24 39);
    }

    .media-subtitle:where(.dark, .dark *) {
        color: rgb(249 250 251);
    }

    .flex-start {
        display: flex;
        justify-content: flex-start;
    }

    .media-text-sm {
        font-size: 0.875rem;
        line-height: 1.25rem;
        color: rgb(55 65 81);
    }

    .media-text-sm:where(.dark, .dark *) {
        color: rgb(209 213 219);
    }

    .media-timestamp {
        color: rgb(107 114 128);
        font-size: 0.75rem;
        line-height: 1rem;
        text-align: center;
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
    }

    .media-timestamp:where(.dark, .dark *) {
        color: rgb(156 163 175);
    }

    .media-image-preview {
        width: 100%;
        height: 100%;
        object-fit: cover;
        border-radius: 5px;
    }

    .media-modal-content {
        display: flex;
        flex-direction: column;
        justify-content: flex-start;
        width: 100%;
        height: 100%;
    }

    .media-preview-link {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        padding: 2rem;
        min-height: 400px;
        border: 1px solid rgb(229 231 235);
        border-radius: 0.5rem;
        background-color: rgb(255 255 255);
        overflow: hidden;
        cursor: zoom-in;
        transition: background-color 0.15s ease;
    }

    .media-preview-link:where(.dark, .dark *) {
        border-color: rgb(55 65 81);
        background-color: rgb(17 24 39);
    }

    .media-preview-link:hover {
        background-color: rgb(249 250 251);
    }

    .media-preview-link:hover:where(.dark, .dark *) {
        background-color: rgb(55 65 81 / 0.5);
    }

    .media-preview-link img {
        max-width: 100%;
        max-height: 70vh;
        width: auto;
        height: auto;
        object-fit: contain;
        border-radius: 0.375rem;
    }

    .media-video-full {
        width: 100%;
        max-height: 70vh;
        border-radius: 0.375rem;
    }

    .media-file-preview-icon {
        display: flex;
        flex-direction: column;
        align-items: center;
        gap: 0.5rem;
    }

    .media-file-preview-icon-large {
        width: 8rem;
        height: 8rem;
    }

    .fullscreen-modal {
        position: fixed;
        inset: 0;
        z-index: 99999;
        background-color: rgba(0, 0, 0, 0.95);
        display: flex;
        align-items: center;
        justify-content: center;
        padding: 2rem;
    }

    .fullscreen-close-btn {
        position: absolute;
        top: 1rem;
        right: 1rem;
        color: white;
        background: rgba(0, 0, 0, 0.75);
        border-radius: 0.5rem;
        padding: 0.75rem;
        cursor: pointer;
        border: 1px solid rgba(255, 255, 255, 0.2);
        transition: all 0.2s ease;
    }

    .fullscreen-close-btn:hover {
        background: rgba(0, 0, 0, 0.9);
        border-color: rgba(255, 255, 255, 0.4);
    }

    .meta-section {
        display: flex;
        flex-direction: column;
        gap: 1rem;
        margin-top: 1rem;
        margin-bottom: 1rem;
        padding: 1rem;
        background-color: rgb(243 244 246);
        border-radius: 0.5rem;
        border: 1px solid rgb(229 231 235);
    }

    .meta-section:where(.dark, .dark *) {
        background-color: rgb(31 41 55);
        border-color: rgb(55 65 81);
    }

    .empty-state-container {
        padding: 3rem 1.5rem;
    }

    .empty-state-content {
        margin-left: auto;
        margin-right: auto;
        display: grid;
        max-width: 32rem;
        justify-items: center;
        text-align: center;
    }

    .empty-state-icon-container {
        margin-bottom: 1rem;
        border-radius: 9999px;
        background-color: rgb(229 231 235);
        padding: 0.75rem;
    }

    .empty-state-icon-container:where(.dark, .dark *) {
        background-color: rgb(107 114 128 / 0.2);
    }

    .empty-state-icon {
        height: 1.5rem;
        width: 1.5rem;
        color: rgb(75 85 99);
    }

    .empty-state-icon:where(.dark, .dark *) {
        color: rgb(156 163 175);
    }

    .empty-state-heading {
        font-size: 1.125rem;
        line-height: 1.75rem;
        font-weight: 600;
        color: rgb(17 24 39);
        margin: 0;
    }

    .empty-state-heading:where(.dark, .dark *) {
        color: rgb(249 250 251);
    }
</style>

@if(isset($records) || count($folders) > 0)
<div class="media-grid">
    @if(isset($records))
        @foreach($records as $item)
            @if($item instanceof \TomatoPHP\FilamentMediaManager\Models\Folder)
                @livewire(\TomatoPHP\FilamentMediaManager\Livewire\FolderComponent::class, ['item' => $item], key('folder-' . $item->id))
            @else
                <x-filament::modal  width="3xl" slide-over>
                <x-slot name="trigger" class="media-trigger-slot">
                    <div class="media-card">
                        @php
                            $extension = strtolower(pathinfo($item->file_name, PATHINFO_EXTENSION));
                            $title = $item->hasCustomProperty('title') ? (!empty($item->getCustomProperty('title')) ? $item->getCustomProperty('title') : $item->name) : $item->name;

                            // File type icon mapping
                            $fileIcons = [
                                // Documents
                                'pdf' => ['icon' => 'heroicon-o-document-text', 'color' => '#ef4444'],
                                'doc' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
                                'docx' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
                                'odt' => ['icon' => 'heroicon-o-document-text', 'color' => '#3b82f6'],
                                'rtf' => ['icon' => 'heroicon-o-document-text', 'color' => '#6b7280'],
                                'txt' => ['icon' => 'heroicon-o-document', 'color' => '#6b7280'],
                                'md' => ['icon' => 'heroicon-o-document', 'color' => '#6b7280'],

                                // Spreadsheets
                                'xls' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
                                'xlsx' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
                                'ods' => ['icon' => 'heroicon-o-table-cells', 'color' => '#22c55e'],
                                'csv' => ['icon' => 'heroicon-o-table-cells', 'color' => '#10b981'],

                                // Presentations
                                'ppt' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
                                'pptx' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],
                                'odp' => ['icon' => 'heroicon-o-presentation-chart-bar', 'color' => '#f97316'],

                                // Archives
                                'zip' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                'rar' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                '7z' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                'tar' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],
                                'gz' => ['icon' => 'heroicon-o-archive-box', 'color' => '#eab308'],

                                // Code files
                                'json' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
                                'xml' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
                                'html' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
                                'css' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                'js' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#eab308'],
                                'ts' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
                                'jsx' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                'tsx' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                'php' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#8b5cf6'],
                                'py' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
                                'rb' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#ef4444'],
                                'java' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
                                'cpp' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                'c' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#3b82f6'],
                                'go' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#06b6d4'],
                                'rust' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],
                                'swift' => ['icon' => 'heroicon-o-code-bracket', 'color' => '#f97316'],

                                // Images (vector)
                                'svg' => ['icon' => 'heroicon-o-photo', 'color' => '#f59e0b'],
                                'eps' => ['icon' => 'heroicon-o-photo', 'color' => '#8b5cf6'],
                                'ai' => ['icon' => 'heroicon-o-photo', 'color' => '#f97316'],

                                // Others
                                'psd' => ['icon' => 'heroicon-o-photo', 'color' => '#3b82f6'],
                                'sketch' => ['icon' => 'heroicon-o-photo', 'color' => '#f59e0b'],
                                'fig' => ['icon' => 'heroicon-o-photo', 'color' => '#ec4899'],
                            ];

                            $fileIcon = $fileIcons[$extension] ?? ['icon' => 'heroicon-o-document', 'color' => '#9ca3af'];
                        @endphp

                        <div class="media-preview {{ str($item->mime_type)->contains(['image', 'video']) ? 'media-preview-with-bg' : '' }}"
                             x-data>
                            @if(str($item->mime_type)->contains('image'))
                                <img src="{{ $item->getUrl() }}" alt="{{ $title }}" />
                            @elseif(str($item->mime_type)->contains('video'))
                                <video src="{{ $item->getUrl() }}"></video>
                            @elseif(str($item->mime_type)->contains('audio'))
                                <x-filament::icon name="heroicon-o-musical-note" class="media-icon-large" style="color: #ec4899;" />
                            @else
                                @php
                                    $hasPreview = false;
                                    $loadTypes = \TomatoPHP\FilamentMediaManager\Facade\FilamentMediaManager::getTypes();
                                    $type = null;
                                    foreach ($loadTypes as $getType) {
                                        if(str($item->file_name)->contains($getType->exstantion)){
                                            $hasPreview = $getType->preview;
                                            $type = $getType;
                                        }
                                    }
                                @endphp
                                @if($hasPreview && $type)
                                    <x-filament::icon :name="$type->icon" class="media-icon-large" style="color: {{ $fileIcon['color'] ?? '#9ca3af' }};" />
                                @else
                                    <div class="media-file-icon">
                                        <x-filament::icon :name="$fileIcon['icon']" class="media-file-icon-image" style="color: {{ $fileIcon['color'] }};" />
                                        <span class="media-file-extension">{{ $extension }}</span>
                                    </div>
                                @endif
                            @endif
                        </div>

                        <div class="media-info">
                            <h1 class="media-title"
                                x-data
                                x-tooltip="{
                                    content: '{{ addslashes($title) }}',
                                    theme: $root.closest('.dark') ? 'dark' : 'light',
                                }">
                                {{ $title }}
                            </h1>
                            <p class="media-timestamp">
                                {{ $item->created_at->diffForHumans() }}
                            </p>
                        </div>
                    </div>
                </x-slot>

                <x-slot name="heading">
                    {{ $item->uuid }}
                </x-slot>

                <x-slot name="description">
                    {{ $item->file_name }}
                </x-slot>

                <div>
                    <div class="media-modal-content">

                        @if(str($item->mime_type)->contains('image'))
                            <div class="media-preview-link" x-data="{ fullscreen: false }">
                                <img src="{{ $item->getUrl() }}" alt="{{ $title }}" @click="fullscreen = true" style="cursor: zoom-in;" />

                                <!-- Fullscreen Image Modal -->
                                <div x-show="fullscreen"
                                     x-transition.opacity
                                     @click="fullscreen = false"
                                     @keydown.escape.window="fullscreen = false"
                                     class="fullscreen-modal"
                                     x-cloak
                                     style="display: none;"
                                     x-bind:style="fullscreen && 'display: flex !important;'">
                                    <img src="{{ $item->getUrl() }}"
                                         alt="{{ $title }}"
                                         style="max-width: 95%; max-height: 95vh; object-fit: contain; cursor: zoom-out;"
                                         @click.stop />
                                    <button @click="fullscreen = false" class="fullscreen-close-btn">
                                        <x-filament::icon name="heroicon-o-x-mark" style="width: 1.5rem; height: 1.5rem;" />
                                    </button>
                                </div>
                            </div>

                        @elseif(str($item->mime_type)->contains('video'))
                            <div class="media-preview-link">
                                <video class="media-video-full" controls>
                                    <source src="{{ $item->getUrl() }}" type="{{ $item->mime_type }}">
                                </video>
                            </div>

                        @elseif(str($item->mime_type)->contains('audio'))
                            <div class="media-preview-link">
                                <div class="media-file-preview-icon">
                                    <x-filament::icon name="heroicon-o-musical-note" class="media-file-preview-icon-large" style="color: #ec4899;" />
                                </div>
                                <audio class="media-video-full" controls style="width: 100%; margin-top: 1rem;">
                                    <source src="{{ $item->getUrl() }}" type="{{ $item->mime_type }}">
                                </audio>
                            </div>
                        @else
                            @php
                                $hasPreview = false;
                                $loadTypes = \TomatoPHP\FilamentMediaManager\Facade\FilamentMediaManager::getTypes();
                                $previewType = null;
                                foreach ($loadTypes as $type) {
                                    if(str($item->file_name)->contains($type->exstantion)){
                                        $hasPreview = $type->preview;
                                        $previewType = $type;
                                    }
                                }
                            @endphp
                            @if($hasPreview)
                                @include($hasPreview, ['media' => $item])
                            @else
                                <a href="{{ $item->getUrl() }}" target="_blank" class="media-preview-link">
                                    <div class="media-file-preview-icon">
                                        <x-filament::icon :name="$fileIcon['icon']" class="media-file-preview-icon-large" style="color: {{ $fileIcon['color'] }};" />
                                        <span style="font-size: 1rem; font-weight: 600; text-transform: uppercase; color: {{ $fileIcon['color'] }};">{{ $extension }}</span>
                                        <span style="font-size: 0.875rem; color: rgb(107 114 128); margin-top: 0.5rem;">Click to download</span>
                                    </div>
                                </a>
                            @endif
                        @endif
                        <div class="meta-section">
                            @if($item->model)
                            <div>
                                <div>
                                    <h1 class="media-subtitle">{{ trans('filament-media-manager::messages.media.meta.model') }}</h1>
                                </div>
                                <div class="flex-start">
                                    <p class="media-text-sm">
                                      {{str($item->model_type)->afterLast('\\')->title()}}[ID:{{ $item->model?->id }}]
                                    </p>
                                </div>
                            </div>
                            @endif
                            <div>
                                <div>
                                    <h1 class="media-subtitle">{{ trans('filament-media-manager::messages.media.meta.file-name') }}</h1>
                                </div>
                                <div class="flex-start">
                                    <p class="media-text-sm">
                                        {{ $item->file_name }}
                                    </p>
                                </div>
                            </div>
                            <div>
                                <div>
                                    <h1 class="media-subtitle">{{ trans('filament-media-manager::messages.media.meta.type') }}</h1>
                                </div>
                                <div class="flex-start">
                                    <p class="media-text-sm">
                                        {{ $item->mime_type }}
                                    </p>
                                </div>
                            </div>
                            <div>
                                <div>
                                    <h1 class="media-subtitle">{{ trans('filament-media-manager::messages.media.meta.size') }}</h1>
                                </div>
                                <div class="flex-start">
                                    <p class="media-text-sm">
                                        {{ $item->humanReadableSize }}
                                    </p>
                                </div>
                            </div>
                            <div>
                                <div>
                                    <h1 class="media-subtitle">{{ trans('filament-media-manager::messages.media.meta.disk') }}</h1>
                                </div>
                                <div class="flex-start">
                                    <p class="media-text-sm">
                                        {{ $item->disk  }}
                                    </p>
                                </div>
                            </div>
                            @if($item->custom_properties)
                                @foreach($item->custom_properties as $key=>$value)
                                    @if($value)
                                        <div>
                                            <div>
                                                <h1 class="media-subtitle">{{str($key)->title()}}</h1>
                                            </div>
                                            <div class="flex-start">
                                                <p class="media-text-sm">
                                                    {{ $value }}
                                                </p>
                                            </div>
                                        </div>
                                    @endif
                                @endforeach
                            @endif
                        </div>
                    </div>
                </div>

                    @if(filament('filament-media-manager')->allowUserAccess && (!empty($currentFolder->user_id)))
                        @if($currentFolder->user_id === auth()->user()->id && $currentFolder->user_type === get_class(auth()->user()))
                            <x-slot name="footer">
                                {{ ($this->editMedia)(['record' => $item]) }}
                                {{ ($this->deleteMedia)(['record' => $item]) }}
                            </x-slot>
                        @endif
                    @else
                        <x-slot name="footer">
                            {{ ($this->editMedia)(['record' => $item]) }}
                            {{ ($this->deleteMedia)(['record' => $item]) }}
                        </x-slot>
                    @endif

            </x-filament::modal>
            @endif
        @endforeach
    @endif
    @if(filament('filament-media-manager')->allowSubFolders)
        @foreach($folders as $folder)
            @livewire(\TomatoPHP\FilamentMediaManager\Livewire\FolderComponent::class, ['item' => $folder], key('folder-' . $folder->id))
        @endforeach
    @endif
</div>
@else
    <div class="empty-state-container">
        <div class="empty-state-content">
            <div class="empty-state-icon-container">
                <x-filament::icon
                    icon="heroicon-o-x-mark"
                    class="empty-state-icon"
                />
            </div>

            <h3 class="empty-state-heading">
                {{ trans('filament-media-manager::messages.empty.title') }}
            </h3>
        </div>
    </div>
@endif
</file>

<file path="README.md">
![Screenshot](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/fadymondy-tomato-media-manager.jpg)

# Filament media manager

[![Latest Stable Version](https://poser.pugx.org/tomatophp/filament-media-manager/version.svg)](https://packagist.org/packages/tomatophp/filament-media-manager)
[![License](https://poser.pugx.org/tomatophp/filament-media-manager/license.svg)](https://packagist.org/packages/tomatophp/filament-media-manager)
[![Downloads](https://poser.pugx.org/tomatophp/filament-media-manager/d/total.svg)](https://packagist.org/packages/tomatophp/filament-media-manager)
[![Dependabot Updates](https://github.com/tomatophp/filament-media-manager/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/tomatophp/filament-media-manager/actions/workflows/dependabot/dependabot-updates)
[![PHP Code Styling](https://github.com/tomatophp/filament-media-manager/actions/workflows/fix-php-code-styling.yml/badge.svg)](https://github.com/tomatophp/filament-media-manager/actions/workflows/fix-php-code-styling.yml)
[![Tests](https://github.com/tomatophp/filament-media-manager/actions/workflows/tests.yml/badge.svg)](https://github.com/tomatophp/filament-media-manager/actions/workflows/tests.yml)

Manage your media files using spatie media library with easy to use GUI for FilamentPHP

## Installation

```bash
composer require tomatophp/filament-media-manager
```

now you need to publish media migration 

```bash
php artisan vendor:publish --provider="Spatie\MediaLibrary\MediaLibraryServiceProvider" --tag="medialibrary-migrations"
```

after installing your package, please run this command

```bash
php artisan filament-media-manager:install
```

finally, register the plugin on `/app/Providers/Filament/AdminPanelProvider.php`, if you like to use GUI and Folder Browser.

```php
->plugin(
    \TomatoPHP\FilamentMediaManager\FilamentMediaManagerPlugin::make()
        ->allowSubFolders()
        ->navigationGroup()
        ->navigationIcon()
        ->navigationLabel()
)
```

## Features

- 📁 Manage your media files using spatie media library
- 📂 Create folders and subfolders
- 🔒 Set password for folders with secure access
- 📝 Upload Files with Custom Fields using `->schema()`
- 🤖 Auto Create Folders for Model/Collection/Record
- 🌍 RTL/Multi Language Support
- 🎨 Full Dark Mode Support
- 🖼️ MediaManagerPicker - Browse and select media from folder structure
- ⚡ MediaManagerInput - Direct file upload with Spatie Media Library
- 🔧 InteractsWithMediaManager Trait - Easy model integration
- 📊 Live Preview with thumbnails and file information
- ✅ Selection validation (min/max items)
- 🔄 Auto-save and modal management
- 🏷️ Collection Names - Multiple pickers on same page with separate collections
- 📱 Responsive Images - Automatic responsive image generation with Spatie
- 🎯 Drag & Drop Reordering - Visual reordering of selected media

## Screenshots

![Folders](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/folders.png)
![Folder Password](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/folder-password.png)
![Media](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media.png)
![Add Media](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/add-media.png)
![Add Sub Folder](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/create-sub-folder.png)
![Preview File](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/preview-file.png)
![Preview Images](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/preview-image.png)
![Edit Media](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/edit-media-meta.png)
![Media Inputs](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-input.png)
![Media Picker Empty State](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-empty.png)
![Media Picker Selected Files](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-selected.png)
![Media Picker Browser](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-browser.png)
![Media Picker After Select](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-after-select.png)
![Media Picker Folders](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-folder.png)
![Media Picker Password Folders](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-password.png)
![Media Picker Selected Files](https://raw.githubusercontent.com/tomatophp/filament-media-manager/master/arts/media-picker-selected-files.png)

## Usage

you can use the media manager by adding this code to your filament component

```php
use TomatoPHP\FilamentMediaManager\Form\MediaManagerInput;

public function form(Schema $schema): Schema
{
    return $schema->components([
        MediaManagerInput::make('images')
            ->disk('public')
            ->schema([
                Forms\Components\TextInput::make('title')
                    ->required()
                    ->maxLength(255),
                Forms\Components\TextInput::make('description')
                    ->required()
                    ->maxLength(255),
            ]),
    ]);
}

```

or you can use Media Library Picker like this

```php
use TomatoPHP\FilamentMediaManager\Form\MediaManagerPicker;

public function form(Schema $schema): Schema
{
    return $schema->components([
         MediaManagerPicker::make('media')
          ->multiple() // or ->single() (default is multiple)
          ->maxItems(5) // Maximum number of items that can be selected
          ->minItems(2) // Minimum number of items required
          ->collection('products') // Separate collection for this picker
          ->responsiveImages() // Enable responsive images generation
    ]);
}

```

and on your model to manage your attached media 

```php
use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaManager;

class Model extends Authenticatable {
    use InteractsWithMediaManager;
} 
```

### MediaManagerPicker Features

- **Multiple/Single Selection**: Use `->multiple()` or `->single()` to control selection mode
- **Item Limits**: Set `->maxItems(n)` and `->minItems(n)` to enforce selection constraints
- **Collection Names**: Use `->collection('name')` to separate media for different pickers on the same page
- **Responsive Images**: Use `->responsiveImages()` to automatically generate responsive images with Spatie
- **Drag & Drop Reordering**: Visually reorder selected media items with drag handles
- **Password Protected Folders**: Browse secure folders with password verification
- **Live Preview**: See selected items with preview thumbnails, file info, and remove buttons
- **Dark Mode Support**: Fully styled for both light and dark themes
- **Auto-close Modal**: Modal automatically closes after selection with success notification

### Multiple Pickers with Collections

You can use multiple MediaManagerPicker components on the same page by using collection names:

```php
use TomatoPHP\FilamentMediaManager\Form\MediaManagerPicker;

public function form(Schema $schema): Schema
{
    return $schema->components([
        // Featured image picker
        MediaManagerPicker::make('featured_image')
            ->collection('featured')
            ->single()
            ->label('Featured Image'),

        // Gallery picker
        MediaManagerPicker::make('gallery_images')
            ->collection('gallery')
            ->multiple()
            ->maxItems(10)
            ->label('Gallery'),

        // Attachments picker with responsive images
        MediaManagerPicker::make('hero_image')
            ->collection('hero')
            ->single()
            ->responsiveImages()
            ->label('Hero Image'),
    ]);
}
```

Each picker maintains its own separate media attachments based on the collection name.

## Working with Media in Models

### InteractsWithMediaManager Trait

Use the `InteractsWithMediaManager` trait in your models to easily access and manage media attached via MediaManagerPicker:

```php
use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaManager;

class Product extends Model
{
    use InteractsWithMediaManager;
}
```

#### Available Methods

```php
// Get all media attached via MediaManagerPicker
$product->getMediaManagerMedia(); // All media
$product->getMediaManagerMedia('featured'); // From specific collection

// Get media by UUIDs
$product->getMediaManagerMediaByUuids(['uuid-1', 'uuid-2']);

// Get media from Spatie collection (MediaManagerInput)
$product->getMediaManagerInputMedia('images');

// Attach media programmatically
$product->attachMediaManagerMedia(['uuid-1', 'uuid-2']); // To default collection
$product->attachMediaManagerMedia(['uuid-1', 'uuid-2'], 'gallery'); // To specific collection

// Detach media
$product->detachMediaManagerMedia(['uuid-1']); // Detach specific from default
$product->detachMediaManagerMedia(['uuid-1'], 'gallery'); // From specific collection
$product->detachMediaManagerMedia(null, 'gallery'); // Detach all from collection

// Sync media (replace all with new)
$product->syncMediaManagerMedia(['uuid-3', 'uuid-4']); // Default collection
$product->syncMediaManagerMedia(['uuid-3', 'uuid-4'], 'gallery'); // Specific collection

// Check if media exists
$product->hasMediaManagerMedia('uuid-1'); // In default collection
$product->hasMediaManagerMedia('uuid-1', 'featured'); // In specific collection

// Get first media item
$product->getFirstMediaManagerMedia(); // From default
$product->getFirstMediaManagerMedia('featured'); // From collection

// Get media URL
$product->getMediaManagerUrl(); // First from default collection
$product->getMediaManagerUrl('featured'); // First from featured collection

// Get all media URLs
$product->getMediaManagerUrls(); // All from default
$product->getMediaManagerUrls('gallery'); // All from gallery collection

// Responsive Images Methods
$product->getMediaManagerResponsiveImages('hero'); // Get responsive data
$product->getMediaManagerSrcset('hero'); // Get srcset for first media
$product->getMediaManagerSrcsets('gallery'); // Get all srcsets
$product->getMediaManagerResponsiveUrls('hero'); // Get responsive URLs for first
$product->getAllMediaManagerResponsiveUrls('gallery'); // Get all responsive URLs
```

#### Usage Examples

```php
// In your blade template - Basic usage
@php
    $product = App\Models\Product::find(1);
    $images = $product->getMediaManagerMedia('gallery');
@endphp

<div class="product-gallery">
    @foreach($images as $image)
        <img src="{{ $image->getUrl('thumb') }}" alt="{{ $image->name }}">
    @endforeach
</div>

// Get featured image from specific collection
@php
    $featuredUrl = $product->getMediaManagerUrl('featured') ?? '/default-image.png';
@endphp

<img src="{{ $featuredUrl }}" alt="Featured Image">

// Responsive Images with srcset
@php
    $heroSrcset = $product->getMediaManagerSrcset('hero');
    $heroUrl = $product->getMediaManagerUrl('hero');
@endphp

<img src="{{ $heroUrl }}"
     srcset="{{ $heroSrcset }}"
     sizes="(max-width: 768px) 100vw, 50vw"
     alt="Hero Image">

// Gallery with responsive images
@foreach($product->getMediaManagerResponsiveImages('gallery') as $item)
    <img src="{{ $item['url'] }}"
         srcset="{{ $item['srcset'] }}"
         alt="Gallery Image">
@endforeach

// Get user avatar from specific collection
@php
    $avatarUrl = auth()->user()->getMediaManagerUrl('avatar') ?? '/default-avatar.png';
@endphp

<img src="{{ $avatarUrl }}" alt="User Avatar">
```

For complete documentation of the trait, see [TRAITS.md](./docs/TRAITS.md).

## Important: Run Migrations

After installing or updating the package, make sure to run migrations to add the required database columns:

```bash
php artisan migrate
```

This will add the following columns to the `media_has_models` table:
- `order_column` - For drag & drop reordering functionality
- `collection_name` - For multiple pickers with separate collections
- `responsive_images` - For responsive images support

## Add Custom Preview to selected type on the media manager

you can add custom preview to selected type on the media manager by add this code to your provider

```php
use TomatoPHP\FilamentMediaManager\Facade\FilamentMediaManager;
use TomatoPHP\FilamentMediaManager\Services\Contracts\MediaManagerType;


public function boot() {
     FilamentMediaManager::register([
        MediaManagerType::make('.pdf')
            ->icon('bxs-file-pdf')
            ->preview('media-manager.pdf'),
    ]);
}
```

in your view file you can use it like this 

```php
<div class="m-4">
    <canvas id="the-canvas"></canvas>
</div>

<script src="//mozilla.github.io/pdf.js/build/pdf.mjs" type="module"></script>

<style type="text/css">
    #the-canvas {
        border: 1px solid black;
        direction: ltr;
    }
</style>
<script type="module">
    // If absolute URL from the remote server is provided, configure the CORS
    // header on that server.
    var url = "{{ $media->getUrl() }}";

    // Loaded via <script> tag, create shortcut to access PDF.js exports.
    var { pdfjsLib } = globalThis;

    // The workerSrc property shall be specified.
    pdfjsLib.GlobalWorkerOptions.workerSrc = '//mozilla.github.io/pdf.js/build/pdf.worker.mjs';

    // Asynchronous download of PDF
    var loadingTask = pdfjsLib.getDocument(url);
    loadingTask.promise.then(function(pdf) {

        // Fetch the first page
        var pageNumber = 1;
        pdf.getPage(pageNumber).then(function(page) {
            var scale = 1;
            var viewport = page.getViewport({scale: scale});

            // Prepare canvas using PDF page dimensions
            var canvas = document.getElementById('the-canvas');
            var context = canvas.getContext('2d');
            canvas.height = viewport.height;
            canvas.width = viewport.width;

            // Render PDF page into canvas context
            var renderContext = {
                canvasContext: context,
                viewport: viewport
            };
            var renderTask = page.render(renderContext);
        });
    }, function (reason) {
        // PDF loading error
        console.error(reason);
    });
</script>
```

you can attach global `js` or `css` file to the media manager by add this code to your provider

```php
use TomatoPHP\FilamentMediaManager\Facade\FilamentMediaManager;
use TomatoPHP\FilamentMediaManager\Services\Contracts\MediaManagerType;


public function boot() {
     FilamentMediaManager::register([
        MediaManagerType::make('.pdf')
            ->js('https://mozilla.github.io/pdf.js/build/pdf.mjs'),
            ->css('https://cdnjs.cloudflare.com/ajax/libs/pdf.js/4.3.136/pdf_viewer.min.css'),
            ->icon('bxs-file-pdf')
            ->preview('media-manager.pdf'),
    ]);
}
```

please note that the `name ` of the component will be the same name of the collection.

## Allow Sub Folders

you can allow create and manage subfolders on your media manager on `/app/Providers/Filament/AdminPanelProvider.php`

```php
->plugins([
    \TomatoPHP\FilamentMediaManager\FilamentMediaManagerPlugin::make()
        ->allowSubFolders()
])
```

## Allow User Access

now you can allow user to access selected folder and restract user to access each other folders if the folder is not public on `/app/Providers/Filament/AdminPanelProvider.php`

```php
->plugin(
    \TomatoPHP\FilamentMediaManager\FilamentMediaManagerPlugin::make()
        ->allowUserAccess()
)
```

now on your user model you can use this trait to allow user to access selected folder

```php

use TomatoPHP\FilamentMediaManager\Traits\InteractsWithMediaFolders;

class User extends Authenticatable
{
    use InteractsWithMediaFolders;
}
```

**NOTE** don't forget to migrate after update the plugin

## Folders API

now you can access your media and folders using API you have 2 endpoints

- `/api/folders` to get all folders
- `/api/folders/{id}` to get folder by id with sub folders and media files

to allow this feature, you need to publish the config file by use this command

```bash
php artisan vendor:publish --tag="filament-media-manager-config"
```

then you can set `api.active` to `true` on the config file

```php
'api' => [
    "active" => true,
],
```

## Publish Assets

you can publish config file by use this command

```bash
php artisan vendor:publish --tag="filament-media-manager-config"
```

you can publish a view file by using this command

```bash
php artisan vendor:publish --tag="filament-media-manager-views"
```

you can publish a language file by using this command

```bash
php artisan vendor:publish --tag="filament-media-manager-lang"
```

you can publish the migrations file by using this command

```bash
php artisan vendor:publish --tag="filament-media-manager-migrations"
```
## Testing

This package includes comprehensive test suites for all major features. Tests are written using [Pest PHP](https://pestphp.com/).

### Running Tests

Run all tests:
```bash
composer test
```

Run a specific test file:
```bash
./vendor/bin/pest tests/src/MediaManagerPickerTest.php
```

Run with coverage:
```bash
./vendor/bin/pest --coverage
```

### Test Coverage

The test suite includes:

- **MediaManagerPickerTest** - Tests for MediaManagerPicker component, folder navigation, password protection, selection validation, and file upload
- **MediaManagerInputTest** - Tests for MediaManagerInput component, file upload, media retrieval, deletion, and custom schema
- **InteractsWithMediaManagerTest** - Tests for the trait methods including attach, detach, sync, and URL generation

For detailed testing documentation, see [tests/README.md](./tests/README.md)

## Code Style

if you like to fix the code style, just use this command

```bash
composer format
```

## PHPStan

if you like to check the code by `PHPStan` just use this command

```bash
composer analyse
```

## Other Filament Packages

Check out our [Awesome TomatoPHP](https://github.com/tomatophp/awesome)
</file>

</files>