from fastapi import APIRouter, Depends, Query
from prisma import Prisma
from typing import List, Dict, Optional
from app.api.dependencies import get_prisma

router = APIRouter(prefix="/referencias-proveedor", tags=["referencias-proveedor"])


@router.get("/")
async def obtener_referencias_proveedor(
    proveedor_id: Optional[int] = Query(None),
    db: Prisma = Depends(get_prisma)
) -> List[Dict]:
    """Obtener referencias pendientes por proveedor"""
    # Obtener referencias pendientes de pedidos a proveedor
    where = {
        "estado": {"in": ["pendiente", "parcial"]}
    }
    
    if proveedor_id:
        where["pedidoProveedor"] = {"proveedorId": proveedor_id}
    
    referencias = await db.referenciapedidoproveedor.find_many(
        where=where,
        include={
            "pedidoProveedor": {
                "include": {
                    "proveedor": True
                }
            },
            "referenciaPedidoCliente": {
                "include": {
                    "pedidoCliente": {
                        "include": {
                            "cliente": True
                        }
                    }
                }
            }
        }
    )
    
    # Agrupar por proveedor
    proveedores_data = {}
    for ref in referencias:
        proveedor = ref.pedidoProveedor.proveedor
        if proveedor.id not in proveedores_data:
            proveedores_data[proveedor.id] = {
                "proveedor": {
                    "id": proveedor.id,
                    "nombre": proveedor.nombre,
                    "email": proveedor.email,
                    "tiene_web": proveedor.tieneWeb,
                    "activo": proveedor.activo,
                },
                "referencias_pendientes": [],
                "referencias_devolucion": [],
            }
        
        proveedores_data[proveedor.id]["referencias_pendientes"].append({
            "id": ref.id,
            "referencia": ref.referencia,
            "denominacion": ref.denominacion,
            "unidades_pedidas": ref.unidadesPedidas,
            "unidades_recibidas": ref.unidadesRecibidas,
            "estado": ref.estado,
        })
    
    # Agregar devoluciones pendientes
    devoluciones_where = {"estadoAbono": "pendiente"}
    if proveedor_id:
        devoluciones_where["proveedorId"] = proveedor_id
    
    devoluciones = await db.devolucion.find_many(
        where=devoluciones_where,
        include={"proveedor": True}
    )
    
    for dev in devoluciones:
        if dev.proveedorId not in proveedores_data:
            proveedores_data[dev.proveedorId] = {
                "proveedor": {
                    "id": dev.proveedor.id,
                    "nombre": dev.proveedor.nombre,
                    "email": dev.proveedor.email,
                    "tiene_web": dev.proveedor.tieneWeb,
                    "activo": dev.proveedor.activo,
                },
                "referencias_pendientes": [],
                "referencias_devolucion": [],
            }
        
        proveedores_data[dev.proveedorId]["referencias_devolucion"].append({
            "id": dev.id,
            "referencia": dev.referencia,
            "denominacion": dev.denominacion,
            "unidades": dev.unidades,
            "fecha_devolucion": dev.fechaDevolucion.isoformat() if dev.fechaDevolucion else None,
        })
    
    return list(proveedores_data.values())