from pathlib import Path

SKILL_ROOT = Path(__file__).resolve().parent
RESOURCE_BASES = (SKILL_ROOT / "references", SKILL_ROOT / "assets")
DEFAULT_RESOURCE = "references/workflows.md"

INTENT_SIGNALS = {
    "CLI": {"weight": 4, "keywords": ["cu", "clickup-cli", "terminal", "cli", "sprint", "standup"]},
    "MCP": {"weight": 4, "keywords": ["mcp", "code mode", "bulk", "docs", "goals", "webhooks", "chat"]},
    "INSTALL": {"weight": 4, "keywords": ["install", "setup", "not installed", "configure", "api key"]},
    "TASK_OPS": {"weight": 3, "keywords": ["create task", "update task", "delete task", "assign", "search"]},
    "DISCOVERY": {"weight": 3, "keywords": ["workspace", "spaces", "lists", "folders", "members"]},
}

RESOURCE_MAP = {
    "CLI": ["references/cli_reference.md", "references/workflows.md"],
    "MCP": ["references/tool_reference.md", "references/workflows.md"],
    "INSTALL": ["INSTALL_GUIDE.md"],
    "TASK_OPS": ["references/workflows.md", "references/cli_reference.md"],
    "DISCOVERY": ["references/workflows.md", "references/tool_reference.md"],
}

LOADING_LEVELS = {
    "ALWAYS": [DEFAULT_RESOURCE],
    "ON_DEMAND_KEYWORDS": ["full reference", "all tools", "all commands", "deep dive"],
    "ON_DEMAND": ["references/tool_reference.md", "references/cli_reference.md", "assets/tool_categories.md"],
}

def _task_text(task) -> str:
    parts = [
        str(getattr(task, "text", "")),
        str(getattr(task, "query", "")),
        " ".join(getattr(task, "keywords", []) or []),
    ]
    return " ".join(parts).lower()

def _guard_in_skill(relative_path: str) -> str:
    resolved = (SKILL_ROOT / relative_path).resolve()
    resolved.relative_to(SKILL_ROOT)
    if resolved.suffix.lower() != ".md":
        raise ValueError(f"Only markdown resources are routable: {relative_path}")
    return resolved.relative_to(SKILL_ROOT).as_posix()

def discover_markdown_resources() -> set[str]:
    docs = []
    for base in RESOURCE_BASES:
        if base.exists():
            docs.extend(p for p in base.rglob("*.md") if p.is_file())
    return {doc.relative_to(SKILL_ROOT).as_posix() for doc in docs}

def score_intents(task) -> dict[str, float]:
    """Weighted intent scoring from request text and capability signals."""
    text = _task_text(task)
    scores = {intent: 0.0 for intent in INTENT_SIGNALS}
    for intent, cfg in INTENT_SIGNALS.items():
        for keyword in cfg["keywords"]:
            if keyword in text:
                scores[intent] += cfg["weight"]
    if getattr(task, "cli_available", False):
        scores["CLI"] += 5
    if getattr(task, "code_mode_configured", False):
        scores["MCP"] += 4
    return scores

def select_intents(scores: dict[str, float], ambiguity_delta: float = 1.0, max_intents: int = 2) -> list[str]:
    ranked = sorted(scores.items(), key=lambda item: item[1], reverse=True)
    if not ranked or ranked[0][1] <= 0:
        return ["CLI"]
    selected = [ranked[0][0]]
    if len(ranked) > 1 and ranked[1][1] > 0 and (ranked[0][1] - ranked[1][1]) <= ambiguity_delta:
        selected.append(ranked[1][0])
    return selected[:max_intents]

def route_clickup_resources(task):
    inventory = discover_markdown_resources()
    intents = select_intents(score_intents(task), ambiguity_delta=1.0)
    loaded = []
    seen = set()

    def load_if_available(relative_path: str) -> None:
        guarded = _guard_in_skill(relative_path)
        if guarded in inventory and guarded not in seen:
            load(guarded)
            loaded.append(guarded)
            seen.add(guarded)

    for relative_path in LOADING_LEVELS["ALWAYS"]:
        load_if_available(relative_path)
    for intent in intents:
        for relative_path in RESOURCE_MAP.get(intent, []):
            load_if_available(relative_path)

    text = _task_text(task)
    if any(keyword in text for keyword in LOADING_LEVELS["ON_DEMAND_KEYWORDS"]):
        for relative_path in LOADING_LEVELS["ON_DEMAND"]:
            load_if_available(relative_path)

    if not loaded:
        load_if_available(DEFAULT_RESOURCE)

    return {"intents": intents, "resources": loaded}

# Check if installed
command -v cu && cu --version 2>&1 | head -1

# Installation
npm install -g @krodak/clickup-cli

# Initial setup (interactive)
cu init

# Verify (requires API token configured)
cu auth

# Discovery
cu spaces                     # List workspace spaces
cu lists <spaceId>            # List space lists
cu auth                       # Verify authentication

# Read Operations
cu tasks                      # My open tasks
cu assigned                   # Tasks assigned to me
cu sprint                     # Current sprint tasks
cu sprints                    # All sprints
cu summary                    # Sprint summary / standup
cu search <query>             # Search tasks
cu task <id>                  # Task details
cu subtasks <id>              # Task subtasks
cu comments <id>              # Task comments
cu activity <id>              # Task activity log
cu inbox                      # Notifications
cu overdue                    # Overdue tasks
cu open <query>               # Open task in browser

# Write Operations
cu create -n "name" -l <listId>       # Create task
cu update <id> --status "done"        # Update task
cu comment <id> -m "text"             # Post comment
cu assign <id> --to me                # Assign task
cu depend <id> --on <otherId>         # Add dependency
cu move <id> --to <listId>            # Move task
cu field <id> --set "Field" value     # Set custom field
cu tag <id> --add "bug,frontend"      # Add tags
cu delete <id> --confirm              # Delete task (DESTRUCTIVE)

// Discover ClickUp tools
search_tools({ task_description: "clickup tasks" });

// Create a task
await call_tool_chain({
  code: `
    const task = await clickup.clickup_create_task({
      listName: "Sprint Backlog",
      name: "Implement login page",
      description: "Build the login UI with email/password",
      priority: 2,
      assignees: ["me"]
    });
    return task;
  `
});

// Get workspace structure
await call_tool_chain({
  code: `
    const ws = await clickup.clickup_get_workspace({
      include_hierarchy: true
    });
    return ws;
  `
});

// Bulk create tasks
await call_tool_chain({
  code: `
    const tasks = await clickup.clickup_create_bulk_tasks({
      listName: "Sprint Backlog",
      tasks: [
        { name: "Task A", priority: 2 },
        { name: "Task B", priority: 3 },
        { name: "Task C", priority: 3 }
      ]
    });
    return tasks;
  `
});

// Manage documents
await call_tool_chain({
  code: `
    const doc = await clickup.clickup_create_document({
      parent: { id: spaceId, type: 4 },
      name: "Sprint Retrospective",
      visibility: "PUBLIC",
      content: "## What went well\\n- ...",
      content_format: "text/md"
    });
    return doc;
  `
});

// Get design info, create implementation task
const file = await figma.figma_get_file({ fileKey: "abc" });
const task = await clickup.clickup_create_task({
  listName: "Sprint Backlog",
  name: `Implement: ${file.name}`,
  description: `Design file: https://figma.com/file/abc`
});

# Get task details, create branch
cu task abc123 --json | jq -r '.name' | sed 's/ /-/g' | xargs -I{} git checkout -b "feature/{}"

# Daily workflow
cu tasks                       # My open tasks
cu sprint                      # Current sprint
cu summary                     # Sprint standup summary
cu assigned                    # Assigned to me
cu overdue                     # Overdue tasks
cu inbox                       # Notifications

# Task operations
cu create -n "Name" -l <listId>   # Create
cu update <id> --status "done"    # Update
cu task <id>                      # Details
cu search "query"                 # Search
cu comment <id> -m "text"         # Comment
cu delete <id> --confirm          # Delete

# Workspace
cu spaces                      # List spaces
cu lists <spaceId>             # List space lists
cu auth                        # Verify auth

// Tool naming: clickup.clickup_{tool_name}

// Task ops
clickup.clickup_create_task({ listName: "...", name: "..." })
clickup.clickup_get_task({ task: "task-id-or-name" })
clickup.clickup_update_task({ task: "id", status: "done" })
clickup.clickup_search_tasks({ query: "..." })

// Enterprise features (MCP-only)
clickup.clickup_manage_goals({ action: "list" })
clickup.clickup_create_document({ name: "...", content: "..." })
clickup.clickup_manage_time_entries({ action: "start_timer", task: "id" })
clickup.clickup_manage_webhooks({ action: "create", endpoint: "...", events: ["taskCreated"] })
clickup.clickup_manage_chat_messages({ action: "create", channel_name: "...", content: "..." })

What do you need?
     |
     +-- Task CRUD / Sprint / Standup
     |   +-- CLI available? --> cu commands (fastest)
     |   +-- CLI unavailable? --> MCP create/get/update_task
     |
     +-- Bulk operations
     |   +-- MCP: create_bulk_tasks, update_bulk_tasks
     |
     +-- Documents / Goals / Webhooks
     |   +-- MCP only (not available in CLI)
     |
     +-- Time Tracking / Chat
     |   +-- MCP only (manage_time_entries, manage_chat_*)
     |
     +-- Workspace discovery
     |   +-- CLI: cu spaces, cu lists
     |   +-- MCP: get_workspace (with hierarchy)
     |
     +-- Custom Fields / Tags / Checklists
         +-- CLI: cu field, cu tag (basic)
         +-- MCP: manage_custom_fields, manage_checklists (full CRUD)