app.py

import os
import logging
from datetime import datetime
from typing import Any, Dict, Tuple, Union
from flask import (
    Flask,
    request,
    redirect,
    url_for,
    render_template,
    send_from_directory,
    flash,
    Response,
)
import json

from src.config import AppConfig
from src.services import FigmaService, ProcessingPipeline, FileService, VideoService
from src.repositories import ManifestRepository
from src.models import Video
from src.exceptions import ValidationError, SignBridgeError
from src.utils import timed_execution, RequestValidator


# Configure logging
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Initialize application configuration
config = AppConfig.from_env()
figma_service = FigmaService(config.figma)
pipeline_service = ProcessingPipeline(config)
file_service = FileService()
manifest_repository = ManifestRepository(
    manifest_path=os.path.join(config.content_dir, "manifest.json")
)
video_service = VideoService(
    config=config,
    pipeline_service=pipeline_service,
    file_service=file_service,
    manifest_repository=manifest_repository,
)

# Legacy compatibility - maintain these for existing code
BASE_DIR = config.base_dir
UPLOAD_DIR = config.upload_dir
OUT_DIR = config.out_dir

app = Flask(__name__)
app.secret_key = config.secret_key


# Compatibility wrappers for existing code
def get_figma_url() -> str:
    """Get Figma URL from configuration."""
    return config.figma.url or ""


def get_figma_tokens() -> dict:
    """Fetch design tokens from Figma API."""
    return figma_service.get_design_tokens()


def write_hardcoded_sigml(output_sigml: str) -> None:
    """Overwrite output_sigml with a fixed two-hand SiGML for demo sentence.
    This guarantees the avatar will sign with both hands regardless of STT/Gloss.
    """
    sigml_text = """<sigml>

  <hns_sign gloss="XIN_CHAO">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamflathand/><hamthumboutmod/><hamextfingerur/><hampalml/>
        <hamplus/><hamflathand/><hamthumboutmod/><hamextfingerul/><hampalml/>
      <hamparend/>
      <hammoveu/><hamsmallmod/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="HOM_NAY">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamflathand/><hamextfingero/><hampalml/>
        <hamplus/><hamflathand/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammoved/><hamsmallmod/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="TOI">
    <hamnosys_manual>
      <hamfinger2/><hamthumbacrossmod/><hamextfingeril/><hampalmr/><hamtouch/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="CHIA_SE">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamceeall/><hamextfingeror/><hampalml/>
        <hamplus/><hamceeall/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammoveo/><hamsmallmod/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="Y_TUONG">
    <hamnosys_manual>
      <hamfist/><hamthumbacrossmod/><hamextfingeror/><hampalml/>
      <hammoveu/><hamarcu/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="GIAO_DUC">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamceeall/><hamextfingeror/><hampalml/>
        <hamplus/><hamceeall/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammoveu/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="DU_AN">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamflathand/><hamextfingeror/><hampalml/>
        <hamplus/><hamflathand/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammoveu/><hamsmallmod/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="AI">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamflathand/><hamextfingeror/><hampalml/>
        <hamplus/><hamflathand/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammoveo/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="GIUP">
    <hamnosys_manual>
      <hamfinger2/><hamthumbacrossmod/><hamextfingeril/><hampalmr/><hamtouch/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="NGUOI_DIEC">
    <hamnosys_manual>
      <hamfinger23/><hamextfingerui/><hampalml/><hamear/><hamtouch/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="TIEP_CAN">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamflathand/><hamextfingeror/><hampalml/>
        <hamplus/><hamflathand/><hamextfingerol/><hampalml/>
      <hamparend/>
      <hammovei/><hamsmallmod/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="NOI_DUNG">
    <hamnosys_manual>
      <hamsymmlr/>
      <hamparbegin/>
        <hamfinger2/><hamthumbacrossmod/><hamextfingerl/><hampalml/>
        <hamplus/><hamfinger2/><hamthumbacrossmod/><hamextfingeru/><hampalml/>
      <hamparend/>
      <hamtouch/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="HOC_TAP">
    <hamnosys_manual>
      <hamfist/><hamthumbacrossmod/><hambetween/>
      <hamflathand/><hamextfingeru/><hampalml/><hamtouch/>
    </hamnosys_manual>
  </hns_sign>

  <hns_sign gloss="DE_DANG_HON">
    <hamnosys_manual>
      <hamfinger2/><hamthumbacrossmod/><hamextfingeril/><hampalmr/><hamtouch/>
    </hamnosys_manual>
  </hns_sign>

</sigml>
"""
    with open(output_sigml, "w", encoding="utf-8") as f:
        f.write(sigml_text)


@app.route("/")
@timed_execution
def index() -> str:
    """Render main landing page with video list.

    Returns:
        Rendered HTML template
    """
    videos = manifest_repository.get_all_videos()
    # Convert to dict for template compatibility
    videos_data = [v.to_dict() for v in videos]
    return render_template(
        "index.html",
        videos=videos_data,
        figma_url=get_figma_url(),
        figma_tokens=get_figma_tokens(),
    )


@app.route("/watch/<vid>")
@timed_execution
def watch(vid: str) -> Union[str, Response]:
    """Display video with sign language avatar.

    Args:
        vid: Video identifier

    Returns:
        Rendered HTML template or redirect
    """
    try:
        # Get video data from service
        viewing_data = video_service.get_video_for_viewing(vid)

        # Support embed mode for hub iframe
        is_embed = request.args.get("embed") == "1"

        return render_template(
            "result.html",
            video=None,
            video_url=viewing_data.video_url,
            sigml=viewing_data.sigml_filename,
            playlist=None,
            embed=is_embed,
        )

    except ValidationError:
        flash("Video không tồn tại trong manifest")
        return redirect(url_for("index"))

    except SignBridgeError as e:
        flash(f"Lỗi: {e}")
        return redirect(url_for("index"))


@app.route("/hub")
def hub() -> str:
    """Render learning hub page.

    Returns:
        Rendered HTML template
    """
    videos = manifest_repository.get_all_videos()
    # Convert to dict for template compatibility
    videos_data = [v.to_dict() for v in videos]
    return render_template("hub.html", videos=videos_data)


@app.route("/assets/<path:filename>")
def serve_assets(filename: str) -> Response:
    """Serve static asset files.

    Args:
        filename: Asset filename

    Returns:
        File response
    """
    return send_from_directory(os.path.join(BASE_DIR, "assets"), filename)


@app.route("/upload", methods=["POST"])
@timed_execution
def upload() -> Response:
    """Handle video upload and processing.

    Returns:
        Redirect response to preview page or index on error
    """
    video_file = request.files.get("video")

    try:
        # Process video through service
        result = video_service.upload_and_process(video_file)

        if not result.success:
            flash(f"Xử lý lỗi: {result.error_message}")
            return redirect(url_for("index"))

        # Redirect to preview
        return redirect(
            url_for(
                "preview",
                video=result.video_filename,
                sigml=result.sigml_filename,
                playlist=result.playlist_filename,
            )
        )

    except ValidationError as e:
        logger.warning(f"Validation error in upload: {e}")
        flash(str(e))
        return redirect(url_for("index"))

    except SignBridgeError as e:
        logger.error(f"Processing error in upload: {e}", exc_info=True)
        flash(f"Lỗi xử lý: {e}")
        return redirect(url_for("index"))


@app.route("/preview")
def preview() -> str:
    """Preview endpoint for iframe embed in Interactive Demo.

    Returns:
        Rendered HTML template
    """
    video = request.args.get("video")
    sigml = request.args.get("sigml")
    playlist_name = request.args.get("playlist")
    video_url = url_for("serve_upload", filename=video) if video else None
    return render_template(
        "result.html",
        video=video,
        video_url=video_url,
        sigml=sigml,
        playlist=playlist_name,
        embed=True,
    )


@app.route("/result")
def result():
    video = request.args.get("video")
    sigml = request.args.get("sigml")
    playlist_name = request.args.get("playlist")
    return render_template(
        "result.html", video=video, sigml=sigml, playlist=playlist_name
    )


@app.route("/add_to_hub", methods=["POST"])
@timed_execution
def add_to_hub() -> Tuple[Dict[str, Any], int]:
    """Add uploaded video to Learning Hub (manifest.json).

    Returns:
        Tuple of (JSON response, HTTP status code)
    """
    video_filename = request.form.get("video")
    sigml_filename = request.form.get("sigml")
    title = request.form.get("title", "Video mới")

    try:
        # Validate filenames to prevent path traversal
        RequestValidator.validate_filename(video_filename)
        RequestValidator.validate_filename(sigml_filename)
        # Add video through service
        video_id = video_service.add_to_learning_hub(
            video_filename=video_filename, sigml_filename=sigml_filename, title=title
        )

        logger.info(f"Video added to hub: {video_id}")
        return {"success": True, "videoId": video_id}, 200

    except ValidationError as e:
        logger.warning(f"Validation error in add_to_hub: {e}")
        return {"success": False, "error": str(e)}, 400

    except SignBridgeError as e:
        logger.error(f"Error in add_to_hub: {e}", exc_info=True)
        return {"success": False, "error": str(e)}, 500


@app.route("/static/uploads/<path:filename>")
def serve_upload(filename: str) -> Response:
    """Serve uploaded files.

    Args:
        filename: Upload filename

    Returns:
        File response
    """
    return send_from_directory(UPLOAD_DIR, filename)


@app.route("/out/<path:filename>")
def serve_out(filename: str) -> Response:
    """Serve output files (transcripts, SiGML, etc.).

    Args:
        filename: Output filename

    Returns:
        File response
    """
    return send_from_directory(OUT_DIR, filename)


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5001, debug=True)