from pathlib import Path
from fastapi import APIRouter, Depends, HTTPException
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy import select
from app.dependencies import CommonContext
from app.models import Subject, Subtopic, Page, PageContent

router = APIRouter()
templates = Jinja2Templates(directory="app/templates")

# ── kanji resources live here on disk ────────────────────────────────────
KANJI_RESOURCE_DIR = Path("resources/japanese/kanji")


# ═══════════════════════════════════════════════════════════════════════════
# /japan/kanji/{page_slug}
#
# This route intercepts ALL 3-segment URLs where the second segment is
# "kanji" — because it is registered BEFORE the generic CMS route in main.py.
#
# It handles two distinct cases:
#
#   Case A — page_slug is a kanji character (non-ASCII), e.g. 水, 食, 飲
#             → look for kanji_{char}.html in the resources folder
#             → redirect to /resources/japanese/kanji/kanji_{char}.html
#               (or serve 404 if the file doesn't exist yet)
#
#   Case B — page_slug is an ASCII slug, e.g. kanji-tiles, kanji-links
#             → normal database lookup, exactly like the generic CMS route
#             → render page.html with the stored HTML content
#
# Why handle both here? Because FastAPI matched this route first. Once a route
# matches, there is no "fall through" to the next route. We own this path.
# ═══════════════════════════════════════════════════════════════════════════
@router.get("/{subject_slug}/kanji/{page_slug}", response_class=HTMLResponse)
async def kanji_page(
    subject_slug: str,
    page_slug:    str,
    ctx: CommonContext = Depends(),
):
    # Validate subject exists regardless of which case we're in
    subject = ctx.db.execute(
        select(Subject).where(Subject.slug == subject_slug)
    ).scalar_one_or_none()
    if not subject:
        raise HTTPException(status_code=404)

    # ── Case A: kanji character (contains non-ASCII) ─────────────────────
    if not page_slug.isascii():
        return _serve_kanji_character(page_slug)

    # ── Case B: ASCII slug — standard database lookup ─────────────────────
    return await _serve_kanji_cms_page(subject, page_slug, ctx)


def _serve_kanji_character(character: str) -> RedirectResponse:
    """Redirect /japan/kanji/水 → /resources/japanese/kanji/kanji_水.html

    The kanji detail pages are full standalone HTML files in the resources
    folder. We redirect to the static URL so the browser loads the file
    directly — no template rendering needed.

    In a future enhancement you could instead read the file content and
    inject it into the base template so the site nav and breadcrumbs appear.
    """
    resource_file = KANJI_RESOURCE_DIR / f"kanji_{character}.html"

    if not resource_file.exists():
        raise HTTPException(
            status_code=404,
            detail=f"No kanji page found for '{character}'. "
                   f"Generate it with: Kanji {character}",
        )

    # 302 redirect — browser follows it to the static resource URL
    return RedirectResponse(
        url=f"/resources/japanese/kanji/kanji_{character}.html",
        status_code=302,
    )


async def _serve_kanji_cms_page(
    subject:  Subject,
    page_slug: str,
    ctx:      CommonContext,
):
    """Look up and render an ASCII-slug page within the kanji subtopic."""
    subtopic = ctx.db.execute(
        select(Subtopic).where(
            Subtopic.slug       == "kanji",
            Subtopic.subject_id == subject.id,
        )
    ).scalar_one_or_none()
    if not subtopic:
        raise HTTPException(status_code=404)

    page = ctx.db.execute(
        select(Page).where(
            Page.slug        == page_slug,
            Page.subtopic_id == subtopic.id,
        )
    ).scalar_one_or_none()
    if not page:
        raise HTTPException(status_code=404)

    content_sections = ctx.db.execute(
        select(PageContent)
        .where(PageContent.page_id == page.id)
        .order_by(PageContent.display_order)
    ).scalars().all()

    from app.routers.cms import _prev_next
    prev_page, next_page = _prev_next(subtopic.pages, page.id)

    return templates.TemplateResponse(
        "page.html",
        ctx.get(
            subject=subject,
            subtopic=subtopic,
            page=page,
            content_sections=content_sections,
            prev_page=prev_page,
            next_page=next_page,
            breadcrumbs=[
                {"label": "Home",          "url": "/"},
                {"label": subject.name,   "url": f"/{subject.slug}"},
                {"label": subtopic.name, "url": f"/{subject.slug}/{subtopic.slug}"},
                {"label": page.name,     "url": None},
            ],
        ),
    )

from app.routers import cms, special

# ── Static mounts (checked before ANY route) ─────────────────────────────
app.mount("/static",    StaticFiles(directory="app/static"),  name="static")
app.mount("/resources", StaticFiles(directory="resources"),    name="resources")

# ── Routers — ORDER MATTERS ───────────────────────────────────────────────
# special must come before cms so that /{subject}/kanji/{char} routes
# are checked before the generic /{subject}/{subtopic}/{page} catch-all.
app.include_router(special.router)   # ← first: specific special-case routes
app.include_router(cms.router)       # ← second: general CMS three-level routes

# Standard string parameter — matches exactly ONE segment (no slashes)
@router.get("/{subject_slug}/{subtopic_slug}/{page_slug}")
async def cms_page(subject_slug: str, subtopic_slug: str, page_slug: str):
    pass
# Matches:  /japan/kanji/kanji-tiles   → all three parameters filled
# No match: /japan/kanji/topic/sub-item  → 4 segments, won't match this


# path convertor — matches ANY number of segments including slashes
@router.get("/{full_path:path}")
async def deep_route(full_path: str):
    parts = full_path.strip("/").split("/")
    pass
# Matches:  /japan/kanji/kanji-tiles     → full_path = "japan/kanji/kanji-tiles"
# Matches:  /japan/kanji/topic/sub/item  → full_path = "japan/kanji/topic/sub/item"
# Matches:  /anything/at/all/here        → full_path = "anything/at/all/here"


# int convertor — only matches if the segment is a valid integer
@router.get("/page/{page_id:int}")
async def page_by_id(page_id: int):  # already an int, not a string
    pass
# Matches:  /page/42    → page_id = 42
# No match: /page/hello  → skips this route, tries the next one

# ═══════════════════════════════════════════════════════════════════════════
# Catch-all: anything not matched by the routes above
# This runs LAST — only add this when you need it for deep/dynamic paths.
# Currently not needed; add in a future chapter if the site grows deeper.
# ═══════════════════════════════════════════════════════════════════════════
@router.get("/{full_path:path}", response_class=HTMLResponse, include_in_schema=False)
async def deep_catch_all(
    full_path: str,
    ctx: CommonContext = Depends(),
):
    # Parse the segments manually and try to match them to DB records
    # This is where you'd add 4-level or 5-level routing logic in future
    parts = [p for p in full_path.strip("/").split("/") if p]
    # For now, any unknown path gets a 404
    raise HTTPException(status_code=404)

// Before — links to the raw resource path
const kanjiList = [
  { kanji: '水', file: '/resources/japanese/kanji/kanji_水.html', meaning: 'Water' },
  { kanji: '食', file: '/resources/japanese/kanji/kanji_食.html', meaning: 'Eat / Food' },
  { kanji: '飲', file: '/resources/japanese/kanji/kanji_飲.html', meaning: 'Drink / Swallow' },
];

// After — links to the clean CMS-style URL
// FastAPI's special.py redirects /japan/kanji/水 → /resources/…
const kanjiList = [
  { kanji: '水', file: '/japan/kanji/水', meaning: 'Water' },
  { kanji: '食', file: '/japan/kanji/食', meaning: 'Eat / Food' },
  { kanji: '飲', file: '/japan/kanji/飲', meaning: 'Drink / Swallow' },
];

from fastapi.responses import RedirectResponse

# 301 Moved Permanently
# Browser caches this. Future requests go directly to the new URL.
# Use for: canonical URL changes, old URLs you're retiring forever.
# Caution: very hard to undo — cached in browsers indefinitely.
return RedirectResponse(url="/new-path", status_code=301)

# 302 Found (temporary redirect) — default in FastAPI
# Browser does NOT cache. Every request re-checks the original URL.
# Use for: kanji character → resource file (we might change this later)
return RedirectResponse(url="/new-path", status_code=302)

# 307 Temporary Redirect
# Like 302 but guarantees the HTTP method is preserved (POST stays POST).
# Use for: form submissions that redirect to a different handler.
return RedirectResponse(url="/new-path", status_code=307)

# ── A search endpoint ────────────────────────────────────────────────────
# GET /search?q=kanji
# Would sit above the CMS routes so /search is not treated as a subject slug
@router.get("/search", response_class=HTMLResponse)
async def search(q: str = "", ctx: CommonContext = Depends()):
    pass  # implement in future


# ── An RSS feed ───────────────────────────────────────────────────────────
# GET /feed.xml — must be above /{subject_slug} or "feed.xml" becomes a subject
@router.get("/feed.xml")
async def rss_feed(ctx: CommonContext = Depends()):
    pass


# ── A four-level page for a language course with categories ───────────────
# GET /python/web/fastapi/routing
# subject / subtopic / category / page  (4 levels deep)
@router.get("/python/{subtopic_slug}/{category_slug}/{page_slug}",
           response_class=HTMLResponse)
async def python_deep_page(
    subtopic_slug:  str,
    category_slug:  str,
    page_slug:      str,
    ctx: CommonContext = Depends(),
):
    pass