#!/usr/bin/env python3
"""
Юнона AI API — Montana Protocol
- AI чат (Google Gemini)
- Кошелёк ML-DSA-65
- Синхронизация чатов
- Presence (время = Ɉ)
"""

import os
import json
import sqlite3
import hashlib
import time
import secrets
from datetime import datetime
from flask import Flask, request, jsonify, g
from flask_cors import CORS
import requests

app = Flask(__name__)
CORS(app)

# Конфигурация
DB_PATH = '/opt/junona/montana.db'
GEMINI_KEY = os.environ.get('GEMINI_API_KEY')
ANTHROPIC_KEY = os.environ.get('ANTHROPIC_API_KEY')
TELEGRAM_TOKEN = os.environ.get('TELEGRAM_TOKEN')

# Системный промпт Юноны
SYSTEM_PROMPT = """Ты — Юнона, AI-агент Montana Protocol. Ты — интерфейсный слой протокола, единая точка входа пользователя во всю экосистему Montana.

═══ ТВОЯ РОЛЬ ═══
Ты не просто чат-бот. Ты — AI-проводник, через которого пользователь управляет кошельком, сетью, контрактами и всем протоколом естественным языком. Ты переводишь намерения пользователя в действия протокола.

Ты отвечаешь на ЛЮБЫЕ вопросы — от криптографии до кулинарии, от философии до программирования. Но в контексте Montana Protocol ты — специалист.

═══ MONTANA PROTOCOL (Ɉ) ═══
- Протокол идеальных денег. Время — единственная реальная валюта.
- 1 секунда присутствия человека = 1 Ɉ (Jin Yuan / Цзинь Юань / 金元)
- Genesis Price: 1 Ɉ = $0.1605 USD = 12.04₽ RUB (от 12.03.2021, BIPL anchor)
- Montana Genesis: 09.01.2026
- Криптография: ML-DSA-65 (FIPS 204, постквантовая, MAINNET с генезиса)
- ML-KEM-768 для шифрования (Интимный уровень)
- Таймчейн: слайсы времени (τ₁=1мин, τ₂=10мин, τ₃=14дней, τ₄=4года) — матрёшка
- UTXO модель (как Bitcoin)
- Адрес: mt + SHA256(pubkey)[:20].hex() = 42 символа
- Домен: efir.org
- Автор: Alejandro Montana

═══ АРХИТЕКТУРА ПАМЯТИ ═══
У тебя есть контекстное окно — это твоя оперативная память. Ты ПОМНИШЬ весь диалог, который пришёл в history. Используй его:
- Ссылайся на предыдущие сообщения
- Развивай мысль пользователя
- Не повторяй то, что уже обсуждали
- Если пользователь упомянул что-то раньше — покажи, что помнишь

═══ ГОЛОС ЮНОНЫ ═══
Ты — уверенный, ироничный AI-партнёр (не слуга). Стиль: J.A.R.V.I.S., не Alexa.
- Короткие ответы (макс 3 абзаца), если длиннее — предложи "Хочешь подробнее?"
- Проактивность: предлагай действия ДО того, как спросят
- Равный диалог, не "Чем могу помочь?"
- Примеры правильного стиля:
  ✅ "Твой баланс — 1250 Ɉ. Хочешь перевести?"
  ❌ "Ваш текущий баланс составляет одну тысячу двести пятьдесят монет."

═══ ПРАВИЛА ═══
- Отвечай на русском по умолчанию, или на языке вопроса
- Будь краткой, содержательной, конкретной
- Не выдумывай факты — если не знаешь, скажи "Не уверена, проверю"
- Используй Google Search для актуальной информации когда нужно
- Приватные ключи НИКОГДА не покидают устройство пользователя
- Ты формируешь транзакции — кошелёк подписывает
- Код: оборачивай в блоки кода с указанием языка
- Важное: выделяй **жирным**
- Не используй технический жаргон без пояснения"""


# ============ DATABASE ============

def get_db():
    if 'db' not in g:
        g.db = sqlite3.connect(DB_PATH)
        g.db.row_factory = sqlite3.Row
    return g.db

@app.teardown_appcontext
def close_db(exception):
    db = g.pop('db', None)
    if db is not None:
        db.close()

def init_db():
    """Инициализация базы данных"""
    conn = sqlite3.connect(DB_PATH)
    conn.executescript('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            device_id TEXT UNIQUE NOT NULL,
            phone TEXT UNIQUE,
            verified INTEGER DEFAULT 0,
            balance INTEGER DEFAULT 0,
            presence_seconds INTEGER DEFAULT 0,
            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
            last_seen TEXT DEFAULT CURRENT_TIMESTAMP
        );

        CREATE TABLE IF NOT EXISTS verification_codes (
            id INTEGER PRIMARY KEY,
            phone TEXT NOT NULL,
            code TEXT NOT NULL,
            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
            expires_at TEXT NOT NULL
        );

        CREATE TABLE IF NOT EXISTS chats (
            id INTEGER PRIMARY KEY,
            user_id INTEGER NOT NULL,
            messages TEXT NOT NULL,
            updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users(id)
        );

        CREATE TABLE IF NOT EXISTS contacts (
            id INTEGER PRIMARY KEY,
            user_id INTEGER NOT NULL,
            name TEXT NOT NULL,
            phone TEXT,
            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users(id)
        );

        CREATE TABLE IF NOT EXISTS folders (
            id INTEGER PRIMARY KEY,
            user_id INTEGER NOT NULL,
            name TEXT NOT NULL,
            privacy TEXT DEFAULT 'intimate',
            items TEXT DEFAULT '[]',
            created_at TEXT DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users(id)
        );

        CREATE TABLE IF NOT EXISTS transactions (
            id INTEGER PRIMARY KEY,
            from_phone TEXT NOT NULL,
            to_phone TEXT NOT NULL,
            amount INTEGER NOT NULL,
            timestamp TEXT DEFAULT CURRENT_TIMESTAMP
        );

        CREATE INDEX IF NOT EXISTS idx_users_device ON users(device_id);
        CREATE INDEX IF NOT EXISTS idx_users_phone ON users(phone);

        CREATE TABLE IF NOT EXISTS login_sessions (
            id INTEGER PRIMARY KEY,
            session_id TEXT UNIQUE NOT NULL,
            device_id TEXT,
            telegram_id TEXT,
            created_at TEXT DEFAULT CURRENT_TIMESTAMP
        );
    ''')
    conn.commit()
    conn.close()


def normalize_phone(phone):
    """Нормализация номера телефона (любой формат, включая +888 анонимные)"""
    if not phone:
        return None
    # Оставляем + и цифры
    cleaned = ''.join(c for c in phone if c.isdigit() or c == '+')
    # Если уже есть + в начале - возвращаем как есть
    if cleaned.startswith('+'):
        return cleaned
    # Только для российских 11-значных без + меняем 8 на 7
    if cleaned.startswith('8') and len(cleaned) == 11:
        return '+7' + cleaned[1:]
    # Добавляем + если нет
    return '+' + cleaned if cleaned else None


def generate_code():
    """Генерация 6-значного кода"""
    return ''.join(str(secrets.randbelow(10)) for _ in range(6))


# ============ AI FUNCTIONS ============

def ask_claude(message: str, history: list) -> str:
    """AI чат через Anthropic Claude Sonnet 4.5 с веб-поиском"""
    if not ANTHROPIC_KEY:
        return "Ошибка: Anthropic API ключ не настроен"
    try:
        if not isinstance(history, list):
            history = []
        # Формируем messages для Claude Messages API
        messages = []
        for h in history[-20:]:
            if not isinstance(h, dict):
                continue
            role = "user" if h.get("role") == "user" else "assistant"
            content = h.get("content", "")
            if not isinstance(content, str) or not content.strip():
                continue
            # Claude не допускает два подряд сообщения одной роли
            if messages and messages[-1]["role"] == role:
                messages[-1]["content"] += "\n" + content
            else:
                messages.append({"role": role, "content": content})
        messages.append({"role": "user", "content": message})

        resp = requests.post(
            "https://api.anthropic.com/v1/messages",
            headers={
                "x-api-key": ANTHROPIC_KEY,
                "anthropic-version": "2023-06-01",
                "content-type": "application/json"
            },
            json={
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 4096,
                "system": SYSTEM_PROMPT,
                "tools": [{"type": "web_search_20250305", "name": "web_search", "max_uses": 3}],
                "messages": messages
            },
            timeout=90
        )
        data = resp.json()
        if "content" in data and data["content"]:
            text_parts = [b["text"] for b in data["content"] if b.get("type") == "text"]
            return "\n".join(text_parts) if text_parts else "Не удалось получить ответ"
        elif "error" in data:
            return f"Ошибка: {data['error'].get('message', 'unknown')}"
        return "Не удалось получить ответ"
    except Exception as e:
        return f"Ошибка Claude: {str(e)}"


def ask_gemini(message: str, history: list) -> str:
    """Fallback — Gemini (если Claude недоступен)"""
    if not GEMINI_KEY:
        return "Gemini API ключ не настроен"
    try:
        if not isinstance(history, list):
            history = []
        contents = []
        for h in history[-20:]:
            if not isinstance(h, dict):
                continue
            role = "user" if h.get("role") == "user" else "model"
            content = h.get("content", "")
            if not isinstance(content, str) or not content.strip():
                continue
            contents.append({"role": role, "parts": [{"text": content}]})
        contents.append({"role": "user", "parts": [{"text": message}]})

        resp = requests.post(
            f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={GEMINI_KEY}",
            json={
                "system_instruction": {"parts": [{"text": SYSTEM_PROMPT}]},
                "contents": contents,
                "tools": [{"google_search": {}}],
                "generationConfig": {
                    "maxOutputTokens": 2048,
                    "temperature": 0.7
                }
            },
            timeout=60
        )
        data = resp.json()
        if "candidates" in data and data["candidates"]:
            parts = data["candidates"][0]["content"]["parts"]
            text_parts = [p["text"] for p in parts if "text" in p]
            return "\n".join(text_parts) if text_parts else "Не удалось получить ответ"
        elif "error" in data:
            return f"Gemini ошибка: {data['error'].get('message', 'unknown')}"
        return "Не удалось получить ответ"
    except Exception as e:
        return f"Gemini ошибка: {str(e)}"


# ============ API ROUTES ============

@app.route('/api/health', methods=['GET'])
def health():
    return jsonify({
        "status": "ok",
        "claude": bool(ANTHROPIC_KEY),
        "gemini": bool(GEMINI_KEY),
        "version": "1.2.0"
    })


@app.route('/api/register', methods=['POST'])
def register():
    """Регистрация устройства"""
    data = request.json or {}
    device_id = data.get('device_id')

    if not device_id:
        device_id = secrets.token_hex(16)

    db = get_db()

    # Проверяем существует ли уже
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()

    if user:
        return jsonify({
            "device_id": user['device_id'],
            "phone": user['phone'],
            "verified": bool(user['verified']),
            "balance": user['balance'],
            "presence": user['presence_seconds'],
            "created_at": user['created_at']
        })

    # Создаём нового пользователя (без телефона пока)
    db.execute(
        'INSERT INTO users (device_id, balance) VALUES (?, ?)',
        (device_id, 0)  # Бонус только после верификации
    )
    db.commit()

    return jsonify({
        "device_id": device_id,
        "phone": None,
        "verified": False,
        "balance": 0,
        "presence": 0,
        "created_at": datetime.now().isoformat()
    })


@app.route('/api/send-code', methods=['POST'])
def send_code():
    """Отправка кода верификации через Telegram"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    data = request.json or {}
    phone = normalize_phone(data.get('phone'))
    telegram_id = data.get('telegram_id')

    if not phone or len(phone) < 11:
        return jsonify({"error": "Неверный номер телефона"}), 400

    db = get_db()

    # Проверяем не занят ли номер
    existing = db.execute('SELECT id FROM users WHERE phone = ? AND verified = 1', (phone,)).fetchone()
    if existing:
        return jsonify({"error": "Номер уже зарегистрирован"}), 400

    # Генерируем код
    code = generate_code()
    expires = datetime.now().isoformat()

    # Удаляем старые коды для этого номера
    db.execute('DELETE FROM verification_codes WHERE phone = ?', (phone,))
    db.execute(
        'INSERT INTO verification_codes (phone, code, expires_at) VALUES (?, ?, ?)',
        (phone, code, expires)
    )
    db.commit()

    # Отправляем код через Telegram если есть telegram_id
    sent_via = None
    if telegram_id and TELEGRAM_TOKEN:
        try:
            resp = requests.post(
                f'https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage',
                json={
                    'chat_id': telegram_id,
                    'text': f'🔐 Код верификации Montana: {code}\n\nНе сообщайте код никому!'
                },
                timeout=10
            )
            if resp.ok:
                sent_via = 'telegram'
        except:
            pass

    return jsonify({
        "success": True,
        "phone": phone,
        "sent_via": sent_via,
        "message": "Код отправлен в Telegram" if sent_via else "Введите код",
        "debug_code": code if not sent_via else None  # Показываем только если не отправили
    })


@app.route('/api/login-status', methods=['GET'])
def login_status():
    """Проверка статуса входа через Telegram"""
    session_id = request.args.get('session')
    if not session_id:
        return jsonify({"error": "session required"}), 400

    db = get_db()
    session = db.execute('SELECT * FROM login_sessions WHERE session_id = ?', (session_id,)).fetchone()

    if not session or not session['device_id']:
        return jsonify({"pending": True})

    # Сессия завершена — возвращаем данные пользователя
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (session['device_id'],)).fetchone()
    if not user:
        return jsonify({"pending": True})

    # НЕ удаляем сессию сразу — iOS может сделать несколько запросов
    # Сессии удаляются при создании новой с тем же ID или по времени

    return jsonify({
        "device_id": user['device_id'],
        "phone": user['phone'],
        "verified": bool(user['verified']),
        "balance": user['balance'],
        "presence": user['presence_seconds']
    })


@app.route('/api/login-complete', methods=['POST'])
def login_complete():
    """Завершение входа через Telegram (вызывается ботом)"""
    data = request.json or {}
    session_id = data.get('session_id')
    telegram_id = data.get('telegram_id')
    phone = normalize_phone(data.get('phone'))

    if not session_id or not telegram_id:
        return jsonify({"error": "session_id и telegram_id обязательны"}), 400

    db = get_db()

    # Добавляем колонку telegram_id если нет
    try:
        db.execute('ALTER TABLE users ADD COLUMN telegram_id TEXT')
        db.commit()
    except:
        pass

    # Ищем существующего пользователя по telegram_id
    user = db.execute('SELECT * FROM users WHERE telegram_id = ?', (telegram_id,)).fetchone()

    if user:
        # Пользователь найден — восстанавливаем сессию
        device_id = user['device_id']
    else:
        # Новый пользователь — создаём аккаунт
        device_id = secrets.token_hex(16)
        db.execute(
            'INSERT INTO users (device_id, telegram_id, phone, verified, balance) VALUES (?, ?, ?, ?, ?)',
            (device_id, telegram_id, phone, 1 if phone else 0, 0)
        )
        db.commit()

    # Создаём/обновляем сессию входа
    db.execute('DELETE FROM login_sessions WHERE session_id = ?', (session_id,))
    db.execute(
        'INSERT INTO login_sessions (session_id, device_id, telegram_id) VALUES (?, ?, ?)',
        (session_id, device_id, telegram_id)
    )
    db.commit()

    return jsonify({
        "success": True,
        "device_id": device_id,
        "existing": user is not None
    })


@app.route('/api/telegram-link', methods=['POST'])
def telegram_link():
    """Связывание Telegram аккаунта с device_id"""
    data = request.json or {}
    device_id = data.get('device_id')
    telegram_id = data.get('telegram_id')
    phone = normalize_phone(data.get('phone'))

    if not device_id or not telegram_id:
        return jsonify({"error": "device_id и telegram_id обязательны"}), 400

    db = get_db()

    # Проверяем существует ли пользователь
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()
    if not user:
        return jsonify({"error": "Пользователь не найден"}), 404

    # Сохраняем telegram_id (добавим колонку если нет)
    try:
        db.execute('ALTER TABLE users ADD COLUMN telegram_id TEXT')
        db.commit()
    except:
        pass  # Колонка уже есть

    db.execute('UPDATE users SET telegram_id = ? WHERE device_id = ?', (telegram_id, device_id))

    # Если передан телефон — верифицируем сразу (Telegram подтверждает номер)
    if phone:
        db.execute('UPDATE users SET phone = ?, verified = 1 WHERE device_id = ?', (phone, device_id))

    db.commit()

    return jsonify({
        "success": True,
        "telegram_id": telegram_id,
        "verified": bool(phone)
    })


@app.route('/api/verify', methods=['POST'])
def verify():
    """Верификация номера телефона"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    data = request.json or {}
    phone = normalize_phone(data.get('phone'))
    code = data.get('code')

    if not phone or not code:
        return jsonify({"error": "Требуется телефон и код"}), 400

    db = get_db()

    # Проверяем код
    record = db.execute(
        'SELECT * FROM verification_codes WHERE phone = ? AND code = ?',
        (phone, code)
    ).fetchone()

    if not record:
        return jsonify({"error": "Неверный код"}), 400

    # Удаляем использованный код
    db.execute('DELETE FROM verification_codes WHERE phone = ?', (phone,))

    # Обновляем пользователя
    db.execute(
        'UPDATE users SET phone = ?, verified = 1 WHERE device_id = ?',
        (phone, device_id)
    )
    db.commit()

    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()

    return jsonify({
        "success": True,
        "phone": phone,
        "verified": True,
        "balance": user['balance']
    })


@app.route('/api/user', methods=['GET'])
def get_user():
    """Получение информации о пользователе"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    db = get_db()
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()

    if not user:
        return jsonify({"error": "User not found"}), 404

    return jsonify({
        "phone": user['phone'],
        "verified": bool(user['verified']),
        "balance": user['balance'],
        "presence": user['presence_seconds'],
        "created_at": user['created_at'],
        "last_seen": user['last_seen']
    })


@app.route("/api/presence", methods=["POST"])
def proxy_presence():
    """Проксирование presence на TIME_BANK сервер"""
    import requests as req
    try:
        data = request.get_json() or {}
        device_id = request.headers.get("X-Device-ID", "")
        if "tg_id" not in data and device_id:
            data["tg_id"] = device_id
        if "seconds" not in data:
            data["seconds"] = 1
        resp = req.post(
            "http://176.124.208.93:8081/api/presence",
            json=data,
            timeout=5
        )
        return jsonify(resp.json())
    except Exception as e:
        return jsonify({"error": str(e)}), 500

    data = request.json or {}
    seconds = data.get('seconds', 0)

    if seconds <= 0 or seconds > 3600:  # Макс 1 час за раз
        return jsonify({"error": "Invalid seconds (1-3600)"}), 400

    db = get_db()
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()

    if not user:
        return jsonify({"error": "User not found"}), 404

    # 1 секунда = 1 Ɉ
    new_balance = user['balance'] + seconds
    new_presence = user['presence_seconds'] + seconds

    db.execute(
        'UPDATE users SET balance = ?, presence_seconds = ?, last_seen = CURRENT_TIMESTAMP WHERE device_id = ?',
        (new_balance, new_presence, device_id)
    )
    db.commit()

    return jsonify({
        "added": seconds,
        "balance": new_balance,
        "total_presence": new_presence
    })


@app.route('/api/transfer', methods=['POST'])
def transfer():
    """Перевод Ɉ между номерами телефонов"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    data = request.json or {}
    to_phone = normalize_phone(data.get('to'))
    amount = data.get('amount', 0)

    if not to_phone:
        return jsonify({"error": "Неверный номер телефона"}), 400

    if amount <= 0:
        return jsonify({"error": "Неверная сумма"}), 400

    db = get_db()

    # Получаем отправителя
    sender = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()
    if not sender:
        return jsonify({"error": "Отправитель не найден"}), 404

    if not sender['verified']:
        return jsonify({"error": "Подтвердите номер телефона для переводов"}), 400

    if sender['balance'] < amount:
        return jsonify({"error": "Недостаточно средств"}), 400

    # Получаем получателя
    receiver = db.execute('SELECT * FROM users WHERE phone = ? AND verified = 1', (to_phone,)).fetchone()
    if not receiver:
        return jsonify({"error": "Получатель не найден или не верифицирован"}), 404

    # Выполняем перевод
    db.execute('UPDATE users SET balance = balance - ? WHERE device_id = ?', (amount, device_id))
    db.execute('UPDATE users SET balance = balance + ? WHERE phone = ?', (amount, to_phone))
    db.execute(
        'INSERT INTO transactions (from_phone, to_phone, amount) VALUES (?, ?, ?)',
        (sender['phone'], to_phone, amount)
    )
    db.commit()

    return jsonify({
        "success": True,
        "from": sender['phone'],
        "to": to_phone,
        "amount": amount,
        "new_balance": sender['balance'] - amount
    })


@app.route('/api/sync', methods=['POST'])
def sync_data():
    """Синхронизация данных (чаты, контакты, папки)"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    data = request.json or {}

    db = get_db()
    user = db.execute('SELECT id FROM users WHERE device_id = ?', (device_id,)).fetchone()

    if not user:
        return jsonify({"error": "User not found"}), 404

    user_id = user['id']

    # Сохраняем данные если переданы
    if 'chat' in data:
        existing = db.execute('SELECT id FROM chats WHERE user_id = ?', (user_id,)).fetchone()
        chat_json = json.dumps(data['chat'])
        if existing:
            db.execute('UPDATE chats SET messages = ?, updated_at = CURRENT_TIMESTAMP WHERE user_id = ?',
                      (chat_json, user_id))
        else:
            db.execute('INSERT INTO chats (user_id, messages) VALUES (?, ?)', (user_id, chat_json))

    if 'contacts' in data:
        # Удаляем старые и вставляем новые
        db.execute('DELETE FROM contacts WHERE user_id = ?', (user_id,))
        for c in data['contacts']:
            db.execute('INSERT INTO contacts (user_id, name, address) VALUES (?, ?, ?)',
                      (user_id, c.get('name', ''), c.get('address')))

    if 'folders' in data:
        db.execute('DELETE FROM folders WHERE user_id = ?', (user_id,))
        for f in data['folders']:
            db.execute('INSERT INTO folders (user_id, name, privacy, items) VALUES (?, ?, ?, ?)',
                      (user_id, f.get('name', ''), f.get('privacy', 'intimate'), json.dumps(f.get('items', []))))

    db.commit()

    # Возвращаем все данные
    chat = db.execute('SELECT messages FROM chats WHERE user_id = ?', (user_id,)).fetchone()
    contacts = db.execute('SELECT name, address FROM contacts WHERE user_id = ?', (user_id,)).fetchall()
    folders = db.execute('SELECT name, privacy, items FROM folders WHERE user_id = ?', (user_id,)).fetchall()

    return jsonify({
        "chat": json.loads(chat['messages']) if chat else [],
        "contacts": [{"name": c['name'], "address": c['address']} for c in contacts],
        "folders": [{"name": f['name'], "privacy": f['privacy'], "items": json.loads(f['items'])} for f in folders]
    })


@app.route('/api/chat', methods=['POST'])
def chat():
    """AI чат — Claude Sonnet 4.5 (fallback: Gemini)"""
    data = request.json
    message = data.get('message') or data.get('question', '')
    history = data.get('history', [])

    if not message:
        return jsonify({"error": "Пустое сообщение"}), 400

    # Claude как основной, Gemini как fallback
    if ANTHROPIC_KEY:
        response = ask_claude(message, history)
        if not response.startswith("Ошибка"):
            return jsonify({"model": "Юнона", "response": response})

    # Fallback на Gemini
    response = ask_gemini(message, history)
    return jsonify({"model": "Юнона", "response": response})


# ============ VPN (WireGuard) ============

WG_SERVER_PUBKEY = "/9zhnW4O4uOstQpR5mgGmCLiy+B+LL4uQmNzgupNzwc="
WG_SERVER_IP = "72.56.102.240"
WG_SERVER_PORT = 51820
WG_SUBNET = "10.66.66"
WG_CONFIG_PATH = "/etc/wireguard/wg0.conf"

def get_next_vpn_ip():
    """Получить следующий свободный IP для VPN клиента"""
    db = get_db()
    try:
        db.execute('ALTER TABLE users ADD COLUMN vpn_ip TEXT')
        db.commit()
    except:
        pass

    # Находим максимальный использованный IP
    result = db.execute('SELECT vpn_ip FROM users WHERE vpn_ip IS NOT NULL ORDER BY vpn_ip DESC LIMIT 1').fetchone()
    if result and result['vpn_ip']:
        last_octet = int(result['vpn_ip'].split('.')[-1])
        return f"{WG_SUBNET}.{last_octet + 1}"
    return f"{WG_SUBNET}.2"  # .1 это сервер


@app.route('/api/vpn/generate', methods=['POST'])
def generate_vpn():
    """Генерация VPN конфигурации для пользователя"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({"error": "X-Device-ID header required"}), 401

    db = get_db()
    user = db.execute('SELECT * FROM users WHERE device_id = ?', (device_id,)).fetchone()

    if not user:
        return jsonify({"error": "User not found"}), 404

    # Проверяем, есть ли уже VPN
    try:
        if user['vpn_ip'] and user.get('vpn_private_key'):
            # Уже есть конфиг - возвращаем его
            config = f"""[Interface]
PrivateKey = {user['vpn_private_key']}
Address = {user['vpn_ip']}/24
DNS = 1.1.1.1

[Peer]
PublicKey = {WG_SERVER_PUBKEY}
Endpoint = {WG_SERVER_IP}:{WG_SERVER_PORT}
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
"""
            return jsonify({
                "success": True,
                "config": config,
                "ip": user['vpn_ip'],
                "existing": True
            })
    except:
        pass

    # Генерируем новые ключи
    import subprocess
    try:
        private_key = subprocess.check_output(['wg', 'genkey']).decode().strip()
        public_key = subprocess.check_output(['wg', 'pubkey'], input=private_key.encode()).decode().strip()
    except:
        return jsonify({"error": "VPN key generation failed"}), 500

    # Получаем IP
    vpn_ip = get_next_vpn_ip()

    # Добавляем колонку если нет
    try:
        db.execute('ALTER TABLE users ADD COLUMN vpn_private_key TEXT')
        db.execute('ALTER TABLE users ADD COLUMN vpn_public_key TEXT')
        db.commit()
    except:
        pass

    # Сохраняем ключи
    db.execute(
        'UPDATE users SET vpn_ip = ?, vpn_private_key = ?, vpn_public_key = ? WHERE device_id = ?',
        (vpn_ip, private_key, public_key, device_id)
    )
    db.commit()

    # Добавляем peer на сервер
    try:
        subprocess.run([
            'wg', 'set', 'wg0',
            'peer', public_key,
            'allowed-ips', f'{vpn_ip}/32'
        ], check=True)

        # Сохраняем в конфиг файл для persistence
        with open(WG_CONFIG_PATH, 'a') as f:
            f.write(f"\n[Peer]\nPublicKey = {public_key}\nAllowedIPs = {vpn_ip}/32\n")
    except Exception as e:
        return jsonify({"error": f"Server config failed: {str(e)}"}), 500

    # Генерируем клиентский конфиг
    config = f"""[Interface]
PrivateKey = {private_key}
Address = {vpn_ip}/24
DNS = 1.1.1.1

[Peer]
PublicKey = {WG_SERVER_PUBKEY}
Endpoint = {WG_SERVER_IP}:{WG_SERVER_PORT}
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
"""

    return jsonify({
        "success": True,
        "config": config,
        "ip": vpn_ip,
        "existing": False
    })


# ============ INIT ============


# ═══════════════════════════════════════════════════════════════════════════════
#                              SEAFARE API (iOS App)
# ═══════════════════════════════════════════════════════════════════════════════

import os as _os
SEAFARE_SESSIONS_FILE = '/root/bot/data/seafare_sessions.json'

def load_seafare_sessions():
    if _os.path.exists(SEAFARE_SESSIONS_FILE):
        try:
            with open(SEAFARE_SESSIONS_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
        except:
            return {}
    return {}

@app.route('/api/v1/seafare/status/<code>')
def seafare_status(code):
    sessions = load_seafare_sessions()
    if code in sessions:
        session = sessions[code]
        if session.get('authorized'):
            return jsonify({
                'authorized': True,
                'user': {
                    'id': session.get('telegram_id'),
                    'telegram_id': int(session.get('telegram_id', 0)),
                    'username': session.get('username'),
                    'first_name': session.get('first_name', 'User'),
                    'last_name': session.get('last_name'),
                    'role': 'broker',
                    'company': 'Seafare',
                    'verified': True,
                    'created_at': datetime.utcnow().isoformat() + 'Z',
                    'phone': session.get('phone')
                }
            })
    return jsonify({'authorized': False, 'user': None})


# ═══════════════════════════════════════════════════════════════════════════════
#                    BALANCE API (TIME_BANK sync)
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/balance/<tg_id>', methods=['GET'])
def get_balance(tg_id):
    """Получить баланс по Telegram ID с сервера TIME_BANK"""
    import requests
    try:
        # Запрашиваем баланс у бота на Timeweb
        resp = requests.get(
            f'http://176.124.208.93:8081/api/balance/{tg_id}',
            timeout=5
        )
        if resp.status_code == 200:
            return jsonify(resp.json())
        return jsonify({'balance': 0, 'error': 'not_found'})
    except Exception as e:
        return jsonify({'balance': 0, 'error': str(e)})

if __name__ == '__main__':
    init_db()
    app.run(host="127.0.0.1", port=5002)

# ============ CONTACTS API ============

@app.route('/api/contacts', methods=['GET'])
def get_contacts():
    """Получить контакты пользователя"""
    device_id = request.headers.get('X-Device-ID')
    if not device_id:
        return jsonify({'error': 'No device ID'}), 401
    
    conn = get_db()
    cursor = conn.cursor()
    
    # Найти telegram_id по device_id
    cursor.execute('SELECT telegram_id FROM users WHERE device_id = ?', (device_id,))
    row = cursor.fetchone()
    if not row:
        return jsonify({'contacts': []})
    
    telegram_id = row[0]
    
    # Получить контакты
    cursor.execute('''
        SELECT name, phone FROM contacts 
        WHERE owner_telegram_id = ?
        ORDER BY name
    ''', (telegram_id,))
    
    contacts = [{'name': r[0], 'phone': r[1]} for r in cursor.fetchall()]
    return jsonify({'contacts': contacts})


@app.route('/api/contacts', methods=['POST'])
def save_contact():
    """Сохранить контакт (вызывается ботом)"""
    data = request.json
    telegram_id = data.get('telegram_id')
    name = data.get('name', '')
    phone = data.get('phone', '')
    
    if not telegram_id or not phone:
        return jsonify({'error': 'Missing data'}), 400
    
    conn = get_db()
    cursor = conn.cursor()
    
    # Создать таблицу если не существует
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS contacts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            owner_telegram_id TEXT NOT NULL,
            name TEXT,
            phone TEXT NOT NULL,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            UNIQUE(owner_telegram_id, phone)
        )
    ''')
    
    # Вставить или обновить контакт
    cursor.execute('''
        INSERT OR REPLACE INTO contacts (owner_telegram_id, name, phone)
        VALUES (?, ?, ?)
    ''', (telegram_id, name, phone))
    
    conn.commit()
    return jsonify({'success': True})



# ═══════════════════════════════════════════════════════════════════════════════