"""
=======================================================================
 Název:   mcp_owa_v1.1.py
 Verze:   1.1
 Datum:   2026-06-04
 Popis:   MCP server pro práci s otevřeným OWA oknem (Playwright).
          Drží persistent session a vystavuje tooly:
            - vyhledání emailu v MongoDB OperativniEmailyJNJ.messages
            - otevření emailu v OWA UI přes search
            - Forward → vepsání úvodního textu na začátek body
            - zavření původního čtecího panelu
          Odeslání forwardu dělá uživatel sám.
          Profil sdílí s import_emails_to_mongo_v1.0.py (outlook_profile/).

 Změny v1.1:
   - sync_playwright v dedikovaném worker threadu (Windows + async_playwright
     v persistent contextu padá: Chrome se zavře hned po startu).
   - FastMCP tooly synchronní, dispatch na worker přes queue + Future.

 Spuštění: python mcp_owa_v1.1.py
=======================================================================
"""

import queue
import sys
import threading
from concurrent.futures import Future
from datetime import datetime, timezone
from pathlib import Path
from typing import Optional

from mcp.server.fastmcp import FastMCP
from playwright.sync_api import sync_playwright, Page, BrowserContext
from pymongo import MongoClient, DESCENDING

# ── Konfigurace ────────────────────────────────────────────────────────
BASE_DIR    = Path(__file__).resolve().parent
PROFILE_DIR = BASE_DIR / "outlook_profile"
START_URL   = "https://outlook.cloud.microsoft/mail/"

MONGO_URI = "mongodb://192.168.1.76:27017"
DB_NAME   = "OperativniEmailyJNJ"
COL_NAME  = "messages"

SEARCH_READY = (
    '[placeholder*="Search"], [aria-label*="Search"], '
    '[placeholder*="Hledat"], [aria-label*="Hledat"]'
)


def log(msg: str):
    print(msg, file=sys.stderr, flush=True)


# ── Worker thread (drží Playwright) ────────────────────────────────────

class PWWorker:
    def __init__(self):
        self.q: queue.Queue = queue.Queue()
        self.ready = threading.Event()
        self.pw = None
        self.context: Optional[BrowserContext] = None
        self.main_page: Optional[Page] = None
        self.draft_page: Optional[Page] = None
        self.thread = threading.Thread(target=self._run, daemon=True, name="pw-worker")
        self.thread.start()
        self.ready.wait(timeout=10)

    def _run(self):
        with sync_playwright() as p:
            self.pw = p
            self.ready.set()
            log("pw-worker: sync_playwright ready")
            while True:
                item = self.q.get()
                if item is None:
                    break
                fn, args, kwargs, fut = item
                try:
                    fut.set_result(fn(self, *args, **kwargs))
                except Exception as e:
                    fut.set_exception(e)

    def call(self, fn, *args, **kwargs):
        fut: Future = Future()
        self.q.put((fn, args, kwargs, fut))
        return fut.result()


WORKER = PWWorker()
_mongo = MongoClient(MONGO_URI)
_col   = _mongo[DB_NAME][COL_NAME]
mcp = FastMCP("owa")


# ── Helpers ────────────────────────────────────────────────────────────

def _doc_summary(doc: dict) -> dict:
    return {
        "message_id": doc.get("message_id"),
        "subject":    doc.get("subject"),
        "from":       doc.get("from"),
        "to":         doc.get("to", [])[:5],
        "date":       doc.get("date").isoformat() if doc.get("date") else None,
        "folder":     doc.get("folder"),
        "has_attachments": doc.get("has_attachments", False),
    }


def _wait_ready(page: Page):
    page.wait_for_load_state("domcontentloaded")
    page.wait_for_selector(SEARCH_READY, timeout=30_000)


# ── Worker functions (běží na pw threadu, dostávají worker jako 1. arg) ─

def _start(w: PWWorker) -> dict:
    if w.context is not None:
        return {"status": "already_running", "url": w.main_page.url if w.main_page else None}
    if not PROFILE_DIR.exists():
        return {"status": "error", "error": f"Profil nenalezen: {PROFILE_DIR}. Spusť outlook_login_v1.0.py."}
    w.context = w.pw.chromium.launch_persistent_context(
        user_data_dir=str(PROFILE_DIR),
        headless=False,
        no_viewport=True,
        accept_downloads=True,
        args=[
            "--disable-blink-features=AutomationControlled",
            "--start-maximized",
        ],
    )
    w.main_page = w.context.pages[0] if w.context.pages else w.context.new_page()
    w.main_page.goto(START_URL)
    _wait_ready(w.main_page)
    return {"status": "started", "url": w.main_page.url}


def _stop(w: PWWorker) -> dict:
    if w.context is None:
        return {"status": "not_running"}
    try:
        w.context.close()
    finally:
        w.context = None
        w.main_page = None
        w.draft_page = None
    return {"status": "stopped"}


def _status(w: PWWorker) -> dict:
    if w.context is None:
        return {"running": False}
    return {
        "running": True,
        "url": w.main_page.url if w.main_page else None,
        "tabs": len(w.context.pages),
        "draft_open": w.draft_page is not None and not w.draft_page.is_closed(),
    }


def _open_by_subject(w: PWWorker, subject: str) -> dict:
    if w.context is None:
        return {"status": "not_running"}
    page = w.main_page
    search = page.locator(SEARCH_READY).first
    search.click()
    search.fill("")
    search.type(subject, delay=20)
    page.keyboard.press("Enter")
    page.wait_for_timeout(2_000)
    msgs = page.locator('div[role="option"]')
    try:
        msgs.first.wait_for(state="visible", timeout=10_000)
    except Exception:
        return {"status": "no_results"}
    msgs.first.click()
    page.wait_for_timeout(800)
    return {"status": "opened", "count_visible": msgs.count()}


def _forward(w: PWWorker, body_prefix: str = "", subject_prefix: str = "") -> dict:
    if w.context is None:
        return {"status": "not_running"}
    page = w.main_page
    page.keyboard.press("Control+Shift+F")
    page.wait_for_timeout(1_500)

    body = page.locator(
        'div[aria-label*="Message body" i][contenteditable="true"], '
        'div[aria-label*="Tělo zprávy" i][contenteditable="true"]'
    ).first
    try:
        body.wait_for(state="visible", timeout=10_000)
    except Exception:
        return {"status": "forward_failed", "hint": "Body editor forwardu nenalezen."}

    w.draft_page = page  # inline composer ve stejném tabu

    if subject_prefix:
        subj = page.locator(
            'input[aria-label*="subject" i], input[aria-label*="předmět" i]'
        ).first
        try:
            subj.wait_for(state="visible", timeout=5_000)
            current = subj.input_value()
            subj.fill(f"{subject_prefix}{current}")
        except Exception:
            pass

    if body_prefix:
        body.click()
        page.keyboard.press("Control+Home")
        page.keyboard.type(body_prefix, delay=10)
        page.keyboard.press("Enter")

    return {"status": "forward_ready"}


def _write_at_top(w: PWWorker, text: str) -> dict:
    if w.draft_page is None or w.draft_page.is_closed():
        return {"status": "no_draft"}
    page = w.draft_page
    body = page.locator(
        'div[aria-label*="Message body" i][contenteditable="true"], '
        'div[aria-label*="Tělo zprávy" i][contenteditable="true"]'
    ).first
    body.click()
    page.keyboard.press("Control+Home")
    page.keyboard.type(text, delay=10)
    return {"status": "written", "chars": len(text)}


def _set_recipients(w: PWWorker, to: list[str], cc: Optional[list[str]] = None) -> dict:
    if w.draft_page is None or w.draft_page.is_closed():
        return {"status": "no_draft"}
    page = w.draft_page
    to_field = page.locator(
        'div[aria-label*="To" i][contenteditable="true"], '
        'div[aria-label*="Komu" i][contenteditable="true"]'
    ).first
    to_field.click()
    page.keyboard.type("; ".join(to) + ";", delay=15)
    page.wait_for_timeout(500)
    if cc:
        cc_field = page.locator(
            'div[aria-label*="Cc" i][contenteditable="true"], '
            'div[aria-label*="Kopie" i][contenteditable="true"]'
        ).first
        if cc_field.count():
            cc_field.click()
            page.keyboard.type("; ".join(cc) + ";", delay=15)
    return {"status": "filled", "to": to, "cc": cc or []}


def _close_pane(w: PWWorker) -> dict:
    if w.context is None:
        return {"status": "not_running"}
    w.main_page.keyboard.press("Escape")
    w.main_page.wait_for_timeout(300)
    return {"status": "closed"}


def _screenshot(w: PWWorker, path: str) -> dict:
    if w.context is None:
        return {"status": "not_running"}
    out = (BASE_DIR / path).resolve()
    w.main_page.screenshot(path=str(out), full_page=False)
    return {"status": "ok", "path": str(out)}


# ── MCP tooly (synchronní; dispatch na worker) ─────────────────────────

@mcp.tool()
def start_owa() -> dict:
    """Spustí Playwright s persistent profilem a otevře OWA. Okno zůstane otevřené."""
    return WORKER.call(_start)


@mcp.tool()
def stop_owa() -> dict:
    """Zavře Playwright context (a tím i okno OWA)."""
    return WORKER.call(_stop)


@mcp.tool()
def status() -> dict:
    """Vrátí stav session: běží/neběží, URL, počet tabů, draft otevřen?"""
    return WORKER.call(_status)


@mcp.tool()
def find_emails(
    query: Optional[str] = None,
    from_email: Optional[str] = None,
    folder: Optional[str] = None,
    since_iso: Optional[str] = None,
    limit: int = 10,
) -> list[dict]:
    """Hledá v MongoDB. `query` = substring v subjectu (case-insensitive).
    `since_iso` = ISO datum, vrátí jen emaily od něj. Seřazeno od nejnovějšího."""
    flt: dict = {}
    if query:
        flt["subject"] = {"$regex": query, "$options": "i"}
    if from_email:
        flt["from.email"] = {"$regex": from_email, "$options": "i"}
    if folder:
        flt["folder"] = folder
    if since_iso:
        try:
            dt = datetime.fromisoformat(since_iso.replace("Z", "+00:00"))
            if dt.tzinfo is None:
                dt = dt.replace(tzinfo=timezone.utc)
            flt["date"] = {"$gte": dt}
        except Exception:
            pass
    cur = _col.find(flt).sort("date", DESCENDING).limit(max(1, min(limit, 50)))
    return [_doc_summary(d) for d in cur]


@mcp.tool()
def find_last_email(from_email: Optional[str] = None, folder: Optional[str] = None) -> Optional[dict]:
    """Vrátí nejnovější email (volitelně filtr podle odesílatele / složky)."""
    flt: dict = {}
    if from_email:
        flt["from.email"] = {"$regex": from_email, "$options": "i"}
    if folder:
        flt["folder"] = folder
    docs = list(_col.find(flt).sort("date", DESCENDING).limit(1))
    return _doc_summary(docs[0]) if docs else None


@mcp.tool()
def open_email_by_subject(subject: str) -> dict:
    """Vyhledá v OWA podle subjectu a otevře první výsledek v reading pane."""
    return WORKER.call(_open_by_subject, subject)


@mcp.tool()
def forward_current(body_prefix: str = "", subject_prefix: str = "") -> dict:
    """Klikne Forward (Ctrl+Shift+F). Pokud je `body_prefix`, vepíše ho na začátek body.
    Pokud `subject_prefix`, předřadí ho do předmětu draftu."""
    return WORKER.call(_forward, body_prefix, subject_prefix)


@mcp.tool()
def write_at_top(text: str) -> dict:
    """Vepíše text na začátek body otevřeného draftu (před existující obsah / podpis)."""
    return WORKER.call(_write_at_top, text)


@mcp.tool()
def set_recipients(to: list[str], cc: Optional[list[str]] = None) -> dict:
    """Vyplní To / Cc v otevřeném draftu."""
    return WORKER.call(_set_recipients, to, cc)


@mcp.tool()
def close_reading_pane() -> dict:
    """Zavře otevřený email v reading pane (Escape). Forward draft tím nezavře."""
    return WORKER.call(_close_pane)


@mcp.tool()
def screenshot(path: str = "owa_screenshot.png") -> dict:
    """Uloží screenshot aktivního okna pro orientaci."""
    return WORKER.call(_screenshot, path)


if __name__ == "__main__":
    log("mcp_owa v1.1 starting (stdio)…")
    mcp.run()