Tul xxx Tul

Viewing: PrestamoController.php

<?php

namespace App\Http\Controllers;

use App\Models\CajaDiaria;
use App\Models\Cliente;
use App\Models\MovimientoCaja;
use App\Models\Prestamo;
use App\Models\PrestamoItem;
use App\Models\PrestamoMovimiento;
use App\Models\Producto;
use App\Models\ProductoInstancia;
use App\Models\Empresa;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;

class PrestamoController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');
    }

    /**
     * Verifica contratos vencidos y pasa los artículos a inventario
     */
    private function procesarContratosVencidos()
    {
        $hoy = Carbon::today();
        
        // Buscar contratos vigentes que ya vencieron
        $contratosVencidos = Prestamo::where('estado', 'vigente')
            ->where('fecha_vencimiento', '<', $hoy)
            ->with('items.productoInstancia')
            ->get();
        
        foreach ($contratosVencidos as $prestamo) {
            // Cambiar estado a vencido - el artículo pasa a inventario
            $prestamo->estado = 'vencido';
            $prestamo->save();
            
            // Liberar instancias de producto si existen
            foreach ($prestamo->items as $item) {
                if ($item->producto_instancia_id && $item->productoInstancia) {
                    $item->productoInstancia->estado = 'disponible';
                    $item->productoInstancia->prestamo_actual_id = null;
                    $item->productoInstancia->save();
                }
            }
        }
        
        return $contratosVencidos->count();
    }

    public function index(Request $request)
    {
        // Procesar contratos vencidos automáticamente
        $this->procesarContratosVencidos();
        
        $query = Prestamo::with(['cliente', 'items.producto']);
        
        // Por defecto mostrar solo contratos vigentes (no cerrados ni vencidos)
        // A menos que se especifique un estado o se pida ver historial
        if ($request->filled('estado')) {
            $query->where('estado', $request->estado);
        } elseif (!$request->filled('historial')) {
            // Por defecto solo vigentes
            $query->where('estado', 'vigente');
        }
        
        // Filtro por búsqueda (cliente, producto, contrato)
        if ($request->filled('buscar')) {
            $buscar = $request->buscar;
            $query->where(function($q) use ($buscar) {
                $q->where('codigo_instancia', 'like', "%{$buscar}%")
                  ->orWhereHas('cliente', function($qc) use ($buscar) {
                      $qc->where('nombres', 'like', "%{$buscar}%")
                         ->orWhere('apellidos', 'like', "%{$buscar}%")
                         ->orWhere('cedula', 'like', "%{$buscar}%");
                  })
                  ->orWhereHas('items.producto', function($qp) use ($buscar) {
                      $qp->where('nombre', 'like', "%{$buscar}%")
                         ->orWhere('codigo', 'like', "%{$buscar}%")
                         ->orWhere('placa', 'like', "%{$buscar}%")
                         ->orWhere('serial', 'like', "%{$buscar}%");
                  });
            });
        }
        
        // Filtro por vencimiento
        if ($request->filled('vencimiento')) {
            $hoy = Carbon::today();
            switch ($request->vencimiento) {
                case 'vencidos':
                    $query->where('fecha_vencimiento', '<', $hoy)->where('estado', 'vigente');
                    break;
                case 'proximos':
                    $query->whereBetween('fecha_vencimiento', [$hoy, $hoy->copy()->addDays(7)])->where('estado', 'vigente');
                    break;
                case 'vigentes':
                    $query->where('fecha_vencimiento', '>', $hoy->copy()->addDays(7))->where('estado', 'vigente');
                    break;
            }
        }
        
        $prestamos = $query->orderByDesc('id')->paginate(15)->withQueryString();
        
        // Estadísticas para el dashboard
        $hoy = Carbon::today();
        $inicioMes = Carbon::now()->startOfMonth();
        $finMes = Carbon::now()->endOfMonth();
        
        // Ingresos de compraventa (prórrogas, abonos, cierres)
        $ingresosHoy = MovimientoCaja::where('tipo', 'ingreso')
            ->where('referencia_tipo', 'App\\Models\\Prestamo')
            ->whereDate('fecha', $hoy)
            ->sum('monto');
        
        $ingresosMes = MovimientoCaja::where('tipo', 'ingreso')
            ->where('referencia_tipo', 'App\\Models\\Prestamo')
            ->whereBetween('fecha', [$inicioMes, $finMes])
            ->sum('monto');
        
        // Intereses generados este mes
        $interesesMes = PrestamoMovimiento::whereBetween('fecha', [$inicioMes, $finMes])
            ->sum('monto_interes');
        
        // Capital recuperado este mes
        $capitalRecuperadoMes = PrestamoMovimiento::whereBetween('fecha', [$inicioMes, $finMes])
            ->sum('monto_capital');
        
        $stats = [
            'total_activos' => Prestamo::where('estado', 'vigente')->count(),
            'vencidos' => Prestamo::where('estado', 'vigente')->where('fecha_vencimiento', '<', $hoy)->count(),
            'proximos_vencer' => Prestamo::where('estado', 'vigente')->whereBetween('fecha_vencimiento', [$hoy, $hoy->copy()->addDays(7)])->count(),
            'capital_activo' => Prestamo::where('estado', 'vigente')->sum('saldo_capital'),
            'ingresos_hoy' => $ingresosHoy,
            'ingresos_mes' => $ingresosMes,
            'intereses_mes' => $interesesMes,
            'capital_recuperado_mes' => $capitalRecuperadoMes,
            'total_cerrados' => Prestamo::where('estado', 'cerrado')->count(),
            'total_vencidos_historial' => Prestamo::where('estado', 'vencido')->count(),
        ];
        
        $verHistorial = $request->filled('historial');

        return view('prestamos.index', compact('prestamos', 'stats', 'verHistorial'));
    }

    public function create()
    {
        $clientes = Cliente::where('estado', true)->orderBy('nombres')->get();
        
        // IDs de productos que ya tienen cualquier contrato (vigente o cerrado = ya fue entregado)
        // Solo los vencidos quedan disponibles (pasaron a inventario)
        $productosConContrato = PrestamoItem::whereHas('prestamo', function($q) {
            $q->whereIn('estado', ['activo', 'vigente', 'cerrado']);
        })->pluck('producto_id')->toArray();
        
        // Solo mostrar productos de compraventa que:
        // - NO tienen contrato activo/vigente/cerrado
        // - O tienen contrato vencido (artículo pasó a inventario y está disponible para venta/nuevo préstamo)
        $productos = Producto::where('estado', true)
            ->whereNotNull('tipo_articulo')
            ->whereNotIn('id', $productosConContrato)
            ->orderBy('nombre')
            ->get();

        // Generar siguiente número de contrato
        $ultimoContrato = Prestamo::max('id') ?? 0;
        $siguienteContrato = str_pad($ultimoContrato + 1, 4, '0', STR_PAD_LEFT);

        // Generar siguiente código de producto
        $ultimoProductoCV = Producto::where('codigo', 'like', 'CV-%')
            ->orderByRaw('CAST(SUBSTRING(codigo, 4) AS UNSIGNED) DESC')
            ->first();
        
        if ($ultimoProductoCV) {
            $numeroActual = intval(substr($ultimoProductoCV->codigo, 3));
            $siguienteProducto = 'CV-' . str_pad($numeroActual + 1, 4, '0', STR_PAD_LEFT);
        } else {
            $siguienteProducto = 'CV-0001';
        }

        return view('prestamos.create', compact('clientes', 'productos', 'siguienteContrato', 'siguienteProducto'));
    }

    public function store(Request $request)
    {
        $request->validate([
            'cliente_id' => 'required|exists:clientes,id',
            'producto_id' => 'required|exists:productos,id',
            'codigo_instancia' => 'required|string|max:255',
            'capital_inicial' => 'required|numeric|min:0.01',
            'tasa_mensual' => 'required|numeric|min:0',
            'fecha_inicio' => 'required|date',
            'meses_plazo' => 'required|integer|min:1',
            'observaciones' => 'nullable|string'
        ]);

        $caja = CajaDiaria::obtenerCajaAbierta();
        if (!$caja) {
            return back()->with('error', 'No hay ninguna caja abierta. Debe abrir caja antes de crear un préstamo.')->withInput();
        }

        try {
            $prestamo = DB::transaction(function () use ($request, $caja) {
                $fechaInicio = Carbon::parse($request->fecha_inicio)->startOfDay();
                $fechaVencimiento = $fechaInicio->copy()->addDays(35 * (int)$request->meses_plazo);

                $prestamo = Prestamo::create([
                    'cliente_id' => $request->cliente_id,
                    'user_id' => Auth::id(),
                    'fecha_inicio' => $fechaInicio,
                    'fecha_vencimiento' => $fechaVencimiento,
                    'fecha_corte_interes' => $fechaInicio,
                    'tasa_mensual' => $request->tasa_mensual,
                    'dias_ciclo' => 35,
                    'capital_inicial' => $request->capital_inicial,
                    'saldo_capital' => $request->capital_inicial,
                    'interes_acumulado' => 0,
                    'estado' => 'vigente',
                    'observaciones' => $request->observaciones,
                ]);

                $producto = Producto::findOrFail($request->producto_id);
                if (!$producto->maneja_instancias) {
                    $producto->maneja_instancias = true;
                    $producto->save();
                }

                $instancia = ProductoInstancia::create([
                    'producto_id' => $producto->id,
                    'codigo_instancia' => $request->codigo_instancia,
                    'estado' => 'en_prestamo',
                    'prestamo_actual_id' => $prestamo->id,
                ]);

                PrestamoItem::create([
                    'prestamo_id' => $prestamo->id,
                    'producto_id' => $producto->id,
                    'producto_instancia_id' => $instancia->id,
                    'cantidad' => 1
                ]);

                $producto->stock = (int)$producto->stock + 1;
                $producto->save();

                $movCaja = MovimientoCaja::create([
                    'caja_id' => $caja->id,
                    'fecha' => now(),
                    'tipo' => 'pago',
                    'concepto' => 'Desembolso préstamo #' . $prestamo->id,
                    'referencia_id' => $prestamo->id,
                    'referencia_tipo' => 'App\\Models\\Prestamo',
                    'monto' => $prestamo->capital_inicial,
                    'metodo_pago' => 'efectivo',
                    'observaciones' => 'Desembolso al cliente',
                    'created_by' => Auth::id(),
                    'updated_by' => Auth::id(),
                ]);

                PrestamoMovimiento::create([
                    'prestamo_id' => $prestamo->id,
                    'fecha' => now(),
                    'tipo' => 'desembolso',
                    'monto_total' => $prestamo->capital_inicial,
                    'monto_interes' => 0,
                    'monto_capital' => 0,
                    'prorroga_periodos' => 0,
                    'saldo_capital_antes' => $prestamo->saldo_capital,
                    'saldo_capital_despues' => $prestamo->saldo_capital,
                    'movimiento_caja_id' => $movCaja->id,
                    'observaciones' => 'Desembolso inicial',
                    'created_by' => Auth::id(),
                ]);

                return $prestamo;
            });

            return redirect()->route('prestamos.show', $prestamo)->with('success', 'Préstamo creado correctamente.');
        } catch (\Exception $e) {
            return back()->with('error', 'Error al crear el préstamo: ' . $e->getMessage())->withInput();
        }
    }

    public function show(Prestamo $prestamo)
    {
        $prestamo->load(['cliente', 'items.producto', 'items.productoInstancia', 'movimientos']);

        return view('prestamos.show', compact('prestamo'));
    }

    public function edit(Prestamo $prestamo)
    {
        $prestamo->load(['cliente', 'items.producto']);
        
        // Calcular meses de plazo actual
        $diasPrestamo = Carbon::parse($prestamo->fecha_inicio)->diffInDays($prestamo->fecha_vencimiento);
        $diasCiclo = $prestamo->dias_ciclo ?: 35;
        $mesesPlazo = $diasCiclo > 0 ? ceil($diasPrestamo / $diasCiclo) : 1;
        
        return view('prestamos.edit', compact('prestamo', 'mesesPlazo'));
    }

    public function update(Request $request, Prestamo $prestamo)
    {
        $request->validate([
            'tasa_mensual' => 'required|numeric|min:0',
            'meses_plazo' => 'required|integer|min:1',
            'observaciones' => 'nullable|string'
        ]);

        try {
            $fechaInicio = Carbon::parse($prestamo->fecha_inicio)->startOfDay();
            $fechaVencimiento = $fechaInicio->copy()->addDays(35 * (int)$request->meses_plazo);

            $prestamo->update([
                'tasa_mensual' => $request->tasa_mensual,
                'fecha_vencimiento' => $fechaVencimiento,
                'observaciones' => $request->observaciones,
            ]);

            return redirect()->route('prestamos.show', $prestamo)->with('success', 'Préstamo actualizado correctamente.');
        } catch (\Exception $e) {
            return back()->with('error', 'Error al actualizar el préstamo: ' . $e->getMessage())->withInput();
        }
    }

    public function registrarMovimiento(Request $request, Prestamo $prestamo)
    {
        $request->validate([
            'fecha' => 'required|date',
            'monto_interes' => 'nullable|numeric|min:0',
            'monto_capital' => 'nullable|numeric|min:0',
            'metodo_pago' => 'required|string|max:50',
            'observaciones' => 'nullable|string'
        ]);

        $montoIngresadoInteres = (float)($request->monto_interes ?? 0);
        $montoIngresadoCapital = (float)($request->monto_capital ?? 0);
        $montoTotal = $montoIngresadoInteres + $montoIngresadoCapital;

        if ($montoTotal <= 0) {
            return back()->with('error', 'Debe registrar un monto de interés y/o capital.');
        }

        $caja = CajaDiaria::obtenerCajaAbierta();
        if (!$caja) {
            return back()->with('error', 'No hay ninguna caja abierta. Debe abrir caja antes de registrar pagos.');
        }

        try {
            DB::transaction(function () use ($request, $prestamo, $caja, $montoTotal, $montoIngresadoInteres, $montoIngresadoCapital) {
                $fechaPago = Carbon::parse($request->fecha)->startOfDay();

                $diasCiclo = (int)($prestamo->dias_ciclo ?: 35);
                $tasaMensual = (float)$prestamo->tasa_mensual;
                $tasaDiaria = $tasaMensual / $diasCiclo;

                $saldoAntes = (float)$prestamo->saldo_capital;
                $interesPendienteAntes = (float)($prestamo->interes_acumulado ?? 0);

                $fechaCorte = $prestamo->fecha_corte_interes ? Carbon::parse($prestamo->fecha_corte_interes)->startOfDay() : Carbon::parse($prestamo->fecha_inicio)->startOfDay();
                $diasTranscurridos = max(0, $fechaCorte->diffInDays($fechaPago, false));

                // Cálculo proporcional por días (no por períodos completos)
                $interesGenerado = round($saldoAntes * $tasaDiaria * $diasTranscurridos / 100, 0);

                // Acumular interés vencido
                $interesPendienteDespuesGenerar = round($interesPendienteAntes + $interesGenerado, 2);

                // Aplicación del pago: primero interés pendiente, luego capital.
                $pagoAInteres = min($montoTotal, $interesPendienteDespuesGenerar);
                $pagoRestante = round($montoTotal - $pagoAInteres, 2);
                $pagoACapital = min($pagoRestante, $saldoAntes);

                $interesPendienteFinal = round($interesPendienteDespuesGenerar - $pagoAInteres, 2);
                $saldoDespues = round(max(0, $saldoAntes - $pagoACapital), 2);

                // Si se pagó el interés completo, actualizar fecha de corte a la fecha de pago
                // y extender el vencimiento por un ciclo completo (prórroga)
                $periodosCubiertos = 0;
                if ($pagoAInteres >= $interesGenerado && $interesGenerado > 0) {
                    // El interés fue cubierto, mover fecha de corte a fecha de pago
                    $prestamo->fecha_corte_interes = $fechaPago;
                    // Extender vencimiento por un ciclo de 35 días
                    $prestamo->fecha_vencimiento = $fechaPago->copy()->addDays($diasCiclo);
                    $periodosCubiertos = 1;
                }

                $prestamo->interes_acumulado = $interesPendienteFinal;
                $prestamo->saldo_capital = $saldoDespues;

                // Determinar tipo de movimiento (valores permitidos: desembolso, prorroga, abono_capital, pago_mixto, cierre, ajuste_plazo)
                $tipo = 'pago_mixto';
                if ($pagoACapital >= $saldoAntes && $saldoDespues == 0) {
                    $tipo = 'cierre'; // Retiro total del artículo - cierra el contrato
                } elseif ($pagoAInteres > 0 && $pagoACapital == 0) {
                    $tipo = 'prorroga'; // Solo pagó interés
                } elseif ($pagoAInteres > 0 && $pagoACapital > 0) {
                    $tipo = 'pago_mixto'; // Pagó interés y abonó a capital
                } elseif ($pagoACapital > 0) {
                    $tipo = 'abono_capital';
                }

                $movCaja = MovimientoCaja::create([
                    'caja_id' => $caja->id,
                    'fecha' => now(),
                    'tipo' => 'ingreso',
                    'concepto' => 'Pago préstamo #' . $prestamo->id,
                    'referencia_id' => $prestamo->id,
                    'referencia_tipo' => 'App\\Models\\Prestamo',
                    'monto' => $montoTotal,
                    'metodo_pago' => $request->metodo_pago,
                    'observaciones' => $request->observaciones,
                    'created_by' => Auth::id(),
                    'updated_by' => Auth::id(),
                ]);

                PrestamoMovimiento::create([
                    'prestamo_id' => $prestamo->id,
                    'fecha' => $fechaPago,
                    'tipo' => $tipo,
                    'monto_total' => $montoTotal,
                    'monto_interes' => $pagoAInteres,
                    'monto_capital' => $pagoACapital,
                    'prorroga_periodos' => $periodosCubiertos,
                    'saldo_capital_antes' => $saldoAntes,
                    'saldo_capital_despues' => $saldoDespues,
                    'movimiento_caja_id' => $movCaja->id,
                    'observaciones' => $request->observaciones,
                    'created_by' => Auth::id(),
                ]);

                if ($prestamo->saldo_capital <= 0 && $prestamo->interes_acumulado <= 0) {
                    $prestamo->estado = 'cerrado';

                    foreach ($prestamo->items as $item) {
                        if ($item->producto_instancia_id) {
                            $inst = $item->productoInstancia;
                            if ($inst) {
                                $inst->estado = 'disponible';
                                $inst->prestamo_actual_id = null;
                                $inst->save();
                            }
                        }
                    }
                }

                $prestamo->save();
            });

            return redirect()->route('prestamos.show', $prestamo)->with('success', 'Movimiento registrado correctamente.');
        } catch (\Exception $e) {
            return back()->with('error', 'Error al registrar movimiento: ' . $e->getMessage());
        }
    }

    public function storeProducto(Request $request)
    {
        $request->validate([
            'codigo' => 'required|string|max:50|unique:productos,codigo',
            'nombre' => 'required|string|max:255',
            'marca' => 'nullable|string|max:100',
            'modelo' => 'nullable|string|max:100',
            'descripcion' => 'nullable|string',
            'tipo_articulo' => 'nullable|string|max:50',
            'placa' => 'nullable|string|max:20',
            'serial' => 'nullable|string|max:100',
            'peso_gramos' => 'nullable|numeric|min:0',
            'material' => 'nullable|string|max:50',
            'kilates' => 'nullable|string|max:10',
            'color_pieza' => 'nullable|string|max:50',
            'foto' => 'nullable|image|max:2048'
        ]);

        try {
            $fotoPath = null;
            if ($request->hasFile('foto')) {
                $fotoPath = $request->file('foto')->store('productos/compraventa', 'public');
            }

            $producto = Producto::create([
                'codigo' => $request->codigo,
                'nombre' => $request->nombre,
                'marca' => $request->marca,
                'modelo' => $request->modelo,
                'descripcion' => $request->descripcion,
                'tipo_articulo' => $request->tipo_articulo,
                'placa' => $request->placa,
                'serial' => $request->serial,
                'peso_gramos' => $request->peso_gramos,
                'material' => $request->material,
                'kilates' => $request->kilates,
                'color_pieza' => $request->color_pieza,
                'foto' => $fotoPath,
                'precio_compra' => 0,
                'precio_venta' => 0,
                'precio_final' => 0,
                'stock' => 0,
                'stock_minimo' => 0,
                'estado' => true,
                'maneja_instancias' => true,
            ]);

            // Calcular siguiente código disponible
            $ultimoProductoCV = Producto::where('codigo', 'like', 'CV-%')
                ->orderByRaw('CAST(SUBSTRING(codigo, 4) AS UNSIGNED) DESC')
                ->first();
            
            $siguienteCodigo = 'CV-0001';
            if ($ultimoProductoCV) {
                $numeroActual = intval(substr($ultimoProductoCV->codigo, 3));
                $siguienteCodigo = 'CV-' . str_pad($numeroActual + 1, 4, '0', STR_PAD_LEFT);
            }

            return response()->json([
                'success' => true,
                'producto' => [
                    'id' => $producto->id,
                    'codigo' => $producto->codigo,
                    'nombre' => $producto->nombre
                ],
                'siguiente_codigo' => $siguienteCodigo
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 422);
        }
    }

    public function printContrato(Prestamo $prestamo)
    {
        $prestamo->load(['cliente', 'items.producto']);
        
        // Obtener datos de la empresa del tenant actual
        $empresaModel = Empresa::first();
        
        $empresa = (object) [
            'nombre' => $empresaModel->nombre_comercial ?? config('app.name', 'COMPRAVENTA'),
            'razon_social' => $empresaModel->razon_social ?? '',
            'direccion' => $empresaModel->direccion ?? 'Dirección',
            'telefono' => $empresaModel->telefono ?? 'Teléfono',
            'nit' => $empresaModel->nit ?? 'NIT',
            'logo' => $empresaModel->logo ?? null,
            'regimen' => $empresaModel->regimen_tributario ?? 'no_responsable_iva',
            'representante' => 'Representante Legal',
            'cedula_representante' => '',
            'ciudad' => 'Ciudad'
        ];
        
        // Convertir capital a letras
        $prestamo->capital_en_letras = $this->numeroALetras($prestamo->capital_inicial);
        
        // Calcular número de ciclos/meses desde las fechas
        $diasPrestamo = \Carbon\Carbon::parse($prestamo->fecha_inicio)->diffInDays($prestamo->fecha_vencimiento);
        $diasCiclo = $prestamo->dias_ciclo ?: 35;
        $mesesPlazo = $diasCiclo > 0 ? ceil($diasPrestamo / $diasCiclo) : 1;
        
        // Usar saldo_capital actual (después de abonos) para calcular retroventa
        $capitalActual = $prestamo->saldo_capital;
        $valorRetroventa = $capitalActual + ($capitalActual * $prestamo->tasa_mensual * $mesesPlazo / 100);
        $retroventa_en_letras = $this->numeroALetras($valorRetroventa);
        
        return view('prestamos.contrato-print', compact('prestamo', 'empresa', 'retroventa_en_letras'));
    }

    private function numeroALetras($numero)
    {
        $unidades = ['', 'UN', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE'];
        $decenas = ['', 'DIEZ', 'VEINTE', 'TREINTA', 'CUARENTA', 'CINCUENTA', 'SESENTA', 'SETENTA', 'OCHENTA', 'NOVENTA'];
        $especiales = ['ONCE', 'DOCE', 'TRECE', 'CATORCE', 'QUINCE', 'DIECISÉIS', 'DIECISIETE', 'DIECIOCHO', 'DIECINUEVE'];
        $centenas = ['', 'CIENTO', 'DOSCIENTOS', 'TRESCIENTOS', 'CUATROCIENTOS', 'QUINIENTOS', 'SEISCIENTOS', 'SETECIENTOS', 'OCHOCIENTOS', 'NOVECIENTOS'];
        
        $numero = intval($numero);
        
        if ($numero == 0) return 'CERO';
        if ($numero == 100) return 'CIEN';
        if ($numero == 1000) return 'MIL';
        
        $resultado = '';
        
        // Millones
        if ($numero >= 1000000) {
            $millones = intval($numero / 1000000);
            if ($millones == 1) {
                $resultado .= 'UN MILLÓN ';
            } else {
                $resultado .= $this->numeroALetras($millones) . ' MILLONES ';
            }
            $numero = $numero % 1000000;
        }
        
        // Miles
        if ($numero >= 1000) {
            $miles = intval($numero / 1000);
            if ($miles == 1) {
                $resultado .= 'MIL ';
            } else {
                $resultado .= $this->numeroALetras($miles) . ' MIL ';
            }
            $numero = $numero % 1000;
        }
        
        // Centenas
        if ($numero >= 100) {
            $resultado .= $centenas[intval($numero / 100)] . ' ';
            $numero = $numero % 100;
        }
        
        // Decenas y unidades
        if ($numero >= 20) {
            $resultado .= $decenas[intval($numero / 10)];
            if ($numero % 10 > 0) {
                $resultado .= ' Y ' . $unidades[$numero % 10];
            }
        } elseif ($numero >= 11 && $numero <= 19) {
            $resultado .= $especiales[$numero - 11];
        } elseif ($numero == 10) {
            $resultado .= 'DIEZ';
        } elseif ($numero > 0) {
            $resultado .= $unidades[$numero];
        }
        
        return trim($resultado);
    }

    public function storeCliente(Request $request)
    {
        $request->validate([
            'cedula' => 'required|string|max:20|unique:clientes,cedula',
            'nombres' => 'required|string|max:100',
            'apellidos' => 'required|string|max:100',
            'tipo_documento' => 'nullable|string|max:10',
            'ciudad_expedicion' => 'required|string|max:100',
            'telefono' => 'nullable|string|max:20',
            'email' => 'nullable|email|max:100',
            'direccion' => 'nullable|string|max:255'
        ]);

        try {
            $cliente = Cliente::create([
                'cedula' => $request->cedula,
                'tipo_documento' => $request->tipo_documento ?? 'CC',
                'ciudad_expedicion' => $request->ciudad_expedicion,
                'nombres' => $request->nombres,
                'apellidos' => $request->apellidos,
                'telefono' => $request->telefono,
                'email' => $request->email,
                'direccion' => $request->direccion,
                'estado' => true,
            ]);

            return response()->json([
                'success' => true,
                'cliente' => [
                    'id' => $cliente->id,
                    'cedula' => $cliente->cedula,
                    'nombres' => $cliente->nombres,
                    'apellidos' => $cliente->apellidos
                ]
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 422);
        }
    }
}
User / IP	: 216.73.216.146
Host / Server	: 45.84.207.204 / aircan.me
System	: Linux lt-bnk-web1726.main-hosting.eu 5.14.0-611.36.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Mar 3 11:23:52 EST 2026 x86_64