import gradio as gr
import os, re, json, textwrap
from typing import Dict, Tuple

SKILLS_ROOT = os.path.join(os.path.dirname(__file__), "skills")

def parse_frontmatter(md_text: str) -> Tuple[dict, str]:
    if not md_text.startswith("---"):
        return {}, md_text
    parts = md_text.split("\n")
    if parts[0].strip() != "---":
        return {}, md_text
    try:
        end_idx = parts[1:].index("---") + 1
    except ValueError:
        return {}, md_text
    fm_lines = parts[1:end_idx]
    body = "\n".join(parts[end_idx+1:])
    meta = {}
    for line in fm_lines:
        if ":" in line:
            k, v = line.split(":", 1)
            meta[k.strip()] = v.strip().strip('"').strip("'")
    return meta, body

def load_skill(skill_slug: str):
    path = os.path.join(SKILLS_ROOT, skill_slug, "SKILL.md")
    if not os.path.exists(path):
        return {}, f"**SKILL.md not found for skill `{skill_slug}`.**"
    with open(path, "r", encoding="utf-8") as f:
        text = f.read()
    meta, body = parse_frontmatter(text)
    return meta, body

def list_skills():
    out = []
    if not os.path.isdir(SKILLS_ROOT):
        return out
    for name in sorted(os.listdir(SKILLS_ROOT)):
        if os.path.isdir(os.path.join(SKILLS_ROOT, name)) and os.path.exists(os.path.join(SKILLS_ROOT, name, "SKILL.md")):
            meta, _ = load_skill(name)
            out.append((name, meta.get("name", name), meta.get("description", "")))
    return out

def list_linked_files(skill_slug: str):
    root = os.path.join(SKILLS_ROOT, skill_slug)
    if not os.path.isdir(root):
        return []
    return [fn for fn in sorted(os.listdir(root)) if fn.lower().endswith(".md") and fn != "SKILL.md"]

def read_linked_file(skill_slug: str, filename: str) -> str:
    path = os.path.join(SKILLS_ROOT, skill_slug, filename)
    if not os.path.exists(path):
        return f"**{filename} not found.**"
    with open(path, "r", encoding="utf-8") as f:
        return f.read()

def run_pdf_tool(skill_slug: str, uploaded_pdf) -> str:
    try:
        if uploaded_pdf is None:
            return "Please upload a PDF."
        import runpy, json as _json, os as _os
        tool_path = os.path.join(SKILLS_ROOT, skill_slug, "tools", "extract_form_fields.py")
        if not os.path.exists(tool_path):
            return "Tool script not found. Expected tools/extract_form_fields.py"
        ns = runpy.run_path(tool_path)
        if "extract_fields" not in ns:
            return "extract_form_fields.py does not define extract_fields(pdf_path)."
        fn = ns["extract_fields"]
        result = fn(uploaded_pdf.name if hasattr(uploaded_pdf, "name") else uploaded_pdf)
        try:
            return "```json\n" + _json.dumps(result, indent=2) + "\n```"
        except Exception:
            return str(result)
    except Exception as e:
        return f"Error running tool: {e}"

def explain_progressive_disclosure() -> str:
    return (
        "### Progressive Disclosure\\n\\n"
        "1. **Startup**: Only skill *metadata* (name, description) is shown.\\n"
        "2. **Trigger**: Loading a skill reads **SKILL.md** into context.\\n"
        "3. **Deep Dive**: Linked files (e.g., `reference.md`, `forms.md`) are opened only when needed.\\n"
        "4. **Tools**: For the PDF skill, run the Python tool to extract form fields without adding the PDF to context."
    )

with gr.Blocks(title="Agent Skills — Progressive Disclosure Demo") as demo:
    gr.Markdown("# Equipping agents for the real world with Agent Skills\\nPublished Oct 16, 2025")
    gr.Markdown("This Space demonstrates **Agent Skills** as folders containing a `SKILL.md`, optional linked files, and tools.")

    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### Installed Skills")
            skills = list_skills()
            skill_map = {f"{title} — {desc}": slug for (slug, title, desc) in skills} if skills else {}
            labels = list(skill_map.keys()) or ["(No skills found)"]
            skill_dd = gr.Dropdown(choices=labels, value=labels[0], label="Pick a skill")
            meta_out = gr.JSON(label="Skill metadata")

            def on_pick(label):
                if not skill_map:
                    return {}, "", [], None, None
                slug = skill_map.get(label, None)
                if not slug:
                    return {}, "", [], None, None
                meta, body = load_skill(slug)
                return meta, body, list_linked_files(slug), slug, None

            body_out = gr.Markdown(label="SKILL.md body")
            linked_files = gr.Dropdown(choices=[], label="Linked files")
            selected_slug_state = gr.State(value=None)
            _reset = gr.State(value=None)

            skill_dd.change(fn=on_pick, inputs=[skill_dd], outputs=[meta_out, body_out, linked_files, selected_slug_state, _reset])

        with gr.Column(scale=2):
            gr.Markdown("### Progressive Disclosure")
            gr.Markdown(explain_progressive_disclosure())

            gr.Markdown("---")
            gr.Markdown("### Linked File Viewer")
            linked_view = gr.Markdown()

            def on_view_linked(filename, slug):
                if not slug or not filename:
                    return "Pick a skill and a linked file."
                return read_linked_file(slug, filename)

            view_btn = gr.Button("Open linked file")
            view_btn.click(fn=on_view_linked, inputs=[linked_files, selected_slug_state], outputs=[linked_view])

            gr.Markdown("---")
            gr.Markdown("### Run Skill Tool (PDF form field extractor)")
            pdf_in = gr.File(label="Upload a PDF", file_count="single", type="filepath")
            tool_out = gr.Markdown()

            def run_tool_clicked(slug, pdf):
                if not slug:
                    return "Pick a skill first."
                return run_pdf_tool(slug, pdf)

            run_tool_btn = gr.Button("Extract form fields")
            run_tool_btn.click(fn=run_tool_clicked, inputs=[selected_slug_state, pdf_in], outputs=[tool_out])

if __name__ == "__main__":
    demo.launch()