template_loader.py

"""
Template Loader - Load and manage render templates from JSON files.

Handles loading builtin and user templates, applying them to UI controls,
and saving user templates.
"""

import json
import os
from typing import Dict, List, Optional, Any
from pathlib import Path


# Template directory paths (relative to this module)
_MODULE_DIR = Path(__file__).parent
BUILTIN_TEMPLATES_DIR = _MODULE_DIR / "templates" / "builtin"
USER_TEMPLATES_DIR = _MODULE_DIR / "templates" / "user"


def get_template_dirs() -> tuple:
    """
    Get paths to template directories.
    
    Returns:
        Tuple of (builtin_dir, user_dir)
    """
    return BUILTIN_TEMPLATES_DIR, USER_TEMPLATES_DIR


def ensure_template_dirs():
    """Create template directories if they don't exist."""
    BUILTIN_TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
    USER_TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)


def list_templates(template_type: str = None) -> List[Dict]:
    """
    List all available templates.
    
    Args:
        template_type: Filter by type (e.g., 'spinrender', 'static')
                      None returns all templates
    
    Returns:
        List of template info dicts with keys: name, description, type, path, is_builtin
    """
    ensure_template_dirs()
    templates = []
    
    # Load builtin templates
    for path in BUILTIN_TEMPLATES_DIR.glob("*.json"):
        try:
            with open(path, "r", encoding="utf-8") as f:
                data = json.load(f)
                if template_type is None or data.get("type") == template_type:
                    templates.append({
                        "name": data.get("name", path.stem),
                        "description": data.get("description", ""),
                        "type": data.get("type", "unknown"),
                        "path": str(path),
                        "is_builtin": True
                    })
        except (json.JSONDecodeError, IOError):
            pass  # Skip invalid files
    
    # Load user templates
    for path in USER_TEMPLATES_DIR.glob("*.json"):
        try:
            with open(path, "r", encoding="utf-8") as f:
                data = json.load(f)
                if template_type is None or data.get("type") == template_type:
                    templates.append({
                        "name": data.get("name", path.stem),
                        "description": data.get("description", ""),
                        "type": data.get("type", "unknown"),
                        "path": str(path),
                        "is_builtin": False
                    })
        except (json.JSONDecodeError, IOError):
            pass
    
    return sorted(templates, key=lambda x: (not x["is_builtin"], x["name"].lower()))


def load_template(path: str) -> Optional[Dict]:
    """
    Load a template from file.
    
    Args:
        path: Path to template JSON file
    
    Returns:
        Template dict or None if failed
    """
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except (json.JSONDecodeError, IOError) as e:
        print(f"Failed to load template {path}: {e}")
        return None


def load_template_by_name(name: str, template_type: str = None) -> Optional[Dict]:
    """
    Load a template by name.
    
    Args:
        name: Template name
        template_type: Optional type filter
    
    Returns:
        Template dict or None if not found
    """
    templates = list_templates(template_type)
    for t in templates:
        if t["name"].lower() == name.lower():
            return load_template(t["path"])
    return None


def save_template(template: Dict, name: str = None) -> str:
    """
    Save a template to user templates directory.
    
    Args:
        template: Template dict to save
        name: Optional name override (uses template["name"] if not provided)
    
    Returns:
        Path to saved file
    """
    ensure_template_dirs()
    
    name = name or template.get("name", "Untitled")
    # Sanitize filename
    safe_name = "".join(c for c in name if c.isalnum() or c in " -_").strip()
    safe_name = safe_name.replace(" ", "_").lower()
    
    path = USER_TEMPLATES_DIR / f"{safe_name}.json"
    
    with open(path, "w", encoding="utf-8") as f:
        json.dump(template, f, indent=4)
    
    return str(path)


def delete_template(path: str) -> bool:
    """
    Delete a user template.
    
    Args:
        path: Path to template file
    
    Returns:
        True if deleted, False if builtin or failed
    """
    path = Path(path)
    
    # Don't allow deleting builtin templates
    if BUILTIN_TEMPLATES_DIR in path.parents or path.parent == BUILTIN_TEMPLATES_DIR:
        return False
    
    try:
        path.unlink()
        return True
    except IOError:
        return False


def template_to_params(template: Dict) -> Dict:
    """
    Convert template dict to flat CLI parameters dict.
    
    Args:
        template: Template dict with nested structure
    
    Returns:
        Flat dict of CLI parameters
    """
    params = {}
    
    # Image settings
    img = template.get("image_settings", {})
    params["width"] = img.get("width", 1920)
    params["height"] = img.get("height", 1080)
    params["side"] = img.get("side", "top")
    params["background"] = img.get("background", "transparent")
    params["quality"] = img.get("quality", "high")
    params["preset"] = img.get("preset", "follow_plot_settings")
    params["use_board_stackup_colors"] = img.get("use_board_stackup_colors", False)
    params["floor"] = img.get("floor", False)
    params["perspective"] = img.get("perspective", True)
    
    # Camera settings
    cam = template.get("camera_settings", {})
    params["zoom"] = cam.get("zoom", 1.0)
    params["pan"] = cam.get("pan", "")
    params["pivot"] = cam.get("pivot", "")
    params["rotate"] = cam.get("rotate", "0,0,0")
    
    # Lighting
    light = template.get("lighting", {})
    params["light_top"] = light.get("top", 0.5)
    params["light_bottom"] = light.get("bottom", 0.1)
    params["light_side"] = light.get("side", 0.3)
    params["light_camera"] = light.get("camera", 0.2)
    params["light_side_elevation"] = light.get("side_elevation", 60)
    
    # Animation (for spinrender)
    anim = template.get("animation", {})
    params["fps"] = anim.get("fps", 30)
    params["duration"] = anim.get("duration", 3)
    params["frames"] = anim.get("frames", 90)
    params["format"] = anim.get("format", "mp4")
    params["tilt_x"] = anim.get("tilt_x", -30)
    params["tilt_y"] = anim.get("tilt_y", 0)
    
    return params


def params_to_template(params: Dict, name: str, description: str = "", 
                       template_type: str = "spinrender") -> Dict:
    """
    Convert flat CLI parameters to template dict structure.
    
    Args:
        params: Flat dict of parameters
        name: Template name
        description: Template description
        template_type: Template type
    
    Returns:
        Template dict with nested structure
    """
    return {
        "name": name,
        "description": description,
        "type": template_type,
        "version": "1.0",
        "image_settings": {
            "width": params.get("width", 1920),
            "height": params.get("height", 1080),
            "side": params.get("side", "top"),
            "background": params.get("background", "transparent"),
            "quality": params.get("quality", "high"),
            "preset": params.get("preset", "follow_plot_settings"),
            "use_board_stackup_colors": params.get("use_board_stackup_colors", False),
            "floor": params.get("floor", False),
            "perspective": params.get("perspective", True)
        },
        "camera_settings": {
            "zoom": params.get("zoom", 1.0),
            "pan": params.get("pan", ""),
            "pivot": params.get("pivot", ""),
            "rotate": params.get("rotate", "0,0,0")
        },
        "lighting": {
            "top": params.get("light_top", 0.5),
            "bottom": params.get("light_bottom", 0.1),
            "side": params.get("light_side", 0.3),
            "camera": params.get("light_camera", 0.2),
            "side_elevation": params.get("light_side_elevation", 60)
        },
        "animation": {
            "fps": params.get("fps", 30),
            "duration": params.get("duration", 3),
            "frames": params.get("frames", 90),
            "format": params.get("format", "mp4"),
            "tilt_x": params.get("tilt_x", -30),
            "tilt_y": params.get("tilt_y", 0)
        }
    }


def get_default_template(template_type: str = "spinrender") -> Dict:
    """
    Get the default template for a type.
    
    Args:
        template_type: Template type
    
    Returns:
        Default template dict
    """
    # Try to load builtin default
    default = load_template_by_name("Default", template_type)
    if default:
        return default
    
    # Return hardcoded default
    return params_to_template({}, "Default", "Default settings", template_type)