<?php

namespace App\Http\Controllers;

use App\Models\Producto;
use App\Models\Categoria;
use Illuminate\Http\Request;

class ProductoController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        $productos = Producto::with(['categoria', 'costos'])->orderBy('id', 'asc')->get();
        $categorias = Categoria::where('estado', true)->orderBy('nombre')->get();

        return view('productos.index', compact('productos', 'categorias'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        $categorias = Categoria::where('estado', true)->orderBy('nombre')->get();
        return view('productos.create', compact('categorias'));
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validated = $request->validate([
            'nombre' => 'required|string|max:200',
            'fragancia' => 'required|string|max:200',
            'presentacion' => 'nullable|string|max:100',
            'categoria_id' => 'required|exists:categorias,id',
            'costo_1k' => 'required|numeric|min:0',
            'costo_frag_cf_cv' => 'required|numeric|min:0',
            'stock_actual' => 'nullable|integer|min:0',
            'stock_minimo' => 'nullable|integer|min:0',
            'estado' => 'boolean'
        ]);

        // Generar código consecutivo automáticamente
        $ultimoProducto = Producto::orderBy('id', 'desc')->first();
        $siguienteNumero = $ultimoProducto ? $ultimoProducto->id + 1 : 1;
        $validated['codigo'] = str_pad($siguienteNumero, 4, '0', STR_PAD_LEFT);

        // Valores por defecto para campos ocultos temporalmente
        $validated['stock_actual'] = $validated['stock_actual'] ?? 0;
        $validated['stock_minimo'] = $validated['stock_minimo'] ?? 0;
        $validated['estado'] = $request->has('estado') ? 1 : 0;

        // Calcular valores automáticamente según lógica del Excel
        $validated = $this->calculateProductValues($validated);

        Producto::create($validated);

        return redirect()->route('productos.index')
            ->with('success', 'Producto creado exitosamente.');
    }

    /**
     * Display the specified resource.
     */
    public function show(Producto $producto)
    {
        $producto->load('categoria');
        return view('productos.show', compact('producto'));
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Producto $producto)
    {
        $categorias = Categoria::where('estado', true)->orderBy('nombre')->get();
        return view('productos.edit', compact('producto', 'categorias'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Producto $producto)
    {
        $validated = $request->validate([
            'codigo' => 'required|string|max:50|unique:productos,codigo,' . $producto->id,
            'nombre' => 'required|string|max:200',
            'fragancia' => 'required|string|max:200',
            'presentacion' => 'nullable|string|max:100',
            'categoria_id' => 'required|exists:categorias,id',
            'costo_1k' => 'required|numeric|min:0',
            'costo_frag_cf_cv' => 'required|numeric|min:0',
            'stock_actual' => 'nullable|integer|min:0',
            'stock_minimo' => 'nullable|integer|min:0',
            'estado' => 'boolean'
        ]);

        // Valores por defecto para campos ocultos temporalmente
        $validated['stock_actual'] = $validated['stock_actual'] ?? $producto->stock_actual;
        $validated['stock_minimo'] = $validated['stock_minimo'] ?? $producto->stock_minimo;
        $validated['estado'] = $request->has('estado') ? 1 : 0;

        // Calcular valores automáticamente según lógica del Excel
        $validated = $this->calculateProductValues($validated);

        $producto->update($validated);

        return redirect()->route('productos.index')
            ->with('success', 'Producto actualizado exitosamente.');
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Producto $producto)
    {
        try {
            $producto->delete();
            return redirect()->route('productos.index')
                ->with('success', 'Producto eliminado exitosamente.');
        } catch (\Exception $e) {
            return redirect()->route('productos.index')
                ->with('error', 'No se puede eliminar el producto porque tiene registros asociados.');
        }
    }

    /**
     * Mostrar formulario de costos adicionales
     */
    public function costos(Producto $producto)
    {
        $producto->load('costos', 'categoria');
        return view('productos.costos', compact('producto'));
    }

    /**
     * Guardar costos adicionales
     */
    public function guardarCostos(Request $request, Producto $producto)
    {
        $validated = $request->validate([
            'costos' => 'nullable|array',
            'costos.*.concepto' => 'required|string|max:200',
            'costos.*.valor' => 'required|numeric|min:0',
        ]);

        \DB::beginTransaction();

        try {
            // Eliminar costos anteriores
            $producto->costos()->delete();

            // Agregar nuevos costos
            if ($request->has('costos')) {
                foreach ($request->costos as $costo) {
                    if (!empty($costo['concepto']) && isset($costo['valor']) && $costo['valor'] > 0) {
                        $producto->costos()->create([
                            'concepto' => $costo['concepto'],
                            'valor' => $costo['valor']
                        ]);
                    }
                }
            }

            \DB::commit();

            return redirect()->route('productos.index')
                ->with('success', 'Costos guardados exitosamente');

        } catch (\Exception $e) {
            \DB::rollBack();
            return redirect()->back()
                ->with('error', 'Error al guardar los costos: ' . $e->getMessage());
        }
    }

    /**
     * Get productos con stock bajo o igual al mínimo
     */
    public function getStockBajo()
    {
        $productos = Producto::where('estado', true)
            ->whereColumn('stock_actual', '<=', 'stock_minimo')
            ->with('categoria')
            ->orderBy('stock_actual', 'asc')
            ->get()
            ->map(function($producto) {
                return [
                    'id' => $producto->id,
                    'nombre' => $producto->nombre,
                    'codigo' => $producto->codigo,
                    'stock_actual' => $producto->stock_actual,
                    'stock_minimo' => $producto->stock_minimo,
                    'categoria' => $producto->categoria->nombre,
                    'url' => route('productos.show', $producto->id)
                ];
            });

        return response()->json([
            'total' => $productos->count(),
            'productos' => $productos
        ]);
    }

    /**
     * Muestra el reporte financiero resumen
     */
    public function reporteFinanciero()
    {
        // Obtener todos los productos activos con sus categorías
        $productos = Producto::with('categoria')
            ->where('estado', true)
            ->get();

        // Calcular ganancia promedio por unidad para cada margen
        $gananciaPotencial30 = $productos->sum(function($producto) {
            return $producto->precio_30 - $producto->costo_frag_cf_cv;
        });

        $gananciaPotencial50 = $productos->sum(function($producto) {
            return $producto->precio_50 - $producto->costo_frag_cf_cv;
        });

        $gananciaPotencial75 = $productos->sum(function($producto) {
            return $producto->precio_75 - $producto->costo_frag_cf_cv;
        });

        $gananciaPotencial100 = $productos->sum(function($producto) {
            return $producto->precio_100 - $producto->costo_frag_cf_cv;
        });

        // Top 10 productos por margen de ganancia 50%
        $topProductos = $productos->map(function($producto) {
            $producto->ganancia_50 = $producto->precio_50 - $producto->costo_frag_cf_cv;
            return $producto;
        })->sortByDesc('ganancia_50')->take(10);

        // Distribución por categoría
        $distribucionCategorias = $productos->groupBy('categoria_id')->map(function($items) {
            $categoria = $items->first()->categoria;
            $gananciaPromedio = $items->avg(function($producto) {
                return $producto->precio_50 - $producto->costo_frag_cf_cv;
            });
            $costoPromedio = $items->avg('costo_frag_cf_cv');
            $cantidadProductos = $items->count();

            return [
                'nombre' => $categoria->nombre,
                'ganancia_promedio' => $gananciaPromedio,
                'costo_promedio' => $costoPromedio,
                'cantidad_productos' => $cantidadProductos
            ];
        })->sortByDesc('ganancia_promedio');

        // Total de productos y promedios
        $totalProductos = $productos->count();
        $costoPromedioGeneral = $productos->avg('costo_frag_cf_cv');
        $precioPromedioGeneral = $productos->avg('precio_50');

        return view('reportes.financiero', compact(
            'gananciaPotencial30',
            'gananciaPotencial50',
            'gananciaPotencial75',
            'gananciaPotencial100',
            'topProductos',
            'distribucionCategorias',
            'totalProductos',
            'costoPromedioGeneral',
            'precioPromedioGeneral'
        ));
    }

    /**
     * Calcula los valores automáticos del producto según la lógica del Excel
     *
     * @param array $data - Datos validados del producto
     * @return array - Datos con valores calculados
     */
    private function calculateProductValues(array $data): array
    {
        $costo1k = floatval($data['costo_1k']);
        $costoFrag = floatval($data['costo_frag_cf_cv']);

        // Cálculo 1: IVA 19%
        // Fórmula: costo_1k × 0.19
        $data['iva_19'] = round($costo1k * 0.19, 2);

        // Cálculo 2: COSTO 1K + IVA
        // Fórmula: costo_1k + iva_19
        $data['costo_1k_con_iva'] = round($costo1k + $data['iva_19'], 2);

        // Cálculo 3: COSTO GR (costo por gramo)
        // Fórmula: (costo_1k + iva) ÷ 1000
        $data['costo_gr'] = round($data['costo_1k_con_iva'] / 1000, 2);

        // Cálculo 4: PRECIO 30% (30% de ganancia)
        // Fórmula: costo_frag_cf_cv × 1.30
        $data['precio_30'] = round($costoFrag * 1.30, 2);

        // Cálculo 5: PRECIO 50% (50% de ganancia)
        // Fórmula: costo_frag_cf_cv × 1.50
        $data['precio_50'] = round($costoFrag * 1.50, 2);

        // Cálculo 6: PRECIO 75% (75% de ganancia)
        // Fórmula: costo_frag_cf_cv × 1.75
        $data['precio_75'] = round($costoFrag * 1.75, 2);

        // Cálculo 7: PRECIO 100% (100% de ganancia - doble del costo)
        // Fórmula: costo_frag_cf_cv × 2.00
        $data['precio_100'] = round($costoFrag * 2.00, 2);

        return $data;
    }

    /**
     * Mostrar formulario de importación
     */
    public function mostrarImportar()
    {
        $categorias = Categoria::where('estado', true)->orderBy('nombre')->get();
        return view('productos.importar', compact('categorias'));
    }

    /**
     * Descargar plantilla Excel de ejemplo
     */
    public function descargarPlantilla()
    {
        return \Maatwebsite\Excel\Facades\Excel::download(
            new \App\Exports\PlantillaProductosExport(),
            'plantilla_productos.xlsx'
        );
    }

    /**
     * Procesar archivo Excel e importar productos
     */
    public function importar(Request $request)
    {
        $request->validate([
            'archivo' => 'required|mimes:xlsx,xls,csv|max:10240', // Max 10MB
        ], [
            'archivo.required' => 'Debe seleccionar un archivo Excel',
            'archivo.mimes' => 'El archivo debe ser de tipo Excel (.xlsx, .xls) o CSV',
            'archivo.max' => 'El archivo no debe superar los 10MB',
        ]);

        try {
            $import = new \App\Imports\ProductosImport();
            \Maatwebsite\Excel\Facades\Excel::import($import, $request->file('archivo'));

            $importedCount = $import->getImportedCount();
            $errors = $import->getErrors();

            if (count($errors) > 0) {
                // Hay errores
                if ($importedCount > 0) {
                    return redirect()->route('productos.index')
                        ->with('warning', "Se importaron {$importedCount} productos correctamente, pero hubo algunos errores:")
                        ->with('errores', $errors);
                } else {
                    return redirect()->route('productos.importar')
                        ->with('error', 'No se pudo importar ningún producto. Revisa los errores:')
                        ->with('errores', $errors);
                }
            }

            if ($importedCount > 0) {
                return redirect()->route('productos.index')
                    ->with('success', "Se importaron {$importedCount} productos correctamente.");
            } else {
                return redirect()->route('productos.importar')
                    ->with('warning', 'No se encontraron productos válidos para importar en el archivo.');
            }

        } catch (\Exception $e) {
            return redirect()->route('productos.importar')
                ->with('error', 'Error al importar el archivo: ' . $e->getMessage());
        }
    }
}
