# uv 설치 (Astral, 2024년~ 표준)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

# 확인
uv --version

# Python 3.12 설치
uv python install 3.12

# 또는 시스템 Python (Ubuntu 24.04 기본)
sudo apt install -y python3 python3-pip python3-venv
python3 --version  # 3.12.x

# 작업 디렉토리
mkdir ~/tsv-tg-bot
cd ~/tsv-tg-bot

# 가상환경 (uv)
uv venv
source .venv/bin/activate

# 패키지 설치
uv pip install python-telegram-bot anthropic python-dotenv

# 또는 requirements.txt 방식
cat > requirements.txt << 'EOF'
python-telegram-bot==21.6
anthropic==0.40.0
python-dotenv==1.0.1
EOF
uv pip install -r requirements.txt

~/tsv-tg-bot/
├── .env
├── .gitignore
├── requirements.txt
├── src/
│   ├── bot.py
│   ├── claude.py
│   ├── logger.py
│   └── messages.py
└── logs/

# .env
cat > .env << 'EOF'
TELEGRAM_TOKEN=your_telegram_bot_token_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
ANTHROPIC_MODEL=claude-sonnet-4-6
LOG_DIR=./logs
EOF

# .gitignore
cat > .gitignore << 'EOF'
.venv/
__pycache__/
*.pyc
.env
logs/
*.log
.DS_Store
EOF

chmod 600 .env

# src/messages.py
"""
⚖️ Position C — 시리즈 메타 원칙 일관
"""

POSITION_C_FOOTER = """
━━━━━━━━━━━━━━━━━━━━━━━━━━━
이 봇은 분석 콘텐츠 보조 도구이며,
법률·의료·금융 등 전문 조언을 제공하지 않습니다.
중요한 결정은 전문가와 상의하시기 바랍니다.
━━━━━━━━━━━━━━━━━━━━━━━━━━━
""".strip()

SYSTEM_PROMPT = """
당신은 TSV 운영자의 보조 도구입니다.

[원칙]
- 사실 단일 출처 (확실하지 않은 사실 추측 X)
- 베팅·픽 추천 표현 X
- 법률·의료·금융 단정 표현 X
- 사용자 질문에 정확하고 간결하게 답변

[톤]
- 한국어 기본
- 전문적이고 친근함

[제약]
- 답변 길이 1500자 이내 (Telegram 4096자 한도 안전)
- 코드 블록 사용 권장
""".strip()

ERROR_MESSAGES = {
    "rate_limit": "⏰ 잠시 후 다시 시도해주세요. (rate limit)",
    "api_error": "⚠️ 일시적 오류가 발생했습니다.",
    "too_long": "📝 질문이 너무 깁니다. 1000자 이내로 줄여주세요.",
    "no_question": "질문을 입력해주세요. 예: /ask 안녕",
}

# src/claude.py
import os
from anthropic import Anthropic, APIStatusError, APITimeoutError, APIConnectionError

from messages import SYSTEM_PROMPT

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
MODEL = os.environ.get("ANTHROPIC_MODEL", "claude-sonnet-4-6")


class TooLongError(Exception):
    pass


class RateLimitError(Exception):
    pass


class ApiError(Exception):
    pass


async def ask_claude(question: str) -> str:
    if len(question) > 1000:
        raise TooLongError()

    try:
        response = client.messages.create(
            model=MODEL,
            max_tokens=1500,
            system=SYSTEM_PROMPT,
            messages=[{"role": "user", "content": question}],
        )

        # text 블록만 추출
        for block in response.content:
            if block.type == "text":
                return block.text

        return "⚠️ 답변을 생성할 수 없습니다."

    except APIStatusError as e:
        if e.status_code == 429:
            raise RateLimitError() from e
        if e.status_code >= 500:
            raise ApiError() from e
        raise
    except (APITimeoutError, APIConnectionError) as e:
        raise ApiError() from e

# src/logger.py
import json
import os
from datetime import datetime
from pathlib import Path
from typing import TypedDict, Literal

LOG_DIR = Path(os.environ.get("LOG_DIR", "./logs"))
LOG_DIR.mkdir(parents=True, exist_ok=True)


class LogEntry(TypedDict):
    timestamp: str
    user_id: int
    chat_id: int
    question: str
    response_length: int
    duration_ms: int
    status: Literal["success", "rate_limit", "too_long", "api_error"]


def log_trace(entry: LogEntry) -> None:
    date = datetime.now().strftime("%Y-%m-%d")
    filepath = LOG_DIR / f"{date}.jsonl"
    with filepath.open("a", encoding="utf-8") as f:
        f.write(json.dumps(entry, ensure_ascii=False) + "\n")


def log_error(error: Exception, context: dict) -> None:
    date = datetime.now().strftime("%Y-%m-%d")
    filepath = LOG_DIR / f"{date}-errors.jsonl"
    entry = {
        "timestamp": datetime.now().isoformat(),
        "error": str(error),
        "error_type": type(error).__name__,
        "context": context,
    }
    with filepath.open("a", encoding="utf-8") as f:
        f.write(json.dumps(entry, ensure_ascii=False) + "\n")

# src/bot.py
import os
import time
import logging
import sys
from pathlib import Path
from datetime import datetime

# 부모 디렉토리 path 추가
sys.path.insert(0, str(Path(__file__).parent))

from dotenv import load_dotenv
from telegram import Update
from telegram.ext import (
    Application,
    CommandHandler,
    ContextTypes,
)

from claude import ask_claude, TooLongError, RateLimitError, ApiError
from logger import log_trace, log_error
from messages import POSITION_C_FOOTER, ERROR_MESSAGES

load_dotenv()

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO,
)
logger = logging.getLogger(__name__)


async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Welcome 메시지"""
    user = update.effective_user
    await update.message.reply_text(
        f"안녕하세요, {user.first_name}님!\n"
        f"질문을 하시려면 /ask 명령을 사용하세요.\n"
        f"예: /ask 안녕"
    )


async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """도움말"""
    await update.message.reply_text(
        "[명령어]\n"
        "/ask <질문> - Claude에게 질문\n"
        "/help - 도움말\n"
        "/start - 환영 메시지"
    )


async def ask_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """/ask 명령 처리"""
    question = " ".join(context.args).strip()

    if not question:
        await update.message.reply_text(ERROR_MESSAGES["no_question"])
        return

    msg = update.message
    chat_id = msg.chat_id
    user_id = msg.from_user.id

    # 타이핑 표시
    await context.bot.send_chat_action(chat_id=chat_id, action="typing")

    start = time.time()
    status = "success"
    response = ""

    try:
        response = await ask_claude(question)

        # Telegram 4096자 한도
        if len(response) > 3900:
            response = response[:3900] + "...\n(답변 잘림)"

        # ⚖️ Position C 본문 추가
        full_response = f"{response}\n\n{POSITION_C_FOOTER}"

        await msg.reply_text(full_response)

    except TooLongError:
        status = "too_long"
        await msg.reply_text(ERROR_MESSAGES["too_long"])
    except RateLimitError:
        status = "rate_limit"
        await msg.reply_text(ERROR_MESSAGES["rate_limit"])
    except ApiError as e:
        status = "api_error"
        await msg.reply_text(ERROR_MESSAGES["api_error"])
        log_error(e, {"user_id": user_id, "question": question})
    except Exception as e:
        status = "api_error"
        await msg.reply_text(ERROR_MESSAGES["api_error"])
        log_error(e, {"user_id": user_id, "question": question})

    # ★ LogOnTable 로깅
    log_trace({
        "timestamp": datetime.now().isoformat(),
        "user_id": user_id,
        "chat_id": chat_id,
        "question": question,
        "response_length": len(response),
        "duration_ms": int((time.time() - start) * 1000),
        "status": status,
    })


def main():
    token = os.environ["TELEGRAM_TOKEN"]

    app = Application.builder().token(token).build()

    app.add_handler(CommandHandler("start", start_command))
    app.add_handler(CommandHandler("help", help_command))
    app.add_handler(CommandHandler("ask", ask_command))

    logger.info("✅ Telegram bot starting...")
    app.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == "__main__":
    main()

# 가상환경 활성화
cd ~/tsv-tg-bot
source .venv/bin/activate

# 실행
python src/bot.py
# INFO - ✅ Telegram bot starting...

# Telegram 에서 본인 봇 검색 + /start
# /ask 안녕

# 응답:
# 안녕하세요! 무엇을 도와드릴까요?
#
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━
# 이 봇은 분석 콘텐츠 보조 도구이며,
# ...
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━

# 로그 확인
ls logs/
cat logs/$(date +%Y-%m-%d).jsonl | head