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,
    Priority,  # Added Priority import
)
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("/", status_code=status.HTTP_200_OK)
@require_roles("admin")
def delete_channels(
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Delete all channels"""
    count = 0
    try:
        count = db.query(ChannelDB).count()

        # First delete all channels
        db.query(ChannelDB).delete()

        # Then delete any URLs that are now orphaned (no channel references)
        db.query(ChannelURL).filter(
            ~ChannelURL.channel_id.in_(db.query(ChannelDB.id))
        ).delete(synchronize_session=False)

        # Then delete any groups that are now empty
        db.query(Group).filter(~Group.id.in_(db.query(ChannelDB.group_id))).delete(
            synchronize_session=False
        )

        db.commit()
    except Exception as e:
        print(f"Error deleting channels: {e}")
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Failed to delete channels",
        )
    return {"deleted": count}


@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


# Bulk Upload and Reset Endpoints
@router.post("/bulk-upload", status_code=status.HTTP_200_OK)
@require_roles("admin")
def bulk_upload_channels(
    channels: list[dict],
    db: Session = Depends(get_db),
    user: CognitoUser = Depends(get_current_user),
):
    """Bulk upload channels from JSON array"""
    processed = 0

    # Fetch all priorities from the database, ordered by id
    priorities = db.query(Priority).order_by(Priority.id).all()
    priority_map = {i: p.id for i, p in enumerate(priorities)}

    # Get the highest priority_id (which corresponds to the lowest priority level)
    max_priority_id = None
    if priorities:
        max_priority_id = db.query(Priority.id).order_by(Priority.id.desc()).first()[0]

    for channel_data in channels:
        try:
            # Get or create group
            group_name = channel_data.get("group-title")
            if not group_name:
                continue

            group = db.query(Group).filter(Group.name == group_name).first()
            if not group:
                group = Group(name=group_name)
                db.add(group)
                db.flush()  # Use flush to make the group available in the session
                db.refresh(group)

            # Prepare channel data
            urls = channel_data.get("urls", [])
            if not isinstance(urls, list):
                urls = [urls]

            # Assign priorities dynamically based on fetched priorities
            url_objects = []
            for i, url in enumerate(urls):  # Process all URLs
                priority_id = priority_map.get(i)
                if priority_id is None:
                    # If index is out of bounds,
                    # assign the highest priority_id (lowest priority)
                    if max_priority_id is not None:
                        priority_id = max_priority_id
                    else:
                        print(
                            f"Warning: No priorities defined in database. "
                            f"Skipping URL {url}"
                        )
                        continue
                url_objects.append({"url": url, "priority_id": priority_id})

            # Create channel object with required fields
            channel_obj = ChannelDB(
                tvg_id=channel_data.get("tvg-id", ""),
                name=channel_data.get("name", ""),
                group_id=group.id,
                tvg_name=channel_data.get("tvg-name", ""),
                tvg_logo=channel_data.get("tvg-logo", ""),
            )

            # Upsert channel
            existing_channel = (
                db.query(ChannelDB)
                .filter(
                    and_(
                        ChannelDB.group_id == group.id,
                        ChannelDB.name == channel_obj.name,
                    )
                )
                .first()
            )

            if existing_channel:
                # Update existing
                existing_channel.tvg_id = channel_obj.tvg_id
                existing_channel.tvg_name = channel_obj.tvg_name
                existing_channel.tvg_logo = channel_obj.tvg_logo

                # Clear and recreate URLs
                db.query(ChannelURL).filter(
                    ChannelURL.channel_id == existing_channel.id
                ).delete()

                for url in url_objects:
                    db_url = ChannelURL(
                        channel_id=existing_channel.id,
                        url=url["url"],
                        priority_id=url["priority_id"],
                        in_use=False,
                    )
                    db.add(db_url)
            else:
                # Create new
                db.add(channel_obj)
                db.flush()  # Flush to get the new channel's ID
                db.refresh(channel_obj)

                # Add URLs for new channel
                for url in url_objects:
                    db_url = ChannelURL(
                        channel_id=channel_obj.id,
                        url=url["url"],
                        priority_id=url["priority_id"],
                        in_use=False,
                    )
                    db.add(db_url)

            db.commit()  # Commit all changes for this channel atomically
            processed += 1

        except Exception as e:
            print(f"Error processing channel: {channel_data.get('name', 'Unknown')}")
            print(f"Exception details: {e}")
            db.rollback()  # Rollback the entire transaction for the failed channel
            continue

    return {"processed": processed}


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