from server_backsemot.models import Camion, CamionPresencial, PesajeCamion, PesajeCamionPresencial, CapacidadVehiculo, Vehiculo, Personal, CamionGD, PesajeGD
from server_backsemot.personal.personal import validaciones_basicas
from rest_framework.decorators import api_view
from server_backsemot.utiles import *
from django.db.models import Q
from environ import Env
import traceback

env = Env()
Env.read_env()

@api_view(["POST"])
def enviar_camion_pesaje(request):
    try:
        # Validación de permisos y autenticación
        validacion = validaciones_basicas(validaciones=[1, 2, 3, 4], perfiles=[1, 2, 3], request=request)
        if validacion != "ok":
            return Utiles.responder_500(validacion)
        tipo = request.POST["tipo"]
        id = request.POST["camion"]
        token = request.POST["token"]
        try:
            tipo = int(tipo)
            if tipo != 1 and tipo != 2 and tipo != 3:
                return Utiles.responder_500("Tipo debe ser 1, 2 o 3")
        except ValueError:
            return Utiles.responder_500("Tipo debe ser 1, 2 o 3")
        
        if tipo == 1:
            camion = Camion.objects.get(id=id)
        if tipo == 2:
            camion = CamionPresencial.objects.get(id=id)
        if tipo == 3:
            camion = CamionGD.objects.get(id=id)
        
        personal = Personal.objects.filter(token=token, estado=1).first()
        if not personal:
            return Utiles.responder_500("Por favor realice el login")
        camion.pesar = 1
        camion.ordena_pesaje = personal
        camion.save()
        return Utiles.responder_200("El camión se habilitó para pasar por el pesaje")
    
    except Camion.DoesNotExist:
        return Utiles.responder_500("No existe camión con el id indicado")
    except CamionPresencial.DoesNotExist:
        return Utiles.responder_500("No existe camión con el id indicado")
    except CamionGD.DoesNotExist:
        return Utiles.responder_500("No existe camión con el id indicado")
    except:
        traceback.print_exc()
        return Utiles.responder_500("Error de recepción")
    


@api_view(["POST"])
def recepcion_pesaje_romana(request):
    try:
        # Recepción de datos
        key = request.POST.get("key")
        patente = request.POST.get("patente")
        peso = request.POST.get("peso")

        # Validaciones iniciales
        if key != env('ROMANA_API_KEY'):
            return Utiles.responder_500("Token no válido")
        
        peso = float(peso)
        if peso < 1:
            return Utiles.responder_500("El peso debe ser un valor numérico igual o superior a 1")
        
        if not Utiles.valida_patente(patente):
            return Utiles.responder_500("Debe enviar una patente válida")
        
        # Buscar un camion esperando pesaje con esa patente
        camion = Camion.objects.filter(
            peso_variable=1,
            pesar=1,
            ordena_pesaje__isnull=False,
            patente=patente
        ).first()
        
        # Buscar un camion presencial esperando pesaje con esa patente
        if not camion:
            camion = CamionPresencial.objects.filter(
                peso_variable=1,
                pesar=1,
                ordena_pesaje__isnull=False,
                patente=patente
            ).first()
        
        # Buscar un camionGD esperando pesaje con esa patente
        if not camion:
            camion = CamionGD.objects.filter(
                patente=patente
            ).filter(
                Q(peso_tara=0) |
                Q(pesar=1, ordena_pesaje__isnull=False)
            ).first()
        
        if not camion:
            return Utiles.responder_500("No existe camión con la patente indicada esperando pesaje")
        
        # Crear el registro de pesaje
        pesaje_inicial = False
        if isinstance(camion, Camion):
            p = PesajeCamion()
            camion.cantidad = peso
        elif isinstance(camion, CamionPresencial):
            p = PesajeCamionPresencial()
            v = Vehiculo.objects.filter(variable=1).first()
            if not v:
                return Utiles.responder_500("Falta vehículo variable en vehículos")
            cv = CapacidadVehiculo.objects.filter(vehiculo=v, capacidad=peso).first()
            if not cv:
                cv = CapacidadVehiculo()
                cv.activo = 1
                cv.vehiculo = v
                cv.capacidad = peso
                cv.save()
            camion.capacidad = cv
        else:
            if camion.peso_tara == 0:
                camion.peso_tara = peso
                pesaje_inicial = True
                camion.save()
            else:
                p = PesajeGD()
                p.camion = camion

        if not pesaje_inicial:
            p.camion = camion
            p.peso = peso
            p.personal = camion.ordena_pesaje
            p.fecha = datetime.now()
            p.save()
        
            # Marcar que se ha registrado el pesaje
            camion.pesar = 0
            camion.ordena_pesaje = None
            camion.save()

        # Responder ok al pc de la romana
        return Utiles.responder_200("ok")

    except ValueError:
        return Utiles.responder_500("El peso debe ser un valor numérico int o float")
    except:
        traceback.print_exc()
        return Utiles.responder_500("Error de recepción")