"""CLI entrypoint for journal-bot."""
import argparse
import asyncio
from datetime import date
from pathlib import Path
import sys
from .config import Config
from .queue import Queue
from .state import State
from .vault_writer import VaultWriter
from .telegram_client import TelegramClient
from .transcribe import Transcriber
from .ingest import ingest_once
from .process import process_once
from .processor_lmstudio import LMStudioProcessor


def _load_prompt() -> str:
    here = Path(__file__).parent
    return (here / "prompts" / "journal_system.md").read_text(encoding="utf-8")


async def cmd_ingest(cfg: Config) -> int:
    tg = TelegramClient(
        token=cfg.telegram_token,
        allowed_user_id=cfg.allowed_user_id,
        download_dir=cfg.attachments_dir,
    )
    transcriber = Transcriber(model_name=cfg.whisper_model, device=cfg.whisper_device)
    queue = Queue(cfg.queue_dir)
    state = State(cfg.state_dir)
    try:
        n = await ingest_once(tg, transcriber, queue, state, attachments_dir=cfg.attachments_dir)
    finally:
        await tg.aclose()
    print(f"Ingested {n} items")
    return 0


def cmd_process(cfg: Config) -> int:
    processor = LMStudioProcessor(
        base_url=cfg.lmstudio_url,
        model=cfg.lmstudio_model,
        system_prompt=_load_prompt(),
    )
    queue = Queue(cfg.queue_dir)
    writer = VaultWriter(cfg.vault_path)
    n = process_once(processor, queue, writer, vault_path=cfg.vault_path, today=date.today())
    print(f"Processed {n} items")
    return 0


async def cmd_both(cfg: Config) -> int:
    rc = await cmd_ingest(cfg)
    if rc != 0:
        return rc
    return cmd_process(cfg)


def cmd_write(cfg: Config, target_path: str, entry_file: Path) -> int:
    """Helper used by the Claude Code skill to write a single entry."""
    writer = VaultWriter(cfg.vault_path)
    body = entry_file.read_text(encoding="utf-8")
    writer.append(target_path, body)
    print(f"Wrote to {target_path}")
    return 0


def main() -> int:
    parser = argparse.ArgumentParser(prog="journal_bot")
    sub = parser.add_subparsers(dest="cmd", required=True)
    sub.add_parser("ingest")
    sub.add_parser("process")
    sub.add_parser("both")
    w = sub.add_parser("write")
    w.add_argument("--target-path", required=True)
    w.add_argument("--entry-file", required=True, type=Path)
    args = parser.parse_args()

    cfg = Config()

    if args.cmd == "ingest":
        return asyncio.run(cmd_ingest(cfg))
    if args.cmd == "process":
        return cmd_process(cfg)
    if args.cmd == "both":
        return asyncio.run(cmd_both(cfg))
    if args.cmd == "write":
        return cmd_write(cfg, args.target_path, args.entry_file)
    return 1


if __name__ == "__main__":
    sys.exit(main())