import os
import requests
from typing import Any, List, Optional
from mcp.server.fastmcp import FastMCP
from dotenv import load_dotenv

load_dotenv()

PLANKA_URL = os.getenv("PLANKA_URL", "http://localhost:3000")
PLANKA_TOKEN = os.getenv("PLANKA_TOKEN")

# Initialize FastMCP server
mcp = FastMCP("Planka")

class PlankaClient:
    def __init__(self, url: str, token: str):
        self.url = url.rstrip("/")
        self.token = token
        # Planka uses standard JWT tokens, but they don't always require "Bearer " in the header 
        # for all internal API calls, though standard is to use it.
        self.headers = {"Authorization": f"Bearer {token}"}

    def _get(self, endpoint: str, params: Optional[dict] = None) -> Any:
        response = requests.get(f"{self.url}/api/{endpoint}", headers=self.headers, params=params)
        response.raise_for_status()
        return response.json()

    def _post(self, endpoint: str, data: dict) -> Any:
        response = requests.post(f"{self.url}/api/{endpoint}", headers=self.headers, json=data)
        response.raise_for_status()
        return response.json()

    def get_projects(self) -> List[dict]:
        data = self._get("projects")
        # Handle Planka API response structure which often wraps items in 'items'
        if isinstance(data, dict) and "items" in data:
            return data["items"]
        return data

    def get_boards(self, project_id: str) -> List[dict]:
        data = self._get(f"projects/{project_id}/boards")
        if isinstance(data, dict) and "items" in data:
            return data["items"]
        return data

    def get_cards(self, board_id: str) -> List[dict]:
        data = self._get(f"boards/{board_id}/cards")
        if isinstance(data, dict) and "items" in data:
            return data["items"]
        return data

    def create_card(self, board_id: str, list_id: str, name: str, description: str = "") -> dict:
        return self._post("cards", {
            "boardId": board_id,
            "listId": list_id,
            "name": name,
            "description": description
        })

# Initialize client lazily
client = None

def get_client():
    global client
    if client is None:
        if not PLANKA_TOKEN:
            raise ValueError("PLANKA_TOKEN is required")
        client = PlankaClient(PLANKA_URL, PLANKA_TOKEN)
    return client

@mcp.tool()
def list_projects() -> str:
    """List all Planka projects available to the user."""
    projects = get_client().get_projects()
    if not projects:
        return "No projects found."
    return "\n".join([f"- {p['name']} (ID: {p['id']})" for p in projects])

@mcp.tool()
def list_boards(project_id: str) -> str:
    """List all boards for a given project ID."""
    boards = get_client().get_boards(project_id)
    if not boards:
        return "No boards found."
    return "\n".join([f"- {b['name']} (ID: {b['id']})" for b in boards])

@mcp.tool()
def list_cards(board_id: str) -> str:
    """List all cards for a given board ID."""
    cards = get_client().get_cards(board_id)
    if not cards:
        return "No cards found."
    return "\n".join([f"- {c['name']} (ID: {c['id']})" for c in cards])

@mcp.tool()
def create_card(board_id: str, list_id: str, name: str, description: str = "") -> str:
    """Create a new card on a Planka board."""
    card = get_client().create_card(board_id, list_id, name, description)
    return f"Created card: {card['name']} (ID: {card['id']})"

if __name__ == "__main__":
    mcp.run()