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,
)
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 for duplicate channel (same group_title + name)
    existing_channel = (
        db.query(ChannelDB)
        .filter(
            and_(
                ChannelDB.group_title == channel.group_title,
                ChannelDB.name == channel.name,
            )
        )
        .first()
    )

    if existing_channel:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="Channel with same group_title 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_title are being updated
    if channel.name is not None or channel.group_title is not None:
        name = channel.name if channel.name is not None else db_channel.name
        group_title = (
            channel.group_title
            if channel.group_title is not None
            else db_channel.group_title
        )

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

        if existing_channel:
            raise HTTPException(
                status_code=status.HTTP_409_CONFLICT,
                detail="Channel with same group_title 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()


# 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()