# app/routers/dashboard.py

from typing import List
from sqlalchemy import select
from app.core.database import get_db
from app.models.client import Client
from app.models.visitor import Visitor
from app.models.message import Message
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.agent import AgentAssignmentHistory, Agent
from app.ws.connection_manager import visitor_manager
from fastapi import APIRouter, Depends, HTTPException
from app.schemas.chat import VisitorOnlineList, OnlineVisitor, MessageOut

# router = APIRouter(tags=["Dashboard"])
router = APIRouter(prefix="/dashboard", tags=["Dashboard"])

online_visitors = []   # or fetch from Redis/DB/ws manager

# visitors/online
@router.get("/visitors/online", response_model=VisitorOnlineList)
async def get_online_visitors(db: AsyncSession = Depends(get_db)):

    print("-------/visitors/online-----------")

    # visitors who have an active WS connection
    visitor_uids = list(visitor_manager.active_connections.keys())
    if not visitor_uids:
        return {"visitors": []}

    # fetch visitor + client
    result = await db.execute(
        select(Visitor, Client)
        .join(Client, Visitor.client_id == Client.id)
        .where(Visitor.visitor_id.in_(visitor_uids))
    )
    rows = result.all()
    print("rows",rows)
    if not rows:
        return {"visitors": []}

    # extract visitor PK ids
    visitor_ids = [v.id for (v, _) in rows]

    # fetch active agent assignments
    ass_result = await db.execute(
        select(AgentAssignmentHistory).where(
            AgentAssignmentHistory.visitor_id.in_(visitor_ids),
            AgentAssignmentHistory.ended_at.is_(None),
        )
    )
    assignments = ass_result.scalars().all()
    assignment_map = {a.visitor_id: a for a in assignments}

    print("assignment_map",assignment_map)

    # build final response
    visitors_out: List[OnlineVisitor] = []

    for v, c in rows:

        print("v.name",v.name)
        print("v.city",v.city)
        print("c",c)

        a = assignment_map.get(v.id)

        a = assignment_map.get(v.id)

        agent_name = None
        assigned_agent_id = None

        if a:
            assigned_agent_id = a.agent_id

            # Fetch agent only if assigned
            agent_result = await db.execute(
                select(Agent).where(Agent.id == a.agent_id)
            )
            agent_data = agent_result.scalar_one_or_none()
            agent_name = agent_data.name if agent_data else None

        visitors_out.append(
            OnlineVisitor(
                visitor_uid=v.visitor_id,
                name=v.name,
                city=v.city,
                region=v.region,
                country=v.country,
                ip_address=v.ip_address,
                client_name=c.client_name if c else None,
                assigned_agent_id=assigned_agent_id,
                assigned_agent_name=agent_name,
            )
        )

    return {"visitors": visitors_out}


@router.get("/chat/history/{visitor_uid}", response_model=list[MessageOut])
async def get_chat_history(visitor_uid: str, db: AsyncSession = Depends(get_db)):

    # Find visitor by public visitor_uid
    result = await db.execute(select(Visitor).where(Visitor.visitor_id == visitor_uid))
    
    visitor = result.scalar_one_or_none()
    if not visitor:
        raise HTTPException(status_code=404, detail="Visitor not found")

    msg_result = await db.execute(
        select(Message).where(Message.visitor_id == visitor.id).order_by(Message.created_at.asc())
    )
    messages = msg_result.scalars().all()

    return [
        MessageOut( sender=m.sender, text=m.text, created_at=m.created_at )
        for m in messages
    ]