views

from django.contrib import messages
from django.views.decorators.http import require_http_methods
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required, user_passes_test
from django.http import HttpResponse, JsonResponse, HttpResponseNotAllowed
from django.shortcuts import get_object_or_404, render, redirect
from django.views.decorators.csrf import csrf_exempt
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
import random, json
import traceback  # Importa traceback una sola vez
from .models import Cliente, Contrato, Servicio, Usuario, Rol, Empleado, Zona, Avenida, Direccion # Importa todos los modelos en una línea
from .forms import ClienteForm, ContratoForm # Importa los formularios
from django.core.paginator import Paginator
from django.db.models import Q  # Importa Q para consultas OR
from .forms import ContratoForm



@csrf_exempt
def registrar_cliente(request):
    if request.method == "POST":
        try:
            form = ClienteForm(request.POST)
            if form.is_valid():
                form.save()
                return JsonResponse({"mensaje": "Cliente agregado correctamente"}, status=200)
            else:
                return JsonResponse({"error": "Error en el formulario", "detalles": form.errors}, status=400)
        except Exception as e:
            # Capturamos el traceback para ver detalles del error.
            traceback_str = traceback.format_exc()
            return JsonResponse({"error": "Error interno", "detalles": traceback_str}, status=500)
    return JsonResponse({"error": "Método no permitido"}, status=405)






def login_view(request):
    if request.method == "POST":
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('dashboard')  # Redirigir al dashboard si el login es exitoso
        else:
            messages.error(request, "Usuario o contraseña incorrectos")
    return render(request, 'usuarios/login.html')

def logout_view(request):
    logout(request)
    return redirect('login')  # Redirigir al login después de cerrar sesión

@login_required
def dashboard(request):
    return render(request, 'usuarios/dashboard.html')

### CRUD USUARIOS ###

@login_required
def lista_usuarios(request):
    usuarios = Usuario.objects.all()
    roles = Rol.objects.all()  # ✅ Asegurar que los roles estén disponibles en la plantilla
    return render(request, 'usuarios/lista_usuarios.html', {'usuarios': usuarios, 'roles': roles})

@login_required
def editar_usuario(request, user_id):
    usuario = get_object_or_404(Usuario, id=user_id)

    if request.method == 'POST':
        usuario.username = request.POST['username']
        usuario.first_name = request.POST['first_name']
        usuario.last_name = request.POST['last_name']
        usuario.email = request.POST['email']
        usuario.rol_id = request.POST.get('rol')
        usuario.estatus = 'estatus' in request.POST  # Checkbox activo/inactivo
        usuario.save()
        messages.success(request, "Usuario actualizado correctamente.")
        return redirect('lista_usuarios')

    roles = Rol.objects.all()
    return render(request, 'usuarios/editar_usuario.html', {'usuario': usuario, 'roles': roles})

@login_required
def eliminar_usuario(request, user_id):
    usuario = get_object_or_404(Usuario, id=user_id)
    usuario.delete()
    messages.success(request, "Usuario eliminado correctamente.")
    return redirect('lista_usuarios')

@login_required
def crear_usuario(request):
    if request.method == "POST":
        username = request.POST.get('username').strip()
        first_name = request.POST.get('first_name').strip()
        last_name = request.POST.get('last_name').strip()
        email = request.POST.get('email').strip()
        password = request.POST.get('password')
        rol_id = request.POST.get('rol')

        # Validar que no haya campos vacíos
        if not username or not first_name or not last_name or not email or not password or not rol_id:
            messages.error(request, "Todos los campos son obligatorios.")
            return redirect('lista_usuarios')

        # Validar si el usuario ya existe
        if Usuario.objects.filter(username=username).exists():
            messages.error(request, "El nombre de usuario ya está en uso.")
            return redirect('lista_usuarios')

        # Verificar si el rol existe en la base de datos
        try:
            rol = Rol.objects.get(id=rol_id)
        except Rol.DoesNotExist:
            messages.error(request, "El rol seleccionado no es válido.")
            return redirect('lista_usuarios')

        # Crear usuario y cifrar la contraseña
        nuevo_usuario = Usuario(
            username=username,
            first_name=first_name,
            last_name=last_name,
            email=email,
            rol=rol
        )
        nuevo_usuario.set_password(password)  # 🔐 Cifra la contraseña
        nuevo_usuario.save()

        messages.success(request, f"Usuario '{username}' creado correctamente.")
        return redirect('lista_usuarios')

    # Si el método no es POST, regresar la lista de usuarios
    usuarios = Usuario.objects.all()
    roles = Rol.objects.all()
    return render(request, 'usuarios/lista_usuarios.html', {'usuarios': usuarios, 'roles': roles})


### CRUD EMPLEADOS ###

@login_required
def lista_empleados(request):
    empleados = Empleado.objects.all()
    return render(request, 'usuarios/lista_empleados.html', {'empleados': empleados})

@login_required
def crear_empleado(request):
    if request.method == "POST":
        nombre = request.POST['nombre']
        apellido = request.POST['apellido']
        dni = request.POST['dni']
        rol_id = request.POST.get('rol')
        rol = Rol.objects.get(id=rol_id)

        Empleado.objects.create(nombre=nombre, apellido=apellido, dni=dni, rol=rol)
        messages.success(request, "Empleado agregado correctamente.")
        return redirect('lista_empleados')

    roles = Rol.objects.all()
    return render(request, 'usuarios/crear_empleado.html', {'roles': roles})

@login_required
def editar_empleado(request, emp_id):
    empleado = get_object_or_404(Empleado, id=emp_id)

    if request.method == "POST":
        empleado.nombre = request.POST['nombre']
        empleado.apellido = request.POST['apellido']
        empleado.dni = request.POST['dni']
        empleado.rol_id = request.POST.get('rol')
        empleado.save()
        messages.success(request, "Empleado actualizado correctamente.")
        return redirect('lista_empleados')

    roles = Rol.objects.all()
    return render(request, 'usuarios/editar_empleado.html', {'empleado': empleado, 'roles': roles})

@login_required
def eliminar_empleado(request, emp_id):
    empleado = get_object_or_404(Empleado, id=emp_id)
    empleado.delete()
    messages.success(request, "Empleado eliminado correctamente.")
    return redirect('lista_empleados')

### CRUD ROLES ###

@login_required
def lista_roles(request):
    roles = Rol.objects.all()
    return render(request, 'usuarios/lista_roles.html', {'roles': roles})

@login_required
def crear_rol(request):
    if request.method == "POST":
        nombre = request.POST['nombre']
        Rol.objects.create(nombre=nombre)
        messages.success(request, "Rol creado correctamente.")
        return redirect('lista_roles')

    return render(request, 'usuarios/crear_rol.html')

@login_required
def editar_rol(request, rol_id):
    rol = get_object_or_404(Rol, id=rol_id)

    if request.method == "POST":
        rol.nombre = request.POST['nombre']
        rol.save()
        messages.success(request, "Rol actualizado correctamente.")
        return redirect('lista_roles')

    return render(request, 'usuarios/editar_rol.html', {'rol': rol})

@login_required
def eliminar_rol(request, rol_id):
    rol = get_object_or_404(Rol, id=rol_id)
    rol.delete()
    messages.success(request, "Rol eliminado correctamente.")
    return redirect('lista_roles')



@login_required
def editar_usuario(request, user_id):
    usuario = get_object_or_404(Usuario, id=user_id)

    if request.method == "POST":
        usuario.username = request.POST.get('username').strip()
        usuario.first_name = request.POST.get('first_name').strip()
        usuario.last_name = request.POST.get('last_name').strip()
        usuario.email = request.POST.get('email').strip()
        rol_id = request.POST.get('rol')
        usuario.estatus = 'estatus' in request.POST  # Checkbox para activar/desactivar usuario

        # Validar si el usuario ya existe con otro ID
        if Usuario.objects.exclude(id=user_id).filter(username=usuario.username).exists():
            messages.error(request, "El nombre de usuario ya está en uso por otro usuario.")
            return redirect('lista_usuarios')

        # Verificar si el rol existe
        try:
            usuario.rol = Rol.objects.get(id=rol_id)
        except Rol.DoesNotExist:
            messages.error(request, "El rol seleccionado no es válido.")
            return redirect('lista_usuarios')

        usuario.save()
        messages.success(request, f"Usuario '{usuario.username}' actualizado correctamente.")
        return redirect('lista_usuarios')

    roles = Rol.objects.all()
    return render(request, 'usuarios/editar_usuario.html', {'usuario': usuario, 'roles': roles})


@login_required
def eliminar_usuario(request, user_id):
    usuario = get_object_or_404(Usuario, id=user_id)
    usuario.delete()
    messages.success(request, f"Usuario '{usuario.username}' eliminado correctamente.")
    return redirect('lista_usuarios')



# Función para verificar si el usuario es administrador
def es_admin(user):
    return user.is_authenticated and user.is_superuser

### RESTRINGIR VISTAS A ADMINISTRADORES ###

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')  # Redirigir si no es admin
def lista_usuarios(request):
    usuarios = Usuario.objects.all()
    roles = Rol.objects.all()
    return render(request, 'usuarios/lista_usuarios.html', {'usuarios': usuarios, 'roles': roles})

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')
def crear_usuario(request):
    if request.method == "POST":
        username = request.POST.get('username').strip()
        first_name = request.POST.get('first_name').strip()
        last_name = request.POST.get('last_name').strip()
        email = request.POST.get('email').strip()
        password = request.POST.get('password')
        rol_id = request.POST.get('rol')

        if Usuario.objects.filter(username=username).exists():
            messages.error(request, "El nombre de usuario ya está en uso.")
            return redirect('lista_usuarios')

        try:
            rol = Rol.objects.get(id=rol_id)
        except Rol.DoesNotExist:
            messages.error(request, "El rol seleccionado no es válido.")
            return redirect('lista_usuarios')

        nuevo_usuario = Usuario(
            username=username,
            first_name=first_name,
            last_name=last_name,
            email=email,
            rol=rol
        )
        nuevo_usuario.set_password(password)
        nuevo_usuario.save()

        messages.success(request, f"Usuario '{username}' creado correctamente.")
        return redirect('lista_usuarios')

    return redirect('lista_usuarios')

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')
def eliminar_usuario(request, user_id):
    usuario = get_object_or_404(Usuario, id=user_id)
    usuario.delete()
    messages.success(request, f"Usuario '{usuario.username}' eliminado correctamente.")
    return redirect('lista_usuarios')

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')
def lista_roles(request):
    roles = Rol.objects.all()
    return render(request, 'usuarios/lista_roles.html', {'roles': roles})

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')
def crear_rol(request):
    if request.method == "POST":
        nombre = request.POST['nombre']
        Rol.objects.create(nombre=nombre)
        messages.success(request, "Rol creado correctamente.")
        return redirect('lista_roles')

    return render(request, 'usuarios/crear_rol.html')

@login_required
@user_passes_test(es_admin, login_url='/dashboard/')
def eliminar_rol(request, rol_id):
    rol = get_object_or_404(Rol, id=rol_id)
    rol.delete()
    messages.success(request, "Rol eliminado correctamente.")
    return redirect('lista_roles')


def lista_zonas(request):
    zonas = Zona.objects.all()
    return render(request, "usuarios/lista_zonas.html", {"zonas": zonas})

def crear_zona(request):
    if request.method == "POST":
        nombre = request.POST["nombre"]
        Zona.objects.create(nombre=nombre)
        messages.success(request, "Zona creada correctamente.")
        return redirect("lista_zonas")
    return redirect("lista_zonas")

def editar_zona(request, zona_id):
    zona = get_object_or_404(Zona, id=zona_id)
    if request.method == "POST":
        zona.nombre = request.POST["nombre"]
        zona.save()
        messages.success(request, "Zona actualizada correctamente.")
        return redirect("lista_zonas")
    return redirect("lista_zonas")

def eliminar_zona(request, zona_id):
    zona = get_object_or_404(Zona, id=zona_id)
    zona.delete()
    messages.success(request, "Zona eliminada correctamente.")
    return redirect("lista_zonas")


def lista_avenidas(request):
    avenidas = Avenida.objects.select_related("zona").order_by("zona_id")
    zonas = Zona.objects.all()  # Enviar zonas al template para el formulario

    return render(request, "usuarios/lista_avenidas.html", {"avenidas": avenidas, "zonas": zonas})


def crear_avenida(request):
    if request.method == "POST":
        nombre = request.POST["nombre"]
        zona_id = request.POST["zona"]
        zona = get_object_or_404(Zona, id=zona_id)
        Avenida.objects.create(nombre=nombre, zona=zona)
        messages.success(request, "Avenida creada correctamente.")
        return redirect("lista_avenidas")
    return redirect("lista_avenidas")

def editar_avenida(request, avenida_id):
    avenida = get_object_or_404(Avenida, id=avenida_id)
    if request.method == "POST":
        avenida.nombre = request.POST["nombre"]
        zona_id = request.POST["zona"]
        avenida.zona = get_object_or_404(Zona, id=zona_id)
        avenida.save()
        messages.success(request, "Avenida actualizada correctamente.")
        return redirect("lista_avenidas")
    return redirect("lista_avenidas")

def eliminar_avenida(request, avenida_id):
    avenida = get_object_or_404(Avenida, id=avenida_id)
    avenida.delete()
    messages.success(request, "Avenida eliminada correctamente.")
    return redirect("lista_avenidas")

def lista_clientes(request):
    clientes_list = Cliente.objects.all().order_by('id')

    query = request.GET.get('q')  # Obtiene el término de búsqueda del formulario

    if query:
        # Filtra clientes por nombre, documento o cualquier otro campo que desees
        clientes_list = clientes_list.filter(
            Q(nombre__icontains=query) | Q(documento__icontains=query)
        )

    paginator = Paginator(clientes_list, 6)
    page_number = request.GET.get('page')
    clientes = paginator.get_page(page_number)

    zonas = Zona.objects.all()
    return render(request, 'usuarios/lista_clientes.html', {'clientes': clientes, 'zonas': zonas})



def obtener_cliente(request, id):
    """Devuelve datos del cliente en JSON para edición"""
    cliente = get_object_or_404(Cliente, id=id)
    data = {
        "id": cliente.id,
        "documento": cliente.documento,
        "nombre": cliente.nombre,
        "apellido_paterno": cliente.apellido_paterno,
        "apellido_materno": cliente.apellido_materno,
        "fecha_nacimiento": cliente.fecha_nacimiento.strftime("%Y-%m-%d"),
        "sexo": cliente.sexo,
        "telefono": cliente.telefono,
        "email": cliente.email,
        "direccion": cliente.direccion,
        "estatus": cliente.estatus,
        "zona_id": cliente.zona.id,
        "avenida_id": cliente.avenida.id,
    }
    return JsonResponse(data)

def get_avenidas(request, zona_id):
    avenidas = Avenida.objects.filter(zona_id=zona_id).values('id', 'nombre')
    return JsonResponse({'avenidas': list(avenidas)})

def get_zonas(request):
    zonas = list(Zona.objects.values('id', 'nombre'))
    return JsonResponse({'zonas': zonas})



@require_http_methods(["GET", "POST"])
def editar_cliente(request, cliente_id):
    cliente = get_object_or_404(Cliente, id=cliente_id)

    if request.method == "GET":
        # Devolver los datos del cliente en formato JSON
        data = {
            "id": cliente.id,
            "documento": cliente.documento,
            "nombre": cliente.nombre,
            "apellido_paterno": cliente.apellido_paterno,
            "apellido_materno": cliente.apellido_materno,
            "fecha_nacimiento": cliente.fecha_nacimiento.strftime("%Y-%m-%d") if cliente.fecha_nacimiento else None,
            "sexo": cliente.sexo,
            "telefono": cliente.telefono,
            "email": cliente.email,
            "direccion": cliente.direccion,
            "estatus": cliente.estatus,
            "zona_id": cliente.zona.id if cliente.zona else None,
            "avenida_id": cliente.avenida.id if cliente.avenida else None,
        }
        return JsonResponse(data, safe=False)

    elif request.method == "POST":
        try:
            # Procesar el formulario de edición
            form = ClienteForm(request.POST, instance=cliente)
            if form.is_valid():
                cliente = form.save(commit=False)

                # Procesar el campo 'estatus' manualmente
                estatus = request.POST.get("estatus", "1")  # Por defecto, "1" (Activo)
                cliente.estatus = estatus == "1"  # Convertir a booleano

                # Guardar los cambios en la base de datos
                cliente.save()

                # Devolver una respuesta JSON con el mensaje de éxito
                return JsonResponse({
                    "message": "Cliente actualizado correctamente",
                    "id": cliente.id,
                    "estatus": cliente.estatus,  # Devolver el estado actualizado
                }, status=200)
            else:
                # Si el formulario no es válido, devolver los errores
                return JsonResponse({
                    "error": "Error en el formulario",
                    "detalles": form.errors,
                }, status=400)
        except Exception as e:
            # Manejar errores inesperados
            return JsonResponse({
                "error": "Error interno del servidor",
                "detalles": str(e),
            }, status=500)

    return JsonResponse({"error": "Método no permitido"}, status=405)



@csrf_exempt
def eliminar_cliente(request, cliente_id):
    if request.method == "DELETE":  # Verifica que el método sea DELETE
        cliente = get_object_or_404(Cliente, id=cliente_id)
        cliente.delete()
        return JsonResponse({"mensaje": "Cliente eliminado correctamente"}, status=200)

    return JsonResponse({"error": "Método no permitido"}, status=405)





from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .models import Cliente
from .forms import ClienteForm

@csrf_exempt
def agregar_cliente(request):
    if request.method == "POST":
        form = ClienteForm(request.POST)
        if form.is_valid():
            # Guardar el cliente, pero sin commit para poder modificar campos manualmente
            cliente = form.save(commit=False)

            # Procesar el campo 'estatus' manualmente
            estatus = request.POST.get("estatus", "1")  # Por defecto, "1" (Activo)
            cliente.estatus = estatus == "1"  # Convertir a booleano (True si es "1", False si es "0")

            # Guardar el cliente en la base de datos
            cliente.save()

            # Devolver una respuesta JSON con los datos del cliente
            return JsonResponse({
                "mensaje": "Cliente agregado correctamente.",
                "id": cliente.id,
                "documento": cliente.documento,
                "nombre": cliente.nombre,
                "apellido_paterno": cliente.apellido_paterno,
                "apellido_materno": cliente.apellido_materno,
                "telefono": cliente.telefono,
                "email": cliente.email,
                "estatus": cliente.estatus,  # Devolver el estado actualizado
            }, status=200)
        else:
            # Si el formulario no es válido, devolver errores
            return JsonResponse({
                "error": "Error en el formulario",
                "detalles": form.errors,
            }, status=400)
    else:
        # Si el método no es POST, devolver un error
        return JsonResponse({
            "error": "Método no permitido",
        }, status=405)


def cliente_detail(request, cliente_id):
    cliente = get_object_or_404(Cliente, pk=cliente_id)
    if request.method == "GET":
        data = {
            'id': cliente.id,
            'documento': cliente.documento,
            'nombre': cliente.nombre,
            'apellido_paterno': cliente.apellido_paterno,
            'apellido_materno': cliente.apellido_materno,
            'fecha_nacimiento': cliente.fecha_nacimiento.strftime('%Y-%m-%d'),
            'sexo': cliente.sexo,
            'telefono': cliente.telefono,
            'email': cliente.email,
            'estatus': cliente.estatus,
            'numero_cliente': cliente.numero_cliente,
            # Se devuelven todas las direcciones asociadas al cliente, incluyendo los IDs para zona y avenida
            'direcciones': [
                {
                    'id': d.id,
                    'zona': d.zona.nombre if d.zona else None,
                    'zona_id': d.zona.id if d.zona else None,
                    'avenida': d.avenida.nombre if d.avenida else None,
                    'avenida_id': d.avenida.id if d.avenida else None,
                    'direccion': d.direccion,
                } for d in cliente.direcciones.all()
            ]
        }
        return JsonResponse(data)
    elif request.method == "POST":
        # Aquí procesa la actualización de los datos del cliente
        return JsonResponse({'mensaje': 'Cliente actualizado correctamente.'})
    else:
        return HttpResponseNotAllowed(['GET', 'POST'])


def detalle_cliente(request, cliente_id):
    cliente = get_object_or_404(Cliente, pk=cliente_id)
    return render(request, 'cliente_detail.html', {'cliente': cliente})



def detalle_cliente_html(request, cliente_id):
    # Obtener el cliente (y sus direcciones) como ya lo haces en cliente_detail
    cliente = get_object_or_404(Cliente, pk=cliente_id)
    return render(request, 'usuarios/detalle_cliente.html', {'cliente': cliente})



# --- Agregado de Reportes y Generación de PDF ---
def generar_pdf_clientes(request):
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'attachment; filename="reporte_clientes.pdf"'
    pdf = canvas.Canvas(response, pagesize=letter)
    pdf.setTitle("Reporte de Clientes")
    pdf.setFont("Helvetica-Bold", 14)
    pdf.drawString(200, 750, "Reporte de Clientes")
    pdf.setFont("Helvetica", 10)
    clientes = Cliente.objects.all()
    y = 720
    for cliente in clientes:
        pdf.drawString(50, y, f"{cliente.documento} - {cliente.nombre} - {cliente.telefono} - {cliente.email}")
        y -= 20
    pdf.showPage()
    pdf.save()
    return response


# Vista para listar servicios
def lista_servicios(request):
    servicios = Servicio.objects.all()
    return render(request, 'usuarios/lista_servicios.html', {'servicios': servicios})

# Vista para agregar un servicio
def agregar_servicio(request):
    if request.method == "POST":
        nombre = request.POST.get("nombre")
        costo = request.POST.get("costo")

        if nombre and costo:
            Servicio.objects.create(nombre=nombre, costo=int(costo))
            messages.success(request, "Servicio agregado correctamente")
            return redirect("servicios")  # Redirige a la lista de servicios

    return render(request, "usuarios/lista_servicios.html")

# Vista para editar un servicio
def editar_servicio(request, servicio_id):
    servicio = get_object_or_404(Servicio, id=servicio_id)

    if request.method == "GET":
        # Retornar datos del servicio en formato JSON
        return JsonResponse({
            "id": servicio.id,
            "nombre": servicio.nombre,
            "costo": servicio.costo
        })

    elif request.method == "POST":
        try:
            servicio.nombre = request.POST.get("nombre")
            servicio.costo = int(request.POST.get("costo"))
            servicio.save()
            messages.success(request, "Servicio actualizado correctamente")
            return JsonResponse({"mensaje": "Servicio actualizado correctamente"})
        except Exception as e:
            return JsonResponse({"error": f"Error al actualizar el servicio: {str(e)}"}, status=400)

    return JsonResponse({"error": "Método no permitido"}, status=405)


# Vista para eliminar un servicio
def eliminar_servicio(request, servicio_id):
    servicio = get_object_or_404(Servicio, id=servicio_id)
    servicio.delete()
    messages.success(request, "Servicio eliminado correctamente")
    return JsonResponse({"mensaje": "Servicio eliminado correctamente"})



# Vista para listar contratos
def lista_contratos(request):
    contratos = Contrato.objects.all()
    form = ContratoForm()
    return render(request, "usuarios/lista_contratos.html", {"contratos": contratos, "form": form})


# Vista para generar número de abonado único
def generar_numero_abonado():
    return "C" + str(random.randint(100000, 999999))

def obtener_servicio(request, servicio_id):
    """ Obtiene información de un servicio específico """
    try:
        servicio = get_object_or_404(Servicio, pk=servicio_id)
        return JsonResponse({"id": servicio.id, "nombre": servicio.nombre, "costo": servicio.costo})
    except Exception as e:
        return JsonResponse({'error': f'Ocurrió un error al obtener el servicio: {e}'}, status=500)







# Vista para obtener los datos de un contrato
def obtener_contrato(request, id):
    try:
        contrato = get_object_or_404(Contrato, id=id)

        # Construir el nombre completo correctamente
        cliente = contrato.cliente
        cliente_nombre = f"{cliente.nombre} {cliente.apellido_paterno} {cliente.apellido_materno or ''}".strip()

        return JsonResponse({
            "success": True,
            "contrato": {
                "id": contrato.id,
                "cliente": cliente.id,
                "cliente_nombre": cliente_nombre,  # ✅ Usa apellido_paterno y apellido_materno
                "numero_abonado": contrato.numero_abonado,
                "descripcion": contrato.descripcion,
                "total": contrato.total
            }
        })
    except Exception as e:
        return JsonResponse({"success": False, "message": f"Error en el servidor: {str(e)}"}, status=500)


# Vista para editar un registrar_contrato
@csrf_exempt
def obtener_cliente(request, cliente_id):
    """ Devuelve los datos de un cliente en formato JSON. """
    cliente = get_object_or_404(Cliente, id=cliente_id)
    data = {
        "id": cliente.id,
        "documento": cliente.documento,
        "nombre": cliente.nombre,
        "apellido_paterno": cliente.apellido_paterno,
        "apellido_materno": cliente.apellido_materno,
        "telefono": cliente.telefono,
        "email": cliente.email,
        "direccion": cliente.direccion,
        "estatus": cliente.estatus,
    }
    return JsonResponse(data)

@csrf_exempt
def editar_cliente(request, cliente_id):
    """ Actualiza un cliente existente. """
    if request.method == "POST":
        try:
            cliente = get_object_or_404(Cliente, id=cliente_id)
            for key, value in request.POST.items():
                setattr(cliente, key, value)
            cliente.save()
            return JsonResponse({"mensaje": "Cliente actualizado correctamente"}, status=200)
        except Exception as e:
            return JsonResponse({"error": f"Error interno: {str(e)}"}, status=500)
    return JsonResponse({"error": "Método no permitido"}, status=405)







# Vista para eliminar contrato
def eliminar_contrato(request, id):
    if request.method == "DELETE":
        contrato = get_object_or_404(Contrato, id=id)
        contrato.delete()
        return JsonResponse({"success": True})
    return JsonResponse({"success": False, "error": "Método no permitido"}, status=405)


# Buscar clientes por nombre o documento
def buscar_clientes(request):
    query = request.GET.get("query", "").strip()
    if query:
        clientes = Cliente.objects.filter(nombre__icontains=query) | Cliente.objects.filter(documento__icontains=query)
        data = list(clientes.values("id", "nombre", "documento"))
        return JsonResponse(data, safe=False)
    return JsonResponse([], safe=False)






@csrf_exempt
def agregar_contrato(request):
    """ Agrega un nuevo contrato con sus servicios asociados. """
    if request.method == "POST":
        form = ContratoForm(request.POST)
        if form.is_valid():
            contrato = form.save(commit=False)
            contrato.total = contrato.calcular_total()
            contrato.save()
            form.save_m2m()
            return JsonResponse({"mensaje": "Contrato agregado correctamente"}, status=201)
        return JsonResponse({"error": "Formulario inválido", "detalles": form.errors}, status=400)
    return JsonResponse({"error": "Método no permitido"}, status=405)

@csrf_exempt
def editar_contrato(request, id):
    """ Edita los detalles de un contrato existente. """
    contrato = get_object_or_404(Contrato, id=id)
    if request.method == "POST":
        try:
            data = json.loads(request.body.decode("utf-8"))
            for key, value in data.items():
                setattr(contrato, key, value)
            contrato.save()
            return JsonResponse({"mensaje": "Contrato actualizado correctamente"}, status=200)
        except Exception as e:
            return JsonResponse({"error": f"Error interno: {str(e)}"}, status=500)
    return JsonResponse({"error": "Método no permitido"}, status=405)



def generar_numero_abonado(request):
    """
    Genera un número de abonado único basado en el último contrato registrado.editar_cliente
    """
    ultimo_contrato = Contrato.objects.order_by('-numero_abonado').first()
    nuevo_numero = (ultimo_contrato.numero_abonado + 1) if ultimo_contrato and ultimo_contrato.numero_abonado else 1000
    return JsonResponse({"numero_abonado": nuevo_numero})


def get_zonas(request):
    zonas = list(Zona.objects.values('id', 'nombre'))
    return JsonResponse({'zonas': zonas})

def obtener_avenidas(request):
    """ Devuelve la lista de avenidas filtradas por zona. """
    zona_id = request.GET.get("zona_id")
    avenidas = list(Avenida.objects.filter(zona_id=zona_id).values("id", "nombre")) if zona_id else []
    return JsonResponse({"avenidas": avenidas})





def obtener_direcciones_cliente(request, cliente_id):
    try:
        direcciones = Direccion.objects.filter(cliente_id=cliente_id).values("id", "direccion")
        return JsonResponse({"direcciones": list(direcciones)})
    except Exception as e:
        print(f"Error al obtener direcciones: {e}")  # Depuración
        return JsonResponse({"error": "Ocurrió un error al obtener las direcciones."}, status=500)


def obtener_estado_cliente(request, cliente_id):
    try:
        cliente = Cliente.objects.get(id=cliente_id)
        return JsonResponse({'estatus': cliente.estatus})  # Ajusta según el nombre del campo en el modelo
    except Cliente.DoesNotExist:
        return JsonResponse({'error': 'Cliente no encontrado'}, status=404)