from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy import and_
from sqlalchemy.orm import Session

from app.auth.dependencies import get_current_user, require_roles
from app.models import (
    ChannelCreate,
    ChannelDB,
    ChannelResponse,
    ChannelUpdate,
    ChannelURL,
    ChannelURLCreate,
    ChannelURLResponse,
    Group,
)
from app.models.auth import CognitoUser
from app.models.schemas import ChannelURLUpdate
from app.utils.database import get_db

router = APIRouter(prefix="/channels", tags=["channels"])


@router.post("/", response_model=ChannelResponse, status_code=status.HTTP_201_CREATED)
@require_roles("admin")
def create_channel(
    channel: ChannelCreate,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Create a new channel"""
    # Check if group exists
    group = db.query(Group).filter(Group.id == channel.group_id).first()
    if not group:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Group not found",
        )

    # Check for duplicate channel (same group_id + name)
    existing_channel = (
        db.query(ChannelDB)
        .filter(
            and_(
                ChannelDB.group_id == channel.group_id,
                ChannelDB.name == channel.name,
            )
        )
        .first()
    )

    if existing_channel:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="Channel with same group_id and name already exists",
        )

    # Create channel without URLs first
    channel_data = channel.model_dump(exclude={"urls"})
    urls = channel.urls
    db_channel = ChannelDB(**channel_data)
    db.add(db_channel)
    db.commit()
    db.refresh(db_channel)

    # Add URLs with priority
    for url in urls:
        db_url = ChannelURL(
            channel_id=db_channel.id,
            url=url.url,
            priority_id=url.priority_id,
            in_use=False,
        )
        db.add(db_url)

    db.commit()
    db.refresh(db_channel)
    return db_channel


@router.get("/{channel_id}", response_model=ChannelResponse)
def get_channel(channel_id: UUID, db: Session = Depends(get_db)):
    """Get a channel by id"""
    channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )
    return channel


@router.put("/{channel_id}", response_model=ChannelResponse)
@require_roles("admin")
def update_channel(
    channel_id: UUID,
    channel: ChannelUpdate,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Update a channel"""
    db_channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not db_channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )

    # Only check for duplicates if name or group_id are being updated
    if channel.name is not None or channel.group_id is not None:
        name = channel.name if channel.name is not None else db_channel.name
        group_id = (
            channel.group_id if channel.group_id is not None else db_channel.group_id
        )

        # Check if new group exists
        if channel.group_id is not None:
            group = db.query(Group).filter(Group.id == channel.group_id).first()
            if not group:
                raise HTTPException(
                    status_code=status.HTTP_404_NOT_FOUND,
                    detail="Group not found",
                )

        existing_channel = (
            db.query(ChannelDB)
            .filter(
                and_(
                    ChannelDB.group_id == group_id,
                    ChannelDB.name == name,
                    ChannelDB.id != channel_id,
                )
            )
            .first()
        )

        if existing_channel:
            raise HTTPException(
                status_code=status.HTTP_409_CONFLICT,
                detail="Channel with same group_id and name already exists",
            )

    # Update only provided fields
    update_data = channel.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        setattr(db_channel, key, value)

    db.commit()
    db.refresh(db_channel)
    return db_channel


@router.delete("/{channel_id}", status_code=status.HTTP_204_NO_CONTENT)
@require_roles("admin")
def delete_channel(
    channel_id: UUID,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Delete a channel"""
    channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )
    db.delete(channel)
    db.commit()
    return None


@router.get("/", response_model=list[ChannelResponse])
@require_roles("admin")
def list_channels(
    skip: int = 0,
    limit: int = 100,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """List all channels with pagination"""
    return db.query(ChannelDB).offset(skip).limit(limit).all()


# New endpoint to get channels by group
@router.get("/groups/{group_id}/channels", response_model=list[ChannelResponse])
def get_channels_by_group(
    group_id: UUID,
    db: Session = Depends(get_db),
):
    """Get all channels for a specific group"""
    group = db.query(Group).filter(Group.id == group_id).first()
    if not group:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Group not found"
        )
    return db.query(ChannelDB).filter(ChannelDB.group_id == group_id).all()


# New endpoint to update a channel's group
@router.put("/{channel_id}/group", response_model=ChannelResponse)
@require_roles("admin")
def update_channel_group(
    channel_id: UUID,
    group_id: UUID,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Update a channel's group"""
    channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )

    group = db.query(Group).filter(Group.id == group_id).first()
    if not group:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Group not found"
        )

    # Check for duplicate channel name in new group
    existing_channel = (
        db.query(ChannelDB)
        .filter(
            and_(
                ChannelDB.group_id == group_id,
                ChannelDB.name == channel.name,
                ChannelDB.id != channel_id,
            )
        )
        .first()
    )

    if existing_channel:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="Channel with same name already exists in target group",
        )

    channel.group_id = group_id
    db.commit()
    db.refresh(channel)
    return channel


# URL Management Endpoints
@router.post(
    "/{channel_id}/urls",
    response_model=ChannelURLResponse,
    status_code=status.HTTP_201_CREATED,
)
@require_roles("admin")
def add_channel_url(
    channel_id: UUID,
    url: ChannelURLCreate,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Add a new URL to a channel"""
    channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )

    db_url = ChannelURL(
        channel_id=channel_id,
        url=url.url,
        priority_id=url.priority_id,
        in_use=False,  # Default to not in use
    )
    db.add(db_url)
    db.commit()
    db.refresh(db_url)
    return db_url


@router.put("/{channel_id}/urls/{url_id}", response_model=ChannelURLResponse)
@require_roles("admin")
def update_channel_url(
    channel_id: UUID,
    url_id: UUID,
    url_update: ChannelURLUpdate,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Update a channel URL (url, in_use, or priority_id)"""
    db_url = (
        db.query(ChannelURL)
        .filter(and_(ChannelURL.id == url_id, ChannelURL.channel_id == channel_id))
        .first()
    )

    if not db_url:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="URL not found"
        )

    if url_update.url is not None:
        db_url.url = url_update.url
    if url_update.in_use is not None:
        db_url.in_use = url_update.in_use
    if url_update.priority_id is not None:
        db_url.priority_id = url_update.priority_id

    db.commit()
    db.refresh(db_url)
    return db_url


@router.delete("/{channel_id}/urls/{url_id}", status_code=status.HTTP_204_NO_CONTENT)
@require_roles("admin")
def delete_channel_url(
    channel_id: UUID,
    url_id: UUID,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Delete a URL from a channel"""
    url = (
        db.query(ChannelURL)
        .filter(and_(ChannelURL.id == url_id, ChannelURL.channel_id == channel_id))
        .first()
    )

    if not url:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="URL not found"
        )

    db.delete(url)
    db.commit()
    return None


@router.get("/{channel_id}/urls", response_model=list[ChannelURLResponse])
@require_roles("admin")
def list_channel_urls(
    channel_id: UUID,
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """List all URLs for a channel"""
    channel = db.query(ChannelDB).filter(ChannelDB.id == channel_id).first()
    if not channel:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, detail="Channel not found"
        )

    return db.query(ChannelURL).filter(ChannelURL.channel_id == channel_id).all()