┌─────────────────────────────────────────────────────────────┐
│  PRESENTATION LAYER (Trigger)                               │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────────┐              ┌──────────────────┐    │
│  │   CONTROLLER     │              │      JOB         │    │
│  │   (Manuale)      │              │   (Automatico)   │    │
│  └────────┬─────────┘              └────────┬─────────┘    │
│           │                                  │              │
│           └──────────────┬───────────────────┘              │
│                          │                                  │
└──────────────────────────┼──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  BUSINESS LOGIC LAYER (Services)                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌────────────────────────────────────────────────────────┐│
│  │  CsvScannerService                                      ││
│  │   → scanForNewCsvs()                                    ││
│  │   → registerCsv($file, $machine, $profile)             ││
│  └────────────────────────────────────────────────────────┘│
│                                                              │
│  ┌────────────────────────────────────────────────────────┐│
│  │  CsvValidatorService                                    ││
│  │   → validate($csvImport): ValidationResult             ││
│  │   → checkColumns($csv, $profile)                       ││
│  │   → checkDataTypes($csv, $profile)                     ││
│  └────────────────────────────────────────────────────────┘│
│                                                              │
│  ┌────────────────────────────────────────────────────────┐│
│  │  CsvProcessorService                                    ││
│  │   → process($csvImport): ProcessingResult              ││
│  │   → importRows($csv, $profile)                         ││
│  │   → handleErrors($errors)                              ││
│  └────────────────────────────────────────────────────────┘│
│                                                              │
│  ┌────────────────────────────────────────────────────────┐│
│  │  CsvCleanupService                                      ││
│  │   → cleanup($csvImport)                                ││
│  │   → archive($csvImport)                                ││
│  │   → deleteFile($csvImport)                             ││
│  └────────────────────────────────────────────────────────┘│
│                                                              │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│  DATA LAYER (Models)                                        │
├─────────────────────────────────────────────────────────────┤
│  CsvImport, Machine, ImportProfile                          │
└─────────────────────────────────────────────────────────────┘

namespace App\Services\I40;

class CsvValidatorService
{
    public function validate(CsvImport $csvImport): ValidationResult
    {
        // Logica IDENTICA sia per manuale che automatico
        
        $profile = ImportProfile::find($csvImport->profile_id);
        $filePath = Storage::path($csvImport->file_path);
        
        $errors = [];
        
        // 1. Verifica file esista
        if (!Storage::exists($csvImport->file_path)) {
            return new ValidationResult(false, ['File non trovato']);
        }
        
        // 2. Leggi CSV
        try {
            $csv = Reader::createFromPath($filePath);
            $csv->setHeaderOffset($profile->has_header ? 0 : null);
        } catch (\Exception $e) {
            return new ValidationResult(false, ['Errore lettura CSV: ' . $e->getMessage()]);
        }
        
        // 3. Verifica colonne
        $headers = $csv->getHeader();
        $expectedColumns = array_column($profile->columns, 'name');
        
        foreach ($expectedColumns as $col) {
            if (!in_array($col, $headers)) {
                $errors[] = "Colonna mancante: {$col}";
            }
        }
        
        // 4. Conta righe
        $rowsCount = count($csv);
        
        // 5. Verifica tipi dati (campione prime 10 righe)
        // ... logica validazione tipi ...
        
        return new ValidationResult(
            isValid: empty($errors),
            errors: $errors,
            rowsCount: $rowsCount
        );
    }
}

// Value Object per il risultato
class ValidationResult
{
    public function __construct(
        public bool $isValid,
        public array $errors,
        public int $rowsCount = 0
    ) {}
}

namespace App\Http\Controllers\Admin\I40;

class CsvImportsController extends Controller
{
    public function __construct(
        protected CsvValidatorService $validator,
        protected CsvProcessorService $processor
    ) {}
    
    /**
     * Valida CSV manualmente
     */
    public function validate(CsvImport $csvImport)
    {
        // Verifica permessi, stato, etc.
        if (!in_array($csvImport->status, ['pending', 'failed'])) {
            return back()->withErrors(['error' => 'CSV non in stato validabile']);
        }
        
        // Aggiorna stato
        $csvImport->update(['status' => 'validating']);
        
        try {
            // ⭐ CHIAMATA AL SERVICE (STESSO CODICE)
            $result = $this->validator->validate($csvImport);
            
            // Aggiorna con risultato
            $csvImport->update([
                'status' => $result->isValid ? 'validated' : 'failed',
                'is_valid' => $result->isValid,
                'validation_errors' => json_encode($result->errors),
                'rows_total' => $result->rowsCount,
                'validated_at' => now(),
                'validated_by' => auth()->id()  // ← MANUALE
            ]);
            
            $message = $result->isValid 
                ? "CSV validato con successo! {$result->rowsCount} righe."
                : "Validazione fallita: " . count($result->errors) . " errori trovati.";
            
            return redirect()
                ->route('admin.i40.csv-imports.index')
                ->with($result->isValid ? 'success' : 'error', $message);
                
        } catch (\Exception $e) {
            $csvImport->update([
                'status' => 'failed',
                'error_message' => $e->getMessage()
            ]);
            
            return back()->withErrors(['error' => 'Errore validazione: ' . $e->getMessage()]);
        }
    }
    
    /**
     * Elabora CSV manualmente
     */
    public function process(CsvImport $csvImport)
    {
        // Verifica sia validato
        if ($csvImport->status !== 'validated') {
            return back()->withErrors(['error' => 'CSV deve essere validato prima di elaborare']);
        }
        
        // Aggiorna stato
        $csvImport->update([
            'status' => 'processing',
            'processing_started_at' => now(),
            'processed_by' => auth()->id()  // ← MANUALE
        ]);
        
        try {
            // ⭐ CHIAMATA AL SERVICE (STESSO CODICE)
            $result = $this->processor->process($csvImport);
            
            // Aggiorna con risultato
            $csvImport->update([
                'status' => 'completed',
                'processing_completed_at' => now(),
                'rows_processed' => $result->rowsProcessed,
                'rows_failed' => $result->rowsFailed,
                'import_result' => json_encode($result->stats)
            ]);
            
            return redirect()
                ->route('admin.i40.csv-imports.index')
                ->with('success', "Elaborazione completata! {$result->rowsProcessed} righe importate.");
                
        } catch (\Exception $e) {
            $csvImport->update([
                'status' => 'failed',
                'error_message' => $e->getMessage(),
                'processing_completed_at' => now()
            ]);
            
            return back()->withErrors(['error' => 'Errore elaborazione: ' . $e->getMessage()]);
        }
    }
}

namespace App\Jobs\I40;

class ValidateCsvJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public function __construct(
        protected int $csvImportId
    ) {}
    
    public function handle(CsvValidatorService $validator)
    {
        $csvImport = CsvImport::find($this->csvImportId);
        
        if (!$csvImport) {
            return; // CSV eliminato nel frattempo
        }
        
        // Aggiorna stato
        $csvImport->update(['status' => 'validating']);
        
        // ⭐ CHIAMATA AL SERVICE (STESSO CODICE DEL CONTROLLER!)
        $result = $validator->validate($csvImport);
        
        // Aggiorna con risultato
        $csvImport->update([
            'status' => $result->isValid ? 'validated' : 'failed',
            'is_valid' => $result->isValid,
            'validation_errors' => json_encode($result->errors),
            'rows_total' => $result->rowsCount,
            'validated_at' => now(),
            'validated_by' => null  // ← AUTOMATICO
        ]);
        
        // Se valido e auto-process abilitato
        if ($result->isValid && i40_setting('processing.auto_process_validated')) {
            // Verifica concurrent limit
            $running = CsvImport::where('status', 'processing')->count();
            $limit = i40_setting('processing.concurrent_limit', 5);
            
            if ($running < $limit) {
                dispatch(new ProcessCsvJob($csvImport->id));
            }
        }
    }
}

// Controller
public function validate($id) {
    $result = $this->validator->validate($csv);
    // Redirect
}

// Job (NUOVO)
public function handle() {
    $result = $this->validator->validate($csv);  // ← STESSO SERVICE!
    // Dispatch next
}

// Controller (INVARIATO)
public function validate($id) {
    $result = $this->validator->validate($csv);  // ← STESSO SERVICE!
    // Redirect
}

app/Services/I40/
├── CsvScannerService.php       ← CORE LOGIC
├── CsvValidatorService.php     ← CORE LOGIC ⭐
├── CsvProcessorService.php     ← CORE LOGIC ⭐
└── CsvCleanupService.php       ← CORE LOGIC ⭐

app/Http/Controllers/Admin/I40/
└── CsvImportsController.php
    ├── scanNewCsvs()    → CsvScannerService::scan()
    ├── validate($id)    → CsvValidatorService::validate() ⭐
    ├── process($id)     → CsvProcessorService::process() ⭐
    └── cleanup($id)     → CsvCleanupService::cleanup() ⭐

app/Jobs/I40/ (FUTURE)
├── ValidateCsvJob.php   → CsvValidatorService::validate() ⭐
├── ProcessCsvJob.php    → CsvProcessorService::process() ⭐
└── CleanupCsvJob.php    → CsvCleanupService::cleanup() ⭐

// ❌ SBAGLIATO (duplicazione)
class Controller {
    public function validate() {
        // 100 righe logica validazione
    }
}
class Job {
    public function handle() {
        // STESSE 100 righe duplicate!
    }
}

// ✅ CORRETTO (riuso)
class CsvValidatorService {
    public function validate() {
        // 100 righe logica validazione UNA SOLA VOLTA
    }
}
class Controller {
    public function validate() {
        $this->validator->validate(); // ← Chiama service
    }
}
class Job {
    public function handle() {
        $this->validator->validate(); // ← Chiama STESSO service
    }
}

// Utente può sempre bypassare automazione
public function forceValidate($id)
{
    // Anche se settings = auto, permetti validazione manuale
    $result = $this->validator->validate($csv);
}