<?php

use App\Livewire\Dashboard\Index as DashboardIndex;

/* API Logs */
use App\Livewire\ApiLogs\Index as ApiLogsIndex;

/* Monitorización */
use App\Livewire\Monitoring\{
    Index as MonitoringIndex,
    Traffic as MonitoringTraffic,
    Expirations as MonitoringExpirations,
    Notices as MonitoringNotices,
    Tamano as MonitoringTamano,
    SystemLog as MonitoringSystemLog,
};

/* Clientes */
use App\Livewire\Clients\{
    Index as ClientsIndex,
    Create as ClientsCreate,
    Edit as ClientsEdit,
    Show as ClientsShow,
};

/* Licencias */
use App\Livewire\LicenseTokens\{
    Index as LicenseTokensIndex,
    Edit as LicenseTokensEdit,
    Show as LicenseTokensShow,
    ManageEnvironments as LicenseTokensManageEnvironments,
    AssociateLicense as LicenseTokensAssociateLicense,
    CreateWizard as LicenseTokensCreateWizard,
};

/* Entornos */
use App\Livewire\Environments\{
    Index as EnvironmentsIndex,
    Show as EnvironmentsShow,
    Edit as EnvironmentsEdit,
    CreateWizard as EnvironmentsCreateWizard,
    CreateFromClient as EnvironmentsCreateFromClient,
};
use App\Livewire\Environments\Components\Success as EnvironmentsSuccess;
use App\Livewire\Environments\Plugins\Index as EnvironmentPluginsIndex;
use App\Livewire\Environments\Uso as EnvironmentUso;
use App\Livewire\Environments\Supports\Index as EnvironmentSupportsIndex;

/* Soportes */
use App\Livewire\Supports\{
    Index as SupportsIndex,
    Create as SupportsCreate,
    Edit as SupportsEdit,
};

/* Productos */
use App\Livewire\Products\{
    Index as ProductsIndex,
    Create as ProductsCreate,
    Edit as ProductsEdit,
    Show as ProductsShow,
};

/* Plugins (vista global) */
use App\Livewire\Plugins\Core as PluginsCore;
use App\Livewire\Plugins\Index as GlobalPluginsIndex;
use App\Livewire\Plugins\Inventario as PluginsInventario;
use App\Livewire\Plugins\Nuestros as PluginsNuestros;
use App\Livewire\Plugins\SinInstalar as PluginsSinInstalar;

/* Usuarios */
use App\Livewire\Users\{
    Index as UsersIndex,
    Create as UsersCreate,
    Edit as UsersEdit,
};

/* Setups */
use App\Livewire\Setups\{
    Index as SetupsIndex,
    Create as SetupsCreate,
    Edit as SetupsEdit,
    Show as SetupsShow,
};

/* Features */
use App\Livewire\Features\{
    Index as FeaturesIndex,
    Create as FeaturesCreate,
    Edit as FeaturesEdit,
    VersionShow as FeaturesVersionShow,
    VersionCreate as FeaturesVersionCreate,
    VersionEdit as FeaturesVersionEdit,
};

/* Tutoriales */
use App\Livewire\Tutorials\{
    Index as TutorialsIndex,
    Create as TutorialsCreate,
    Edit as TutorialsEdit,
    VersionShow as TutorialsVersionShow,
    VersionCreate as TutorialsVersionCreate,
    VersionEdit as TutorialsVersionEdit,
};

/* Recursos */
use App\Livewire\Resources\{
    Index as ResourcesIndex,
    Create as ResourcesCreate,
    Edit as ResourcesEdit,
    VersionShow as ResourcesVersionShow,
    VersionCreate as ResourcesVersionCreate,
    VersionEdit as ResourcesVersionEdit,
};

/* SCSS */
use App\Livewire\Scss\{
    Index as ScssIndex,
    Create as ScssCreate,
    Edit as ScssEdit,
    Show as ScssShow,
    VersionShow as ScssVersionShow,
    VersionEdit as ScssVersionEdit,
    FileUpload as ScssFileUpload,
};

/* JS */
use App\Livewire\Js\{
    Index as JsIndex,
    Create as JsCreate,
    Edit as JsEdit,
    Show as JsShow,
    VersionShow as JsVersionShow,
    VersionEdit as JsVersionEdit,
    FileUpload as JsFileUpload,
};

/* SCSS CDN */
use App\Livewire\ScssCdn\{
    Index as ScssCdnIndex,
    BundleCreate as ScssCdnBundleCreate,
    BundleEdit as ScssCdnBundleEdit,
    BundleShow as ScssCdnBundleShow,
    ZipUpload as ScssCdnZipUpload,
    FileEdit as ScssCdnFileEdit,
};

/* CONFIGURACIONES ENVIRONMENTS  */
use App\Livewire\Configurations\Environments\{
    Index as ConfigurationsEnvironmentsTypesIndex,
    Create as ConfigurationsEnvironmentsTypesCreate,
    Edit as ConfigurationsEnvironmentsTypesEdit,
};

/* CONFIGURACIONES USOS DEL ENTORNO (pro, pre, develop, local) */
use App\Livewire\Configurations\Envs\{
    Create as ConfigurationsEnvsCreate,
    Edit as ConfigurationsEnvsEdit,
};

/* CONFIGURACIONES ROLES */
use App\Livewire\Configurations\Access as ConfigurationsAccess;
use App\Livewire\Configurations\Index as ConfigurationsIndex;
use App\Livewire\Configurations\Version as ConfigurationsVersion;
use App\Livewire\Configurations\OwnPlugins as ConfigurationsOwnPlugins;
use App\Livewire\Configurations\Manager\Index as ConfigurationsManagerIndex;

use App\Livewire\Configurations\Roles\{
    Create as ConfigurationsRolesCreate,
    Edit as ConfigurationsRolesEdit,
};

/* CONFIGURACIONES PERMISOS
   Solo la edición de la descripción: el listado vive en Acceso, junto a los roles. */
use App\Livewire\Configurations\Permissions\Edit as ConfigurationsPermissionsEdit;

/* CONFIGURACIONES PRODUCTOS — retirado.
   Había dos catálogos de producto, este y `/products`, con permisos distintos: dos
   sitios para crear y editar lo mismo. Se queda `/products` y las URLs de aquí
   redirigen allí. Ver briefs/configuracion.md §4.4. */

/* Rutas */
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Auth;

Route::get('/', function(){
    return redirect()->route('dashboard');
});

Route::view('profile', 'profile')
    ->middleware(['auth'])
    ->name('profile');

Route::middleware(['auth'])->group(function () {

    // Upload de imágenes para Features (ruta web para usar sesión + CSRF)
    Route::post('/api/features/upload-image', [\App\Http\Controllers\Features\ImageUploadController::class, 'upload'])
        ->middleware(['permission:admin.features.create|admin.features.edit']);

    // Dashboard
    Route::middleware(['permission:admin.dashboard.index'])->group(function () {
        Route::get('/dashboard', DashboardIndex::class)->name('dashboard');
    });

    // Monitorización: lo que se REVISA. Los ajustes (destinatarios, umbrales, horas)
    // están en Configuraciones → Configuraciones del Manager.
    //
    // Permiso de LECTURA para toda la sección: `admin.api-logs.index`, que tienen Admin,
    // Support y Manager —revisar es el trabajo de Soporte—. Las ACCIONES de dentro
    // (liberar un bloqueo, bloquear una IP) exigen `admin.configs.edit`, que es solo de
    // Admin: no es lo mismo mirar que tocar.
    Route::middleware(['permission:admin.api-logs.index'])->group(function () {
        Route::group(['prefix' => 'monitoring'], function () {
            // **La portada de la sección.** `/monitoring` era directamente «Tráfico y
            // cortes», así que la puerta de cinco herramientas era la más densa de las
            // cinco y ninguna decía qué son las otras cuatro. Es lo mismo que le pasaba a
            // Configuración —entraba por «Tipos de entornos»— y se arregla igual.
            Route::get('/', MonitoringIndex::class)->name('monitoring.index');

            // «Bloqueos» e «IPs» eran dos pantallas para un solo trabajo: para bloquear
            // una IP se iba a una y para ver los bloqueos a la otra. Fusionadas en
            // «Tráfico y cortes», que ahora tiene ruta propia porque la raíz es la
            // portada. Quien tuviera `/monitoring` guardado sigue llegando a la sección.
            Route::get('/traffic', MonitoringTraffic::class)->name('monitoring.traffic');
            Route::get('/expirations', MonitoringExpirations::class)->name('monitoring.expirations');
            Route::get('/notices', MonitoringNotices::class)->name('monitoring.notices');
            // El tamaño de la base: solo lectura, con el mismo permiso que el resto de la
            // sección. No borra nada — cada cosa se limpia donde se entiende qué se borra.
            Route::get('/size', MonitoringTamano::class)->name('monitoring.tamano');

            // La antigua pestaña de IPs: cualquier enlace guardado sigue llegando a
            // donde está ahora ese contenido, en lugar de a un 404.
            Route::redirect('/ips', '/monitoring')->name('monitoring.ips');
        });

        // El visor de logs ya existía y es pesado —sus filtros, su paginado—: se queda
        // en su ruta y se enlaza desde las pestañas de Monitorización.
        Route::get('/api-logs', ApiLogsIndex::class)->name('api-logs.index');
    });

    // Usuarios
    Route::middleware(['permission:admin.users.index'])->group(function () {
        Route::group(['prefix' => 'users'], function () {
            Route::get('/', UsersIndex::class)->name('users.index');
            Route::middleware(['permission:admin.users.create'])->group(function () {
                Route::get('/create', UsersCreate::class)->name('users.create');
            });
            Route::middleware(['permission:admin.users.edit'])->group(function () {
                Route::get('/{user}/edit', UsersEdit::class)->name('users.edit');
            });
        });
    });

    // Entornos
    Route::middleware(['permission:admin.environments.index'])->group(function () {
        Route::group(['prefix' => 'environments'], function () {
            Route::get('/', EnvironmentsIndex::class)->name('environments.index');
            Route::middleware(['permission:admin.environments.create'])->group(function () {
                Route::get('/create', EnvironmentsCreateWizard::class)->name('environments.create');
                Route::get('/clients/{client}/create', EnvironmentsCreateFromClient::class)->name('environments.create-from-client');
            });
            Route::get('/{environment}/success', EnvironmentsSuccess::class)->name('environments.success');
            Route::middleware(['permission:admin.environments.edit'])->group(function () {
                Route::get('/{environment}/edit', EnvironmentsEdit::class)->name('environments.edit');
            });
            // El permiso es `admin.plugins.environment`, que existía en el seeder desde
            // el principio **y no lo usaba ninguna ruta**: la pantalla la protegía
            // `admin.environments.index`. Lo tienen Admin y Support, los mismos que
            // antes, así que nadie pierde acceso.
            Route::get('/{environment}/plugins', EnvironmentPluginsIndex::class)
                ->middleware(['permission:admin.plugins.environment'])
                ->name('environments.plugins.index');

            // Uso del entorno: cuánta gente y cuánto contenido tiene ese Moodle, y su
            // evolución. El permiso es `admin.datas.environment`, que ya existía en el
            // seeder sin ninguna pantalla que lo usara —lo tienen Admin y Support—.
            Route::get('/{environment}/uso', EnvironmentUso::class)
                ->middleware(['permission:admin.datas.environment'])
                ->name('environments.uso');

            // La ficha del entorno. **Va al final del grupo a propósito**:
            // `/{environment}` casa con cualquier segmento, así que declarada antes
            // se tragaría `/environments/create` y `/environments/clients/…`.
            //
            // El permiso es el de LECTURA del listado (`admin.environments.index`, el
            // del grupo): quien puede ver la lista puede ver la ficha. Editar,
            // sincronizar y apagar siguen pidiendo el suyo dentro del componente.
            Route::get('/{environment}', EnvironmentsShow::class)->name('environments.show');

            // Soportes contratados del entorno. El permiso de la ruta es el de LECTURA;
            // crear, editar y borrar se comprueban dentro del componente, porque en
            // /livewire/update el `permission:` de la ruta no se reaplica (MGR-005).
            Route::get('/{environment}/supports', EnvironmentSupportsIndex::class)
                ->middleware(['permission:admin.environments.supports.index'])
                ->name('environments.supports.index');
        });
    });

    // Clientes
    // Registro de acciones del panel, con permiso PROPIO: `admin.logs.index`, que una
    // migración vieja creaba sin ruta ni pantalla (MGR-011). Fuera del grupo del visor
    // de la API a propósito: son dos cosas distintas y exigir los dos permisos para
    // esta no lo explica nadie.
    Route::middleware(['permission:admin.logs.index'])->group(function () {
        Route::get('/system-log', MonitoringSystemLog::class)->name('monitoring.system-log');
    });

    Route::middleware(['permission:admin.clients.index'])->group(function () {
        Route::group(['prefix' => 'clients'], function () {
            Route::get('/', ClientsIndex::class)->name('clients.index');
            Route::middleware(['permission:admin.clients.create'])->group(function () {
                Route::get('/create', ClientsCreate::class)->name('clients.create');
            });
            Route::get('/{client}', ClientsShow::class)->name('clients.show');
            Route::middleware(['permission:admin.clients.edit'])->group(function () {
                Route::get('/{client}/edit', ClientsEdit::class)->name('clients.edit');
            });
        });
    });

    // Tipo de Soporte
    Route::middleware(['permission:admin.supports.index'])->group(function () {
        Route::group(['prefix' => 'supports'], function () {
            Route::get('/', SupportsIndex::class)->name('supports.index');
            Route::middleware(['permission:admin.supports.create'])->group(function () {
                Route::get('/create', SupportsCreate::class)->name('supports.create');
            });
            Route::middleware(['permission:admin.supports.edit'])->group(function () {
                Route::get('/{support}/edit', SupportsEdit::class)->name('supports.edit');
            });
        });
    });

    // Configuraciones
    Route::group(['prefix' => 'configurations'], function () {
        // **La puerta de la sección.** Antes no existía: el menú lateral entraba
        // directamente en «Tipos de entornos», la pestaña que menos se toca. Ver
        // `Configurations\Index`.
        //
        // Sin `permission:` a propósito: cada bloque de la portada se pinta con su
        // propio `@can`, así que quien tenga uno solo de los permisos de la sección
        // entra y ve lo suyo. Un middleware aquí obligaría a elegir cuál manda.
        Route::get('/', ConfigurationsIndex::class)->name('configurations.index');

        // Versión y cambios: qué está desplegado aquí y qué no.
        //
        // **Sin `permission:`, igual que la portada.** No enseña ni un dato de cliente, y
        // quien más la necesita —quien atiende el teléfono y tiene que decir si algo ya
        // está subido— es justo quien menos permisos tiene. Pedirle `admin.configs.index`
        // la dejaría solo para Admin, que es el único que ya sabía la respuesta.
        Route::get('/version', ConfigurationsVersion::class)->name('configurations.version');

        // Acceso: roles y permisos en la misma pantalla. El permiso de entrada es el de
        // roles porque es lo primero que se ve; el bloque de permisos lleva el suyo.
        Route::middleware(['permission:admin.roles.index'])->group(function () {
            Route::get('/access', ConfigurationsAccess::class)->name('configurations.access');
        });

        // ============ Catálogos ============
        // **La URL se llamaba `/configurations/environments-types`** porque la pantalla era
        // solo el listado de tipos de entorno. Ahora es «Catálogos» y tiene dentro dos
        // cosas —los tipos y los plugins propios—, así que el endpoint lo dice.
        //
        // La URL vieja se conserva redirigida: está en favoritos y en enlaces compartidos.
        Route::redirect('/environments-types', '/configurations/catalogs')
            ->name('configurations.environments-types.index');

        Route::middleware(['permission:admin.configurations.environments-types.index'])->group(function () {
            Route::group(['prefix' => 'catalogs'], function () {
                Route::get('/', ConfigurationsEnvironmentsTypesIndex::class)->name('configurations.catalogs');

                // Los tipos de entorno cuelgan de Catálogos, que es donde se ven.
                Route::group(['prefix' => 'environment-types'], function () {
                    Route::middleware(['permission:admin.configurations.environments-types.create'])->group(function () {
                        Route::get('/create', ConfigurationsEnvironmentsTypesCreate::class)->name('configurations.environments-types.create');
                    });
                    Route::middleware(['permission:admin.configurations.environments-types.edit'])->group(function () {
                        Route::get('/{type}/edit', ConfigurationsEnvironmentsTypesEdit::class)->name('configurations.environments-types.edit');
                    });
                });

                // ============ Los usos del entorno ============
                // `pro`, `pre`, `develop`, `local`. **Con sus propios permisos y no con
                // los de los tipos**, aunque se vean en la misma hoja: son dos catálogos
                // distintos y este es más delicado —de él dependen la validación de la API
                // pública y qué se ve al abrir el listado de entornos—, así que quién
                // puede tocarlo se decide aparte.
                //
                // El listado vive en la hoja de Catálogos, arriba: son cuatro filas, y una
                // pantalla propia para una tabla de cuatro filas es un clic de más.
                Route::group(['prefix' => 'envs'], function () {
                    Route::middleware(['permission:admin.configurations.envs.create'])->group(function () {
                        Route::get('/create', ConfigurationsEnvsCreate::class)->name('configurations.envs.create');
                    });
                    Route::middleware(['permission:admin.configurations.envs.edit'])->group(function () {
                        Route::get('/{env}/edit', ConfigurationsEnvsEdit::class)->name('configurations.envs.edit');
                    });
                });
            });
        });

        // El catálogo de plugins propios: la lista de qué `component` de Moodle es
        // nuestro. Con `admin.configs.*` y no con un permiso nuevo: es configuración del
        // Manager, y quien ajusta el Manager decide esto.
        Route::middleware(['permission:admin.configs.index'])->group(function () {
            Route::get('/catalogs/own-plugins', ConfigurationsOwnPlugins::class)->name('configurations.own-plugins');
        });

        Route::middleware(['permission:admin.roles.index'])->group(function () {
            Route::group(['prefix' => 'roles'], function () {
                // **El listado de roles vive ahora en Acceso**, junto a los permisos: eran
                // la misma pregunta a dos niveles. La URL se conserva redirigida porque
                // está en favoritos y en enlaces compartidos.
                Route::redirect('/', '/configurations/access')->name('configurations.roles.index');
                Route::middleware(['permission:admin.roles.create'])->group(function () {
                    Route::get('/create', ConfigurationsRolesCreate::class)->name('configurations.roles.create');
                });
                Route::middleware(['permission:admin.roles.edit'])->group(function () {
                    Route::get('/{role}/edit', ConfigurationsRolesEdit::class)->name('configurations.roles.edit');
                });
            });
        });
        // Configuraciones del Manager: ajustes que Soporte tiene que poder cambiar sin
        // desplegar (a quién se avisa de los bloqueos, cada cuánto, la hora del
        // resumen). Los permisos `admin.configs.*` estaban reservados en el seeder
        // desde el principio y no los usaba nadie.
        Route::middleware(['permission:admin.configs.index'])->group(function () {
            Route::get('/manager', ConfigurationsManagerIndex::class)->name('configurations.manager.index');
        });

        Route::middleware(['permission:admin.permissions.index'])->group(function () {
            Route::group(['prefix' => 'permissions'], function () {
                // **El listado de permisos vive ahora en Acceso.** Era una lista plana de
                // 126 filas que no decía qué roles tiene cada permiso, que es la única
                // pregunta que se hace mirándola. La URL se conserva redirigida.
                Route::redirect('/', '/configurations/access')->name('configurations.permissions.index');
                Route::middleware(['permission:admin.permissions.edit'])->group(function () {
                    Route::get('/{permission}/edit', ConfigurationsPermissionsEdit::class)->name('configurations.permissions.edit');
                });
            });
        });
        // **La gemela de Productos ya no está.** Había dos catálogos de producto —este y
        // `/products`, la pantalla rediseñada con su ficha, sus estados y su contenido
        // publicado—, con permisos distintos (`admin.configurations.products.*` frente a
        // `admin.products.*`): dos sitios para crear y editar lo mismo. Se queda el de
        // `/products` y estas URLs redirigen allí. Ver briefs/configuracion.md §4.4.
        Route::redirect('/products', '/products')->name('configurations.products.index');
        Route::redirect('/products/create', '/products/create')->name('configurations.products.create');
        Route::get('/products/{product}/edit', function ($product) {
            return redirect()->route('products.edit', $product);
        })->name('configurations.products.edit');
    });

    // Productos
    Route::middleware(['permission:admin.products.index'])->group(function () {
        Route::group(['prefix' => 'products'], function () {
            Route::get('/', ProductsIndex::class)->name('products.index');
            Route::middleware(['permission:admin.products.create'])->group(function () {
                Route::get('/create', ProductsCreate::class)->name('products.create');
            });
            Route::middleware(['permission:admin.products.edit'])->group(function () {
                Route::get('/{product}/edit', ProductsEdit::class)->name('products.edit');
            });
            Route::middleware(['permission:admin.products.show'])->group(function () {
                Route::get('/{product}', ProductsShow::class)->name('products.show');
            });
        });
    });

    // Plugins del parque — cinco pantallas con el permiso dedicado
    // `admin.plugins.environment`. Eran tres pestañas dentro de una sola pantalla, y
    // una pestaña no se puede enlazar, no sale en el menú y obliga a calcular lo de
    // las otras dos para pintar sus contadores. Ver `Plugins\PantallaDelParque`.
    Route::middleware(['permission:admin.plugins.environment'])->group(function () {
        Route::get('/plugins', GlobalPluginsIndex::class)->name('plugins.index');
        Route::get('/plugins/nuestros', PluginsNuestros::class)->name('plugins.nuestros');
        Route::get('/plugins/sin-instalar', PluginsSinInstalar::class)->name('plugins.sin-instalar');
        Route::get('/plugins/inventario', PluginsInventario::class)->name('plugins.inventario');
        Route::get('/plugins/moodle', PluginsCore::class)->name('plugins.core');
    });

    // Setups anidados bajo productos
    Route::middleware(['permission:admin.setups.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/setups'], function () {
            Route::get('/', SetupsIndex::class)->name('products.setups.index');
            Route::middleware(['permission:admin.setups.create'])->group(function () {
                Route::get('/create', SetupsCreate::class)->name('products.setups.create');
            });
            Route::middleware(['permission:admin.setups.show'])->group(function () {
                Route::get('/{setup}', SetupsShow::class)->name('products.setups.show');
            });
            Route::middleware(['permission:admin.setups.edit'])->group(function () {
                Route::get('/{setup}/edit', SetupsEdit::class)->name('products.setups.edit');
            });
        });
    });

    // Features anidados bajo productos
    Route::middleware(['permission:admin.features.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/features'], function () {
            Route::get('/', FeaturesIndex::class)->name('products.features.index');
            
            // Crear versión
            Route::middleware(['permission:admin.features.version.create'])->group(function () {
                Route::get('/create', FeaturesVersionCreate::class)->name('products.features.version.create');
            });
            
            // Rutas de versiones: products/{product}/features/version/{featureVersion}
            Route::group(['prefix' => 'version/{featureVersion}'], function () {
                Route::middleware(['permission:admin.features.version.show'])->group(function () {
                    Route::get('/', FeaturesVersionShow::class)->name('products.features.version.show');
                });
                Route::middleware(['permission:admin.features.version.edit'])->group(function () {
                    Route::get('/edit', FeaturesVersionEdit::class)->name('products.features.version.edit');
                });
                
                // Rutas de features individuales: products/{product}/features/version/{featureVersion}/feature/{feature}
                Route::group(['prefix' => 'feature/{feature}'], function () {
                    Route::middleware(['permission:admin.features.edit'])->group(function () {
                        Route::get('/edit', FeaturesEdit::class)->name('products.features.edit');
                    });
                });
                
                // Crear feature dentro de una versión
                Route::middleware(['permission:admin.features.create'])->group(function () {
                    Route::get('/feature/create', FeaturesCreate::class)->name('products.features.create');
                });
            });
        });
    });

    // Tutoriales anidados bajo productos
    Route::middleware(['permission:admin.tutorials.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/tutorials'], function () {
            Route::get('/', TutorialsIndex::class)->name('products.tutorials.index');
            
            // Crear versión
            Route::middleware(['permission:admin.tutorials.version.create'])->group(function () {
                Route::get('/create', TutorialsVersionCreate::class)->name('products.tutorials.version.create');
            });
            
            // Rutas de versiones: products/{product}/tutorials/version/{tutorialVersion}
            Route::group(['prefix' => 'version/{tutorialVersion}'], function () {
                Route::middleware(['permission:admin.tutorials.version.show'])->group(function () {
                    Route::get('/', TutorialsVersionShow::class)->name('products.tutorials.version.show');
                });
                Route::middleware(['permission:admin.tutorials.version.edit'])->group(function () {
                    Route::get('/edit', TutorialsVersionEdit::class)->name('products.tutorials.version.edit');
                });
                
                // Rutas de tutoriales individuales: products/{product}/tutorials/version/{tutorialVersion}/tutorial/{tutorial}
                Route::group(['prefix' => 'tutorial/{tutorial}'], function () {
                    Route::middleware(['permission:admin.tutorials.edit'])->group(function () {
                        Route::get('/edit', TutorialsEdit::class)->name('products.tutorials.edit');
                    });
                });
                
                // Crear tutorial dentro de una versión
                Route::middleware(['permission:admin.tutorials.create'])->group(function () {
                    Route::get('/tutorial/create', TutorialsCreate::class)->name('products.tutorials.create');
                });
            });
        });
    });

    // Resources anidados bajo productos
    Route::middleware(['permission:admin.resources.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/resources'], function () {
            Route::get('/', ResourcesIndex::class)->name('products.resources.index');
            
            // Crear versión
            Route::middleware(['permission:admin.resources.version.create'])->group(function () {
                Route::get('/create', ResourcesVersionCreate::class)->name('products.resources.version.create');
            });
            
            // Rutas de versiones: products/{product}/resources/version/{resourceVersion}
            Route::group(['prefix' => 'version/{resourceVersion}'], function () {
                Route::middleware(['permission:admin.resources.version.show'])->group(function () {
                    Route::get('/', ResourcesVersionShow::class)->name('products.resources.version.show');
                });
                Route::middleware(['permission:admin.resources.version.edit'])->group(function () {
                    Route::get('/edit', ResourcesVersionEdit::class)->name('products.resources.version.edit');
                });
                
                // Rutas de recursos individuales: products/{product}/resources/version/{resourceVersion}/resource/{resource}
                Route::group(['prefix' => 'resource/{resource}'], function () {
                    Route::middleware(['permission:admin.resources.edit'])->group(function () {
                        Route::get('/edit', ResourcesEdit::class)->name('products.resources.edit');
                    });
                });
                
                // Crear recurso dentro de una versión
                Route::middleware(['permission:admin.resources.create'])->group(function () {
                    Route::get('/resource/create', ResourcesCreate::class)->name('products.resources.create');
                });
            });
        });
    });

    // LicenceTokens
    Route::middleware(['permission:admin.license-tokens.index'])->group(function () {
        Route::group(['prefix' => 'license_tokens'], function () {
            Route::get('/', LicenseTokensIndex::class)->name('license_tokens.index');
            Route::middleware(['permission:admin.license-tokens.create'])->group(function () {
                Route::get('/create', LicenseTokensCreateWizard::class)->name('license_tokens.create');
            });
            Route::middleware(['permission:admin.license-tokens.edit'])->group(function () {
                Route::get('/{license_token}/edit', LicenseTokensEdit::class)->name('license_tokens.edit');
            });
            Route::middleware(['permission:admin.license-tokens.manage-environments'])->group(function () {
                Route::get('/{license_token}/manage-environments', LicenseTokensManageEnvironments::class)->name('license_tokens.manage-environments');
            });
            Route::middleware(['permission:admin.license-tokens.show'])->group(function () {
                Route::get('/{license_token}', LicenseTokensShow::class)->name('license_tokens.show');
            });
            Route::middleware(['permission:admin.license-tokens.associate-license'])->group(function () {
                Route::get('/{client}/associate-license/{environment?}', LicenseTokensAssociateLicense::class)->name('license_tokens.associate-license');
            });
        });
    });

    // SCSS Versions anidados bajo productos
    Route::middleware(['permission:admin.scss.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/scss'], function () {
            Route::get('/', ScssIndex::class)->name('products.scss.index');
            Route::middleware(['permission:admin.scss.version.show'])->group(function () {
                Route::get('/{scssVersion}', ScssVersionShow::class)->name('products.scss.version.show');
            });
            Route::middleware(['permission:admin.scss.version.edit'])->group(function () {
                Route::get('/{scssVersion}/edit', ScssVersionEdit::class)->name('products.scss.version.edit');
            });
            Route::middleware(['permission:admin.scss.files.upload'])->group(function () {
                Route::get('/{scssVersion}/files/upload', ScssFileUpload::class)->name('products.scss.files.upload');
            });
            Route::middleware(['permission:admin.scss.file.create'])->group(function () {
                Route::get('/{scssVersion}/file/create', ScssCreate::class)->name('products.scss.file.create');
            });
            Route::middleware(['permission:admin.scss.file.show'])->group(function () {
                Route::get('/{scssVersion}/file/{scssFile}', ScssShow::class)->name('products.scss.file.show');
            });
            Route::middleware(['permission:admin.scss.file.edit'])->group(function () {
                Route::get('/{scssVersion}/file/{scssFile}/edit', ScssEdit::class)->name('products.scss.file.edit');
            });
        });
    });

    // JS Versions anidados bajo productos
    Route::middleware(['permission:admin.js.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/js'], function () {
            Route::get('/', JsIndex::class)->name('products.js.index');
            Route::middleware(['permission:admin.js.version.show'])->group(function () {
                Route::get('/{jsVersion}', JsVersionShow::class)->name('products.js.version.show');
            });
            Route::middleware(['permission:admin.js.version.edit'])->group(function () {
                Route::get('/{jsVersion}/edit', JsVersionEdit::class)->name('products.js.version.edit');
            });
            Route::middleware(['permission:admin.js.files.upload'])->group(function () {
                Route::get('/{jsVersion}/files/upload', JsFileUpload::class)->name('products.js.files.upload');
            });
            Route::middleware(['permission:admin.js.file.create'])->group(function () {
                Route::get('/{jsVersion}/file/create', JsCreate::class)->name('products.js.file.create');
            });
            Route::middleware(['permission:admin.js.file.show'])->group(function () {
                Route::get('/{jsVersion}/file/{jsFile}', JsShow::class)->name('products.js.file.show');
            });
            Route::middleware(['permission:admin.js.file.edit'])->group(function () {
                Route::get('/{jsVersion}/file/{jsFile}/edit', JsEdit::class)->name('products.js.file.edit');
            });
        });
    });

    // SCSS CDN Bundles anidados bajo productos
    Route::middleware(['permission:admin.scss-cdn.index'])->group(function () {
        Route::group(['prefix' => 'products/{product}/scss-cdn'], function () {
            Route::get('/', ScssCdnIndex::class)->name('products.scss-cdn.index');
            Route::middleware(['permission:admin.scss-cdn.create'])->group(function () {
                Route::get('/create', ScssCdnBundleCreate::class)->name('products.scss-cdn.create');
            });
            Route::middleware(['permission:admin.scss-cdn.bundle.show'])->group(function () {
                Route::get('/{bundle}', ScssCdnBundleShow::class)->name('products.scss-cdn.bundle.show');
            });
            Route::middleware(['permission:admin.scss-cdn.bundle.edit'])->group(function () {
                Route::get('/{bundle}/edit', ScssCdnBundleEdit::class)->name('products.scss-cdn.bundle.edit');
            });
            Route::middleware(['permission:admin.scss-cdn.bundle.upload'])->group(function () {
                Route::get('/{bundle}/upload', ScssCdnZipUpload::class)->name('products.scss-cdn.bundle.upload');
            });
            Route::middleware(['permission:admin.scss-cdn.file.edit'])->group(function () {
                Route::get('/{bundle}/file/{file}/edit', ScssCdnFileEdit::class)->name('products.scss-cdn.file.edit');
            });
        });
    });

    // Preview de un tutorial: pantalla INTERNA para que el autor vea el vídeo antes de
    // publicarlo. Estaba sin `permission:`, así que cualquier usuario autenticado
    // —de cualquier rol— veía cualquier tutorial por id, incluidos los borradores. Y el
    // `videoid` de un vídeo "oculto" de YouTube es, en la práctica, su contraseña.
    // Ver known-issues MGR-012.
    //
    // Mismo permiso que la pantalla desde la que se llega (la versión del tutorial).
    // Si algún día hace falta compartirlo con un cliente, eso NO es este camino: sería
    // una URL firmada y caducable, y se añade aparte sin tocar esto.
    Route::middleware(['permission:admin.tutorials.version.show'])->group(function () {
        Route::get('/tutorials/{tutorial}/preview', [\App\Http\Controllers\Tutorials\PreviewController::class, 'show'])->name('tutorials.preview');
    });

});


require __DIR__.'/auth.php';