template_manager.py

"""
KiRender Template Manager
Unified template system for SpinRender, Static Images, and Pinout tabs.
All templates in ONE folder, filtered by 'template_type' field.

Template Schema v1.0:
- version: Schema version for compatibility
- locked: True for built-in templates (read-only)
- name: Display name
- description: Template description
- template_type: "spinrender", "static", or "pinout"
- created: ISO timestamp
- modified: ISO timestamp
- cli_params: All kicad-cli pcb render parameters (see cli_builder.py for schema)
"""

import os
import json
from datetime import datetime
from typing import Dict, List, Optional, Any

# Import CLI schema from the single source of truth
from .cli_builder import CLI_SCHEMA, get_default_params

# Template schema version
SCHEMA_VERSION = "1.0"

# Base templates directory - ONE folder for all
TEMPLATES_DIR = os.path.join(os.path.dirname(__file__), 'templates')
BUILTIN_DIR = os.path.join(TEMPLATES_DIR, 'builtin')
USER_DIR = os.path.join(TEMPLATES_DIR, 'user')

# Template types
TEMPLATE_TYPES = ['spinrender', 'static', 'pinout']


def get_empty_template(template_type: str = "static") -> Dict[str, Any]:
    """Return an empty template with default CLI parameters."""
    return {
        "version": SCHEMA_VERSION,
        "locked": False,
        "name": "",
        "description": "",
        "template_type": template_type,
        "created": datetime.now().isoformat(),
        "modified": datetime.now().isoformat(),
        "cli_params": get_default_params()
    }


def load_template(filepath: str) -> Optional[Dict[str, Any]]:
    """Load a single template from file."""
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            template = json.load(f)
        # Ensure required fields
        template.setdefault("version", "1.0")
        template.setdefault("locked", False)
        template.setdefault("template_type", "static")
        template.setdefault("cli_params", {})
        # Fill missing CLI params with defaults from cli_builder
        defaults = get_default_params()
        for key, default_val in defaults.items():
            template["cli_params"].setdefault(key, default_val)
        return template
    except Exception as e:
        print(f"Error loading template {filepath}: {e}")
        return None


def load_all_templates(template_type: str = None) -> Dict[str, Dict[str, Any]]:
    """Load all templates, optionally filtered by type."""
    templates = {}
    
    for subdir, is_builtin in [(BUILTIN_DIR, True), (USER_DIR, False)]:
        if not os.path.exists(subdir):
            os.makedirs(subdir, exist_ok=True)
            continue
        
        for filename in os.listdir(subdir):
            if filename.endswith('.json'):
                filepath = os.path.join(subdir, filename)
                template = load_template(filepath)
                if template:
                    # Filter by type if specified
                    ttype = template.get("template_type") or template.get("type")
                    if template_type and ttype != template_type:
                        continue
                    
                    name = template.get("name", filename[:-5])
                    template["_filepath"] = filepath
                    template["_is_builtin"] = is_builtin
                    templates[name] = template
    
    return templates


def save_template(template: Dict[str, Any], name: str = None) -> str:
    """Save a template to user directory. Returns filepath."""
    if name:
        template["name"] = name
    
    # Update metadata
    template["version"] = SCHEMA_VERSION
    template["modified"] = datetime.now().isoformat()
    template["locked"] = False
    
    if "created" not in template:
        template["created"] = template["modified"]
    
    # Generate safe filename
    safe_name = "".join(c if c.isalnum() or c in "._- " else "_" for c in template["name"])
    safe_name = safe_name.strip().replace(" ", "_").lower()
    filename = f"{safe_name}.json"
    
    # Save to user directory
    os.makedirs(USER_DIR, exist_ok=True)
    filepath = os.path.join(USER_DIR, filename)
    
    # Remove internal fields before saving
    save_data = {k: v for k, v in template.items() if not k.startswith("_")}
    
    with open(filepath, 'w', encoding='utf-8') as f:
        json.dump(save_data, f, indent=2)
    
    return filepath


def delete_template(template: Dict[str, Any]) -> bool:
    """Delete a user template. Returns True if successful."""
    if template.get("locked") or template.get("_is_builtin"):
        return False
    
    filepath = template.get("_filepath")
    if filepath and os.path.exists(filepath):
        os.remove(filepath)
        return True
    return False


def duplicate_template(template: Dict[str, Any], new_name: str) -> str:
    """Duplicate a template with a new name. Returns filepath."""
    new_template = {k: v for k, v in template.items() if not k.startswith("_")}
    new_template["name"] = new_name
    new_template["locked"] = False
    new_template["created"] = datetime.now().isoformat()
    return save_template(new_template)


# ============== CLI Generator (delegates to cli_builder) ==============

def build_cli_args(cli_params: Dict[str, Any], kicad_cli: str, pcb_path: str, output_path: str) -> List[str]:
    """Build complete CLI argument list from template parameters.
    
    NOTE: This delegates to cli_builder.build_cli_command() which is the
    single source of truth for CLI construction.
    """
    from .cli_builder import build_cli_command
    return build_cli_command(cli_params, kicad_cli, pcb_path, output_path)


def get_cli_string(cli_params: Dict[str, Any], kicad_cli: str = "kicad-cli", 
                   pcb_path: str = "board.kicad_pcb", output_path: str = "output.png") -> str:
    """Get CLI command as string for display/logging."""
    from .cli_builder import get_cli_string as _get_cli_string
    return _get_cli_string(cli_params, kicad_cli, pcb_path, output_path)


# ============== Built-in Template Initialization ==============

BUILTIN_TEMPLATES = {
    # SpinRender templates
    "Studio Pro": {
        "template_type": "spinrender",
        "description": "Professional studio look with high quality rendering",
        "cli_params": {
            "width": 1920, "height": 1080,
            "quality": "high",
            "perspective": False,
            "zoom": 1.0,
        }
    },
    "Technical Clean": {
        "template_type": "spinrender",
        "description": "Clean technical render for documentation",
        "cli_params": {
            "width": 1600, "height": 900,
            "quality": "high",
            "perspective": False,
        }
    },
    "Cinematic": {
        "template_type": "spinrender",
        "description": "Dramatic angled view for presentations",
        "cli_params": {
            "width": 1920, "height": 1080,
            "quality": "high",
            "perspective": True,
            "zoom": 1.2,
            "rotate": "-30,0,30",
        }
    },
    "Isometric View": {
        "template_type": "spinrender",
        "description": "Classic isometric angle for documentation",
        "cli_params": {
            "width": 1600, "height": 1600,
            "quality": "high",
            "perspective": False,
            "rotate": "-45,0,45",
        }
    },
    
    # Static Image templates
    "Product Shot": {
        "template_type": "static",
        "description": "Clean product image with white background",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "top",
            "background": "opaque",
            "quality": "high",
        }
    },
    "Technical Top": {
        "template_type": "static",
        "description": "Top-down technical view",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "top",
            "background": "transparent",
            "quality": "high",
        }
    },
    "Technical Bottom": {
        "template_type": "static",
        "description": "Bottom-side view for assembly documentation",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "bottom",
            "background": "transparent",
            "quality": "high",
        }
    },
    "Showcase": {
        "template_type": "static",
        "description": "Angled showcase view",
        "cli_params": {
            "width": 1920, "height": 1080,
            "side": "front",
            "background": "opaque",
            "quality": "high",
            "perspective": True,
            "rotate": "-20,0,15",
            "zoom": 1.1,
        }
    },
    
    # Pinout templates
    "Pinout Clean": {
        "template_type": "pinout",
        "description": "Clean pinout diagram with transparent background",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "top",
            "background": "transparent",
            "quality": "basic",
        }
    },
    "Pinout High Quality": {
        "template_type": "pinout",
        "description": "High quality raytraced pinout",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "top",
            "background": "transparent",
            "quality": "high",
        }
    },
    "Pinout Bottom Side": {
        "template_type": "pinout",
        "description": "Bottom-side pinout diagram",
        "cli_params": {
            "width": 2400, "height": 1600,
            "side": "bottom",
            "background": "transparent",
            "quality": "high",
        }
    },
}


def create_builtin_templates():
    """Create built-in templates if they don't exist."""
    os.makedirs(BUILTIN_DIR, exist_ok=True)
    os.makedirs(USER_DIR, exist_ok=True)
    
    for name, data in BUILTIN_TEMPLATES.items():
        # Create full template structure
        template = get_empty_template(data.get("template_type", "static"))
        template["name"] = name
        template["locked"] = True
        template["description"] = data.get("description", "")
        template["cli_params"].update(data.get("cli_params", {}))
        
        # Save
        safe_name = name.lower().replace(" ", "_")
        filepath = os.path.join(BUILTIN_DIR, f"{safe_name}.json")
        
        # Only create if doesn't exist
        if not os.path.exists(filepath):
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(template, f, indent=2)


# Initialize built-in templates on module load
create_builtin_templates()