mpv-youtube-queue-server/app/views.py

"""Views for the Flask app."""

from flask import Blueprint, current_app, g, jsonify, request
from sqlalchemy import inspect
from sqlalchemy.exc import SQLAlchemyError

from app.database import get_db_session
from app.models import SavedQueue, WatchHistory
from app.mpv import send_to_mpv

bp = Blueprint("views", __name__)


@bp.before_request
def before_request():
    g.db_session = get_db_session()


@bp.teardown_app_request
def shutdown_session(exception=None):
    if hasattr(g, "db_session"):
        g.db_session.close()


@bp.route("/save_queue", methods=["POST"])
def save_queue():
    data = request.get_json()
    if not data or "urls" not in data:
        return jsonify(message="Invalid JSON data"), 400

    db_session = g.db_session
    db_session.query(SavedQueue).delete()

    for url in data["urls"]:
        new_entry = SavedQueue(video_url=url)
        db_session.add(new_entry)

    try:
        db_session.commit()
        return jsonify(message="Data added to saved queue"), 200
    except SQLAlchemyError as e:
        db_session.rollback()
        current_app.logger.error(f"Failed to insert data: {e}")
        return jsonify(message="Database error"), 500


@bp.route("/load_queue", methods=["GET"])
def load_queue():
    """
    Retrieves the saved queue of video URLs.
    """
    current_app.logger.debug("Loading saved queue")
    db_session = g.db_session
    urls = [entry.video_url for entry in db_session.query(SavedQueue).all()]
    current_app.logger.debug(f"Loaded {len(urls)} URLs from the saved queue")
    return jsonify(urls), 200


@bp.route("/add_video", methods=["POST"])
def add_video():
    data = request.get_json()
    if not all(
        k in data for k in ["video_url", "video_name", "channel_url", "channel_name"]
    ):
        current_app.logger.error("Missing required fields")
        current_app.logger.error(
            "Required fields: video_url, video_name, channel_url, channel_name"
        )
        return jsonify(message="Missing required fields"), 400

    new_entry = WatchHistory(
        video_url=data["video_url"],
        video_name=data["video_name"],
        channel_url=data["channel_url"],
        channel_name=data["channel_name"],
        category=data.get("category") if data.get("category") else None,
        view_count=data.get("view_count") if data.get("view_count") else None,
        subscriber_count=data.get("subscribers") if data.get("subscribers") else None,
        thumbnail_url=data.get("thumbnail_url") if data.get("thumbnail_url") else None,
        upload_date=data.get("upload_date") if data.get("upload_date") else None,
    )

    db_session = g.db_session

    try:
        current_app.logger.debug("Adding video to watch history")
        db_session.add(new_entry)
        db_session.commit()
        current_app.logger.debug("Video added to watch history")
        current_app.logger.debug("Data: %s", data)
        return jsonify(message="Video added"), 200
    except SQLAlchemyError as e:
        db_session.rollback()
        current_app.logger.error(f"Database error: {e}")
        return jsonify(message="Failed to add video"), 500


@bp.route("/", methods=["GET"])
def handle_request():
    video_url = request.args.get("url")
    if not video_url:
        return "Missing 'url' parameter", 400

    command = (
        f'{{"command": ["script-message", "add_to_youtube_queue", "{video_url}"]}}\n'
    )
    if send_to_mpv(command):
        return "URL added to mpv queue", 200
    return "Failed to add URL to mpv queue", 500


@bp.route("/migrate_watch_history", methods=["POST"])
def migrate_watch_history():
    db_session = g.db_session
    engine = db_session.get_bind()

    try:
        # First check and add missing columns
        inspector = inspect(engine)
        existing_columns = [
            col["name"] for col in inspector.get_columns("watch_history")
        ]

        # Define new columns and their SQL
        new_columns = {
            "category": "ALTER TABLE watch_history ADD COLUMN category VARCHAR(100)",
            "view_count": "ALTER TABLE watch_history ADD COLUMN view_count INTEGER",
            "subscriber_count": "ALTER TABLE watch_history ADD COLUMN subscriber_count INTEGER",
            "thumbnail_url": "ALTER TABLE watch_history ADD COLUMN thumbnail_url VARCHAR(255)",
            "upload_date": "ALTER TABLE watch_history ADD COLUMN upload_date TIMESTAMP",
        }

        # Add missing columns
        columns_added = []
        for col_name, sql in new_columns.items():
            if col_name not in existing_columns:
                engine.execute(sql)
                columns_added.append(col_name)
                current_app.logger.info(f"Added column: {col_name}")

        # Now backfill with default values
        entries = db_session.query(WatchHistory).all()
        updated_count = 0

        for entry in entries:
            updated = False
            # Check and set defaults for new columns if they're None
            if entry.category is None:
                entry.category = "Unknown"
                updated = True
            if entry.view_count is None:
                entry.view_count = 0
                updated = True
            if entry.subscriber_count is None:
                entry.subscriber_count = 0
                updated = True
            if entry.thumbnail_url is None:
                entry.thumbnail_url = ""
                updated = True
            if entry.upload_date is None:
                # Set to watch_date as a fallback
                entry.upload_date = entry.watch_date
                updated = True

            if updated:
                updated_count += 1

        db_session.commit()
        return (
            jsonify(
                {
                    "message": "Migration completed successfully",
                    "columns_added": columns_added,
                    "records_updated": updated_count,
                    "total_records": len(entries),
                }
            ),
            200,
        )

    except SQLAlchemyError as e:
        db_session.rollback()
        current_app.logger.error(f"Migration failed: {e}")
        return jsonify(message=f"Failed to migrate watch history: {str(e)}"), 500