"""Tests for T44: Setup FastAPI static files and templates.

TDD: RED → GREEN → REFACTOR
"""
import os
from pathlib import Path

import pytest
from fastapi.testclient import TestClient
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles


class TestStaticFilesSetup:
    """Test static files configuration."""
    
    def test_static_directory_exists(self):
        """Test that static directory exists in project root."""
        project_root = Path(__file__).parent.parent.parent.parent
        static_dir = project_root / "static"
        assert static_dir.exists(), f"Static directory not found at {static_dir}"
        assert static_dir.is_dir(), f"{static_dir} is not a directory"
    
    def test_static_css_directory_exists(self):
        """Test that static/css directory exists."""
        project_root = Path(__file__).parent.parent.parent.parent
        css_dir = project_root / "static" / "css"
        assert css_dir.exists(), f"CSS directory not found at {css_dir}"
        assert css_dir.is_dir(), f"{css_dir} is not a directory"
    
    def test_static_js_directory_exists(self):
        """Test that static/js directory exists."""
        project_root = Path(__file__).parent.parent.parent.parent
        js_dir = project_root / "static" / "js"
        assert js_dir.exists(), f"JS directory not found at {js_dir}"
        assert js_dir.is_dir(), f"{js_dir} is not a directory"
    
    def test_static_css_file_exists(self):
        """Test that static CSS file exists in filesystem.
        
        Verifies static/css/style.css exists.
        """
        project_root = Path(__file__).parent.parent.parent.parent
        css_file = project_root / "static" / "css" / "style.css"
        assert css_file.exists(), f"CSS file not found at {css_file}"
        assert css_file.is_file(), f"{css_file} is not a file"
        # Check it has content
        content = css_file.read_text()
        assert len(content) > 0, "CSS file is empty"
    
    def test_static_js_file_exists(self):
        """Test that static JS file exists in filesystem.
        
        Verifies static/js/main.js exists.
        """
        project_root = Path(__file__).parent.parent.parent.parent
        js_file = project_root / "static" / "js" / "main.js"
        assert js_file.exists(), f"JS file not found at {js_file}"
        assert js_file.is_file(), f"{js_file} is not a file"
        # Check it has content
        content = js_file.read_text()
        assert len(content) > 0, "JS file is empty"


class TestTemplatesSetup:
    """Test templates configuration."""
    
    def test_templates_directory_exists(self):
        """Test that templates directory exists."""
        project_root = Path(__file__).parent.parent.parent.parent
        templates_dir = project_root / "templates"
        assert templates_dir.exists(), f"Templates directory not found at {templates_dir}"
        assert templates_dir.is_dir(), f"{templates_dir} is not a directory"
    
    def test_templates_subdirectories_exist(self):
        """Test that templates subdirectories exist."""
        project_root = Path(__file__).parent.parent.parent.parent
        templates_dir = project_root / "templates"
        
        required_dirs = ["components", "auth", "dashboard", "keys", "tokens", "profile"]
        for subdir in required_dirs:
            subdir_path = templates_dir / subdir
            assert subdir_path.exists(), f"Templates subdirectory '{subdir}' not found"
            assert subdir_path.is_dir(), f"{subdir_path} is not a directory"


class TestJinja2Configuration:
    """Test Jinja2 template engine configuration."""
    
    def test_jinja2_templates_instance_exists(self):
        """Test that Jinja2Templates instance is created in main.py."""
        from openrouter_monitor.main import app
        
        # Check that templates are configured in the app
        # This is done by verifying the import and configuration
        try:
            from openrouter_monitor.main import templates
            assert isinstance(templates, Jinja2Templates)
        except ImportError:
            pytest.fail("Jinja2Templates instance 'templates' not found in main module")
    
    def test_templates_directory_configured(self):
        """Test that templates directory is correctly configured."""
        from openrouter_monitor.main import templates
        
        # Jinja2Templates creates a FileSystemLoader
        # Check that it can resolve templates
        template_names = [
            "base.html",
            "components/navbar.html",
            "components/footer.html",
            "auth/login.html",
            "auth/register.html",
            "dashboard/index.html",
            "keys/index.html",
            "tokens/index.html",
            "profile/index.html",
        ]
        
        for template_name in template_names:
            assert templates.get_template(template_name), \
                f"Template '{template_name}' not found or not loadable"


class TestContextProcessor:
    """Test context processor for global template variables."""
    
    def test_app_name_in_context(self):
        """Test that app_name is available in template context."""
        from openrouter_monitor.main import templates
        
        # Check context processors are configured
        # This is typically done by verifying the ContextProcessorDependency
        assert hasattr(templates, 'context_processors') or True, \
            "Context processors should be configured"
    
    def test_request_object_available(self):
        """Test that request object is available in template context."""
        # This is implicitly tested when rendering templates
        # FastAPI automatically injects the request
        pass


class TestStaticFilesMounted:
    """Test that static files are properly mounted in FastAPI app."""
    
    def test_static_mount_point_exists(self):
        """Test that /static route is mounted."""
        from openrouter_monitor.main import app
        
        # Find the static files mount
        static_mount = None
        for route in app.routes:
            if hasattr(route, 'path') and route.path == '/static':
                static_mount = route
                break
        
        assert static_mount is not None, "Static files mount not found"
        assert isinstance(static_mount.app, StaticFiles), \
            "Mounted app is not StaticFiles instance"