<?php

namespace App\Livewire\Features;

use App\Models\Features\Feature;
use App\Models\Features\FeatureVersion;
use App\Models\Products\Product;
use Livewire\Component;

class VersionShow extends Component
{
    public Product $product;
    public FeatureVersion $featureVersion;

    public function mount(Product $product, FeatureVersion $featureVersion)
    {
        $this->product = $product;
        $this->featureVersion = $featureVersion->load('features', 'product', 'creator');
        
        // Verificar que la versión pertenezca al producto
        if ($this->featureVersion->product_id !== $this->product->id) {
            abort(404, 'La versión de Features no pertenece a este producto.');
        }
    }

    public function delete($featureId)
    {
        $this->authorize('admin.features.destroy');
        
        $feature = Feature::findOrFail($featureId);

        // Verificar que la feature pertenece a esta versión
        if ($feature->feature_version_id !== $this->featureVersion->id) {
            session()->flash('error', 'La feature no pertenece a esta versión.');
            return;
        }

        // Eliminar feature
        $feature->delete();

        session()->flash('success', 'Feature eliminada exitosamente.');

        // Recargar versión
        $this->featureVersion->refresh();
    }

    public function moveUp($featureId)
    {
        $this->authorize('admin.features.edit');
        
        $feature = Feature::findOrFail($featureId);
        
        if ($feature->feature_version_id !== $this->featureVersion->id) {
            session()->flash('error', 'La feature no pertenece a esta versión.');
            return;
        }

        // Buscar la feature anterior (sort_order menor)
        $previousFeature = Feature::where('feature_version_id', $this->featureVersion->id)
            ->where('id', '!=', $feature->id)
            ->where(function ($query) use ($feature) {
                if ($feature->sort_order !== null) {
                    $query->where('sort_order', '<', $feature->sort_order)
                        ->orWhereNull('sort_order');
                } else {
                    $query->whereNull('sort_order');
                }
            })
            ->orderByDesc('sort_order')
            ->orderByDesc('created_at')
            ->first();

        if ($previousFeature) {
            $tempOrder = $feature->sort_order;
            $feature->sort_order = $previousFeature->sort_order;
            $previousFeature->sort_order = $tempOrder;
            
            $feature->save();
            $previousFeature->save();
        } else {
            // Si no hay anterior, asignar el sort_order más bajo disponible
            $minOrder = Feature::where('feature_version_id', $this->featureVersion->id)
                ->whereNotNull('sort_order')
                ->min('sort_order');
            
            $feature->sort_order = $minOrder !== null ? $minOrder - 1 : 0;
            $feature->save();
        }

        session()->flash('success', 'Orden actualizado correctamente.');
        $this->featureVersion->refresh();
    }

    public function moveDown($featureId)
    {
        $this->authorize('admin.features.edit');
        
        $feature = Feature::findOrFail($featureId);
        
        if ($feature->feature_version_id !== $this->featureVersion->id) {
            session()->flash('error', 'La feature no pertenece a esta versión.');
            return;
        }

        // Buscar la feature siguiente (sort_order mayor)
        $nextFeature = Feature::where('feature_version_id', $this->featureVersion->id)
            ->where('id', '!=', $feature->id)
            ->where(function ($query) use ($feature) {
                if ($feature->sort_order !== null) {
                    $query->where('sort_order', '>', $feature->sort_order);
                } else {
                    $query->whereNotNull('sort_order');
                }
            })
            ->orderBy('sort_order')
            ->orderBy('created_at')
            ->first();

        if ($nextFeature) {
            $tempOrder = $feature->sort_order;
            $feature->sort_order = $nextFeature->sort_order;
            $nextFeature->sort_order = $tempOrder;
            
            $feature->save();
            $nextFeature->save();
        } else {
            // Si no hay siguiente, asignar el sort_order más alto disponible + 1
            $maxOrder = Feature::where('feature_version_id', $this->featureVersion->id)
                ->whereNotNull('sort_order')
                ->max('sort_order');
            
            $feature->sort_order = $maxOrder !== null ? $maxOrder + 1 : 1;
            $feature->save();
        }

        session()->flash('success', 'Orden actualizado correctamente.');
        $this->featureVersion->refresh();
    }

    public function duplicateVersion()
    {
        $this->authorize('admin.features.version.create');
        
        $newVersion = $this->featureVersion->duplicate();

        session()->flash('success', "Versión duplicada exitosamente. Nueva versión: {$newVersion->version}");

        return redirect()->route('products.features.version.show', [$this->product, $newVersion]);
    }

    public function render()
    {
        $features = $this->featureVersion->features()
            ->with('creator')
            ->ordered()
            ->get();

        return view('livewire.features.version-show', [
            'features' => $features,
        ])->layout('layouts.app');
    }
}