"""
Artist endpoint router.
"""

from fastapi import APIRouter, HTTPException, Request, Depends, Query
from fastapi.responses import JSONResponse
import json
import traceback
from routes.utils.artist import download_artist_albums

# Imports for merged watch functionality
import logging
import threading
from routes.utils.watch.db import (
    add_artist_to_watch as add_artist_db,
    remove_artist_from_watch as remove_artist_db,
    get_watched_artist,
    get_watched_artists,
    add_specific_albums_to_artist_table,
    remove_specific_albums_from_artist_table,
)
from routes.utils.watch.manager import check_watched_artists, get_watch_config
from routes.utils.get_info import get_client, get_artist, get_album

# Import authentication dependencies
from routes.auth.middleware import require_auth_from_state, User

router = APIRouter()

# Existing log_json can be used, or a logger instance.
# Let's initialize a logger for consistency with merged code.
logger = logging.getLogger(__name__)


def construct_spotify_url(item_id: str, item_type: str = "track") -> str:
    """Construct a Spotify URL for a given item ID and type."""
    return f"https://open.spotify.com/{item_type}/{item_id}"


def log_json(message_dict):
    print(json.dumps(message_dict))


@router.get("/download/{artist_id}")
async def handle_artist_download(
    artist_id: str,
    request: Request,
    current_user: User = Depends(require_auth_from_state),
):
    """
    Enqueues album download tasks for the given artist.
    Expected query parameters:
      - album_type: string(s); comma-separated values such as "album,single,appears_on,compilation"
    """
    # Construct the artist URL from artist_id
    url = construct_spotify_url(artist_id, "artist")

    # Retrieve essential parameters from the request.
    album_type = request.query_params.get("album_type", "album,single,compilation")

    # Validate required parameters
    if not url:  # This check is mostly for safety, as url is constructed
        return JSONResponse(
            content={"error": "Missing required parameter: url"}, status_code=400
        )

    try:
        # Delegate to the download_artist_albums function which will handle album filtering
        successfully_queued_albums, duplicate_albums = download_artist_albums(
            url=url,
            album_type=album_type,
            request_args=dict(request.query_params),
            username=current_user.username,
        )

        # Return the list of album task IDs.
        response_data = {
            "status": "complete",
            "message": f"Artist discography processing initiated. {len(successfully_queued_albums)} albums queued.",
            "queued_albums": successfully_queued_albums,
        }
        if duplicate_albums:
            response_data["duplicate_albums"] = duplicate_albums
            response_data["message"] += (
                f" {len(duplicate_albums)} albums were already in progress or queued."
            )

        return JSONResponse(
            content=response_data,
            status_code=202,  # Still 202 Accepted as some operations may have succeeded
        )
    except Exception as e:
        return JSONResponse(
            content={
                "status": "error",
                "message": str(e),
                "traceback": traceback.format_exc(),
            },
            status_code=500,
        )


@router.get("/download/cancel")
async def cancel_artist_download():
    """
    Cancelling an artist download is not supported since the endpoint only enqueues album tasks.
    (Cancellation for individual album tasks can be implemented via the queue manager.)
    """
    return JSONResponse(
        content={"error": "Artist download cancellation is not supported."},
        status_code=400,
    )


@router.get("/info")
async def get_artist_info(
    request: Request,
    current_user: User = Depends(require_auth_from_state),
    limit: int = Query(10, ge=1),  # default=10, must be >=1
    offset: int = Query(0, ge=0),  # default=0, must be >=0
):
    """
    Retrieves Spotify artist metadata given a Spotify artist ID.
    Expects a query parameter 'id' with the Spotify artist ID.
    Returns the raw JSON from get_artist in routes.utils.get_info.
    """
    spotify_id = request.query_params.get("id")

    if not spotify_id:
        return JSONResponse(content={"error": "Missing parameter: id"}, status_code=400)

    try:
        client = get_client()
        artist_info = get_artist(client, spotify_id)
        return JSONResponse(content=artist_info, status_code=200)
    except Exception as e:
        return JSONResponse(
            content={"error": str(e), "traceback": traceback.format_exc()},
            status_code=500,
        )


# --- Merged Artist Watch Routes ---


@router.put("/watch/{artist_spotify_id}")
async def add_artist_to_watchlist(
    artist_spotify_id: str, current_user: User = Depends(require_auth_from_state)
):
    """Adds an artist to the watchlist."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={"error": "Watch feature is currently disabled globally."},
        )

    logger.info(f"Attempting to add artist {artist_spotify_id} to watchlist.")
    try:
        if get_watched_artist(artist_spotify_id):
            return {"message": f"Artist {artist_spotify_id} is already being watched."}

        client = get_client()
        artist_metadata = get_artist(client, artist_spotify_id)

        if not artist_metadata or not artist_metadata.get("name"):
            logger.error(
                f"Could not fetch artist metadata for {artist_spotify_id} from Spotify."
            )
            raise HTTPException(
                status_code=404,
                detail={
                    "error": f"Could not fetch artist metadata for {artist_spotify_id} to initiate watch."
                },
            )

        # Derive a rough total album count from groups if present
        total_albums = 0
        for key in (
            "album_group",
            "single_group",
            "compilation_group",
            "appears_on_group",
        ):
            grp = artist_metadata.get(key)
            if isinstance(grp, list):
                total_albums += len(grp)

        artist_data_for_db = {
            "id": artist_spotify_id,
            "name": artist_metadata.get("name", "Unknown Artist"),
            "albums": {"total": total_albums},
        }

        add_artist_db(artist_data_for_db)

        logger.info(
            f"Artist {artist_spotify_id} ('{artist_metadata.get('name', 'Unknown Artist')}') added to watchlist. Their albums will be processed by the watch manager."
        )
        return {
            "message": f"Artist {artist_spotify_id} added to watchlist. Albums will be processed shortly."
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(
            f"Error adding artist {artist_spotify_id} to watchlist: {e}", exc_info=True
        )
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not add artist to watchlist: {str(e)}"},
        )


@router.get("/watch/{artist_spotify_id}/status")
async def get_artist_watch_status(
    artist_spotify_id: str, current_user: User = Depends(require_auth_from_state)
):
    """Checks if a specific artist is being watched."""
    logger.info(f"Checking watch status for artist {artist_spotify_id}.")
    try:
        artist = get_watched_artist(artist_spotify_id)
        if artist:
            return {"is_watched": True, "artist_data": dict(artist)}
        else:
            return {"is_watched": False}
    except Exception as e:
        logger.error(
            f"Error checking watch status for artist {artist_spotify_id}: {e}",
            exc_info=True,
        )
        raise HTTPException(
            status_code=500, detail={"error": f"Could not check watch status: {str(e)}"}
        )


@router.delete("/watch/{artist_spotify_id}")
async def remove_artist_from_watchlist(
    artist_spotify_id: str, current_user: User = Depends(require_auth_from_state)
):
    """Removes an artist from the watchlist."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={"error": "Watch feature is currently disabled globally."},
        )

    logger.info(f"Attempting to remove artist {artist_spotify_id} from watchlist.")
    try:
        if not get_watched_artist(artist_spotify_id):
            raise HTTPException(
                status_code=404,
                detail={"error": f"Artist {artist_spotify_id} not found in watchlist."},
            )

        remove_artist_db(artist_spotify_id)
        logger.info(f"Artist {artist_spotify_id} removed from watchlist successfully.")
        return {"message": f"Artist {artist_spotify_id} removed from watchlist."}
    except HTTPException:
        raise
    except Exception as e:
        logger.error(
            f"Error removing artist {artist_spotify_id} from watchlist: {e}",
            exc_info=True,
        )
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not remove artist from watchlist: {str(e)}"},
        )


@router.get("/watch/list")
async def list_watched_artists_endpoint(
    current_user: User = Depends(require_auth_from_state),
):
    """Lists all artists currently in the watchlist."""
    try:
        artists = get_watched_artists()
        return [dict(artist) for artist in artists]
    except Exception as e:
        logger.error(f"Error listing watched artists: {e}", exc_info=True)
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not list watched artists: {str(e)}"},
        )


@router.post("/watch/trigger_check")
async def trigger_artist_check_endpoint(
    current_user: User = Depends(require_auth_from_state),
):
    """Manually triggers the artist checking mechanism for all watched artists."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={
                "error": "Watch feature is currently disabled globally. Cannot trigger check."
            },
        )

    logger.info("Manual trigger for artist check received for all artists.")
    try:
        thread = threading.Thread(target=check_watched_artists, args=(None,))
        thread.start()
        return {
            "message": "Artist check triggered successfully in the background for all artists."
        }
    except Exception as e:
        logger.error(
            f"Error manually triggering artist check for all: {e}", exc_info=True
        )
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not trigger artist check for all: {str(e)}"},
        )


@router.post("/watch/trigger_check/{artist_spotify_id}")
async def trigger_specific_artist_check_endpoint(
    artist_spotify_id: str, current_user: User = Depends(require_auth_from_state)
):
    """Manually triggers the artist checking mechanism for a specific artist."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={
                "error": "Watch feature is currently disabled globally. Cannot trigger check."
            },
        )

    logger.info(
        f"Manual trigger for specific artist check received for ID: {artist_spotify_id}"
    )
    try:
        watched_artist = get_watched_artist(artist_spotify_id)
        if not watched_artist:
            logger.warning(
                f"Trigger specific check: Artist ID {artist_spotify_id} not found in watchlist."
            )
            raise HTTPException(
                status_code=404,
                detail={
                    "error": f"Artist {artist_spotify_id} is not in the watchlist. Add it first."
                },
            )

        thread = threading.Thread(
            target=check_watched_artists, args=(artist_spotify_id,)
        )
        thread.start()
        logger.info(
            f"Artist check triggered in background for specific artist ID: {artist_spotify_id}"
        )
        return {
            "message": f"Artist check triggered successfully in the background for {artist_spotify_id}."
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(
            f"Error manually triggering specific artist check for {artist_spotify_id}: {e}",
            exc_info=True,
        )
        raise HTTPException(
            status_code=500,
            detail={
                "error": f"Could not trigger artist check for {artist_spotify_id}: {str(e)}"
            },
        )


@router.post("/watch/{artist_spotify_id}/albums")
async def mark_albums_as_known_for_artist(
    artist_spotify_id: str,
    request: Request,
    current_user: User = Depends(require_auth_from_state),
):
    """Fetches details for given album IDs and adds/updates them in the artist's local DB table."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={
                "error": "Watch feature is currently disabled globally. Cannot mark albums."
            },
        )

    logger.info(f"Attempting to mark albums as known for artist {artist_spotify_id}.")
    try:
        album_ids = await request.json()
        if not isinstance(album_ids, list) or not all(
            isinstance(aid, str) for aid in album_ids
        ):
            raise HTTPException(
                status_code=400,
                detail={
                    "error": "Invalid request body. Expecting a JSON array of album Spotify IDs."
                },
            )

        if not get_watched_artist(artist_spotify_id):
            raise HTTPException(
                status_code=404,
                detail={"error": f"Artist {artist_spotify_id} is not being watched."},
            )

        client = get_client()
        fetched_albums_details = []
        try:
            for album_id in album_ids:
                try:
                    album_detail = get_album(client, album_id)
                    if album_detail and album_detail.get("id"):
                        fetched_albums_details.append(album_detail)
                    else:
                        logger.warning(
                            f"Could not fetch details for album {album_id} when marking as known for artist {artist_spotify_id}."
                        )
                except Exception as e:
                    logger.error(
                        f"Failed to fetch Spotify details for album {album_id}: {e}"
                    )
        finally:
            # No need to close_client here, as get_client is shared
            pass

        if not fetched_albums_details:
            return {
                "message": "No valid album details could be fetched to mark as known.",
                "processed_count": 0,
            }

        processed_count = add_specific_albums_to_artist_table(
            artist_spotify_id, fetched_albums_details
        )
        logger.info(
            f"Successfully marked/updated {processed_count} albums as known for artist {artist_spotify_id}."
        )
        return {
            "message": f"Successfully processed {processed_count} albums for artist {artist_spotify_id}."
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(
            f"Error marking albums as known for artist {artist_spotify_id}: {e}",
            exc_info=True,
        )
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not mark albums as known: {str(e)}"},
        )


@router.delete("/watch/{artist_spotify_id}/albums")
async def mark_albums_as_missing_locally_for_artist(
    artist_spotify_id: str,
    request: Request,
    current_user: User = Depends(require_auth_from_state),
):
    """Removes specified albums from the artist's local DB table."""
    watch_config = get_watch_config()
    if not watch_config.get("enabled", False):
        raise HTTPException(
            status_code=403,
            detail={
                "error": "Watch feature is currently disabled globally. Cannot mark albums."
            },
        )

    logger.info(
        f"Attempting to mark albums as missing (delete locally) for artist {artist_spotify_id}."
    )
    try:
        album_ids = await request.json()
        if not isinstance(album_ids, list) or not all(
            isinstance(aid, str) for aid in album_ids
        ):
            raise HTTPException(
                status_code=400,
                detail={
                    "error": "Invalid request body. Expecting a JSON array of album Spotify IDs."
                },
            )

        if not get_watched_artist(artist_spotify_id):
            raise HTTPException(
                status_code=404,
                detail={"error": f"Artist {artist_spotify_id} is not being watched."},
            )

        deleted_count = remove_specific_albums_from_artist_table(
            artist_spotify_id, album_ids
        )
        logger.info(
            f"Successfully removed {deleted_count} albums locally for artist {artist_spotify_id}."
        )
        return {
            "message": f"Successfully removed {deleted_count} albums locally for artist {artist_spotify_id}."
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(
            f"Error marking albums as missing (deleting locally) for artist {artist_spotify_id}: {e}",
            exc_info=True,
        )
        raise HTTPException(
            status_code=500,
            detail={"error": f"Could not mark albums as missing: {str(e)}"},
        )