import os
import time
import json
import re
import requests
from flask import Flask, request, jsonify
from flask_cors import CORS
from woocommerce import API
from threading import Lock

# ================== КОНФИГУРАЦИЯ ==================
# Вставьте свои данные
TELEGRAM_BOT_TOKEN = "7995140705:AAGgRl8BcYn9Vb1oYfPc0dSkKNNnHNNelYI"
ADMIN_TELEGRAM_ID = 2073528680  # ЗАМЕНИТЕ НА СВОЙ TELEGRAM ID
BOT_DOMAIN = "https://bot.50klimat.ru"
SITE_URL = "https://50klimat.ru"

# WooCommerce данные (замените на свои)
WC_CONSUMER_KEY = "ck_ваш_consumer_key"
WC_CONSUMER_SECRET = "cs_ваш_consumer_secret"

# Настройки бота
BOT_NAME = "Консультант Klimat"
SITE_NAME = "50klimat.ru"
ADMIN_RESPONSE_TIMEOUT = 60  # секунд ожидания ответа админа
# ==================================================

app = Flask(__name__)
CORS(app, origins=[SITE_URL, BOT_DOMAIN])

# Подключение к WooCommerce API
wcapi = API(
    url=SITE_URL,
    consumer_key=WC_CONSUMER_KEY,
    consumer_secret=WC_CONSUMER_SECRET,
    version="wc/v3",
    timeout=30
)

# Хранилище сессий
sessions = {}
sessions_lock = Lock()

# ================== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==================

def send_telegram(chat_id, text, reply_markup=None, reply_to_message_id=None):
    """Отправка сообщения в Telegram"""
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    payload = {
        "chat_id": chat_id,
        "text": text,
        "parse_mode": "HTML",
        "reply_markup": reply_markup
    }
    if reply_to_message_id:
        payload["reply_to_message_id"] = reply_to_message_id
    try:
        r = requests.post(url, json=payload, timeout=10)
        r.raise_for_status()
        return r.json()
    except Exception as e:
        print(f"TG send error: {e}")
        return None

def extract_client_id_from_reply(reply_text):
    """Извлекает client_id из текста пересланного сообщения"""
    match = re.search(r'\(ID:\s*([a-zA-Z0-9_]+)\)', reply_text)
    return match.group(1) if match else None

def search_products(query):
    """Поиск товаров по запросу"""
    try:
        response = wcapi.get("products", params={
            "search": query,
            "per_page": 5,
            "status": "publish"
        })
        if response.status_code == 200:
            products = response.json()
            if products:
                result = "Вот что я нашёл:\n\n"
                for p in products:
                    price = p.get('price', '0')
                    result += f"• {p['name']}\n"
                    result += f"  💰 {price} ₽\n"
                    result += f"  🔗 {p.get('permalink', '')}\n\n"
                return result
            else:
                return "Ничего не нашёл. Уточните запрос."
        else:
            return "Ошибка при поиске товаров."
    except Exception as e:
        print(f"WC error: {e}")
        return "Техническая ошибка. Попробуйте позже."

def get_order_status(order_id):
    """Получение статуса заказа по номеру"""
    try:
        response = wcapi.get(f"orders/{order_id}")
        if response.status_code == 200:
            order = response.json()
            status = order.get('status', 'неизвестен')
            total = order.get('total', '0')
            return f"Заказ #{order_id}\nСтатус: {status}\nСумма: {total} ₽"
        else:
            return f"Заказ #{order_id} не найден."
    except:
        return "Ошибка при запросе заказа."

# ================== ТЕЛЕГРАМ WEBHOOK ==================

@app.route('/webhook/tg', methods=['POST'])
def tg_webhook():
    """ГЛАВНЫЙ ОБРАБОТЧИК ВСЕХ СОБЫТИЙ ОТ TELEGRAM"""
    data = request.get_json()
    print(f"Telegram webhook received: {data}")  # Для отладки
    
    # Обработка callback-кнопок (Взять диалог/Игнорировать)
    if "callback_query" in data:
        cb = data["callback_query"]
        cb_data = cb["data"]
        from_id = cb["from"]["id"]
        message = cb["message"]
        
        # Проверяем, что это админ
        if from_id != ADMIN_TELEGRAM_ID:
            return "ok", 200
        
        if cb_data.startswith("take_"):
            client_id = cb_data.replace("take_", "")
            with sessions_lock:
                session = sessions.get(client_id)
                if session:
                    session["mode"] = "manual"
                    session["admin_in_chat"] = True
                    # Уведомляем админа
                    send_telegram(
                        ADMIN_TELEGRAM_ID,
                        f"✅ Вы взяли диалог с клиентом {client_id}. Теперь все сообщения этого клиента будут приходить сюда, а ваши ответы (через Reply) будут уходить ему."
                    )
                    # Сообщаем клиенту на сайте
                    session["messages_to_send"].append({
                        "sender": "bot",
                        "text": "С вами сейчас свяжется наш специалист. Ожидайте ответа."
                    })
            
            # Убираем кнопки из сообщения
            edit_url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/editMessageReplyMarkup"
            requests.post(edit_url, json={
                "chat_id": ADMIN_TELEGRAM_ID,
                "message_id": message["message_id"],
                "reply_markup": {"inline_keyboard": []}
            })
        
        elif cb_data.startswith("ignore_"):
            # Просто удаляем кнопки
            edit_url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/editMessageReplyMarkup"
            requests.post(edit_url, json={
                "chat_id": ADMIN_TELEGRAM_ID,
                "message_id": message["message_id"],
                "reply_markup": {"inline_keyboard": []}
            })
        
        return "ok", 200
    
    # Обработка обычных сообщений от админа (ответы клиентам)
    if "message" in data:
        msg = data["message"]
        chat_id = msg["chat"]["id"]
        
        # Если сообщение не от админа - игнорируем
        if chat_id != ADMIN_TELEGRAM_ID:
            return "ok", 200
        
        # Проверяем, является ли это ответом на какое-то сообщение бота
        reply_to = msg.get("reply_to_message")
        if not reply_to:
            send_telegram(ADMIN_TELEGRAM_ID, 
                         "Чтобы ответить клиенту, нажмите 'Ответить' на его сообщении.")
            return "ok", 200
        
        # Из текста исходного сообщения извлекаем client_id
        original_text = reply_to.get("text", "")
        client_id = extract_client_id_from_reply(original_text)
        if not client_id:
            send_telegram(ADMIN_TELEGRAM_ID, 
                         "Не удалось определить клиента. Ответьте на сообщение, которое содержит ID клиента.")
            return "ok", 200
        
        # Отправляем ответ клиенту
        with sessions_lock:
            session = sessions.get(client_id)
            if not session:
                send_telegram(ADMIN_TELEGRAM_ID, f"Сессия {client_id} уже закрыта.")
                return "ok", 200
            
            admin_text = msg.get("text", "")
            session["messages_to_send"].append({
                "sender": "admin",
                "text": admin_text
            })
            send_telegram(ADMIN_TELEGRAM_ID, f"✉️ Ответ отправлен клиенту {client_id}")
    
    return "ok", 200

# ================== API ДЛЯ ВИДЖЕТА ==================

@app.route('/api/start', methods=['POST'])
def start_session():
    """Начало новой сессии с клиентом"""
    data = request.get_json()
    client_id = data.get("client_id")
    if not client_id:
        return jsonify({"error": "client_id required"}), 400
    
    with sessions_lock:
        sessions[client_id] = {
            "client_id": client_id,
            "mode": "auto",
            "admin_in_chat": False,
            "state": "waiting_name",
            "name": None,
            "phone": None,
            "product": None,
            "budget": None,
            "timing": None,
            "messages_to_send": [
                {
                    "sender": "bot",
                    "text": "Здравствуйте! Я консультант Klimat. Как вас зовут?"
                }
            ],
            "questions": [
                "Как вас зовут?",
                "Какой тип кондиционера вас интересует? (настенный, канальный, кассетный)",
                "Какой у вас бюджет примерно?",
                "Когда планируете установку?",
                "Ваш номер телефона для связи:"
            ],
            "current_q_index": 0,
            "created_at": time.time()
        }
    
    # Отправляем уведомление админу о новом посетителе
    notify_text = f"🆕 <b>Новый посетитель на {SITE_NAME}</b>\n"
    notify_text += f"ID сессии: <code>{client_id}</code>\n"
    notify_text += "Нажмите кнопку, чтобы взять диалог в свои руки."
    
    keyboard = {
        "inline_keyboard": [
            [
                {"text": "✅ Взять диалог", "callback_data": f"take_{client_id}"},
                {"text": "⏭ Игнорировать", "callback_data": f"ignore_{client_id}"}
            ]
        ]
    }
    send_telegram(ADMIN_TELEGRAM_ID, notify_text, reply_markup=keyboard)
    
    return jsonify({"status": "ok"})

@app.route('/api/poll', methods=['POST'])
def poll():
    """Клиент запрашивает новые сообщения"""
    data = request.get_json()
    client_id = data.get("client_id")
    
    with sessions_lock:
        session = sessions.get(client_id)
        if not session:
            return jsonify({"error": "session not found"}), 404
        
        messages = session.get("messages_to_send", [])
        session["messages_to_send"] = []
    
    return jsonify({"messages": messages})

@app.route('/api/message', methods=['POST'])
def client_message():
    """Клиент отправил сообщение"""
    data = request.get_json()
    client_id = data.get("client_id")
    text = data.get("text")
    
    if not client_id or not text:
        return jsonify({"error": "client_id and text required"}), 400
    
    with sessions_lock:
        session = sessions.get(client_id)
        if not session:
            return jsonify({"error": "session not found"}), 404
        
        # Если режим ручной – пересылаем админу
        if session.get("mode") == "manual" and session.get("admin_in_chat"):
            name = session.get("name", "неизвестно")
            admin_msg = f"💬 <b>Клиент {name}</b> (ID: {client_id}):\n{text}"
            send_telegram(ADMIN_TELEGRAM_ID, admin_msg)
            return jsonify({"status": "ok"})
        
        # Автоматический режим – обрабатываем по состояниям
        state = session.get("state")
        text_lower = text.lower()
        
        # Проверяем специальные запросы
        if any(kw in text_lower for kw in ['кондиционер', 'сплит', 'цена', 'стоит', 'товар']):
            reply = search_products(text)
        elif 'заказ' in text_lower and re.search(r'\d+', text):
            order_id = re.search(r'\d+', text).group()
            reply = get_order_status(order_id)
        else:
            # Стандартный опросник
            if state == "waiting_name":
                session["name"] = text
                session["state"] = "waiting_product"
                reply = session["questions"][1]
            elif state == "waiting_product":
                session["product"] = text
                session["state"] = "waiting_budget"
                reply = session["questions"][2]
            elif state == "waiting_budget":
                session["budget"] = text
                session["state"] = "waiting_timing"
                reply = session["questions"][3]
            elif state == "waiting_timing":
                session["timing"] = text
                session["state"] = "waiting_phone"
                reply = session["questions"][4]
            elif state == "waiting_phone":
                session["phone"] = text
                reply = "Спасибо! Мы свяжемся с вами в ближайшее время."
                session["state"] = "finished"
                # Отправляем админу карточку лида
                lead_msg = f"✅ <b>Новый лид!</b>\n"
                lead_msg += f"Имя: {session['name']}\n"
                lead_msg += f"Тип: {session.get('product', '-')}\n"
                lead_msg += f"Бюджет: {session.get('budget', '-')}\n"
                lead_msg += f"Сроки: {session.get('timing', '-')}\n"
                lead_msg += f"Телефон: {session['phone']}\n"
                lead_msg += f"ID: {client_id}"
                send_telegram(ADMIN_TELEGRAM_ID, lead_msg)
            else:
                reply = "Спасибо за обращение! Если появятся вопросы, напишите нам."
        
        session["messages_to_send"].append({
            "sender": "bot",
            "text": reply
        })
    
    return jsonify({"status": "ok"})

# ================== WEBHOOK ДЛЯ WOOCOMMERCE ==================

@app.route('/webhook/woocommerce', methods=['POST'])
def woocommerce_webhook():
    """Принимает уведомления от WooCommerce"""
    data = request.get_json()
    topic = request.headers.get('X-WC-Webhook-Topic', '')
    
    print(f"WC webhook received: {topic}")
    
    if 'order.created' in topic:
        order = data
        name = order.get('billing', {}).get('first_name', 'Неизвестно')
        total = order.get('total', '0')
        items = order.get('line_items', [])
        msg = f"🛒 <b>НОВЫЙ ЗАКАЗ!</b>\n\nКлиент: {name}\nСумма: {total} ₽\nТовары:\n"
        for item in items[:3]:
            msg += f"  • {item.get('name')} x{item.get('quantity')}\n"
        send_telegram(ADMIN_TELEGRAM_ID, msg)
    
    elif 'customer.created' in topic:
        customer = data
        msg = f"👤 <b>Новый клиент</b>\nИмя: {customer.get('first_name')} {customer.get('last_name')}\nEmail: {customer.get('email')}"
        send_telegram(ADMIN_TELEGRAM_ID, msg)
    
    return "OK", 200

# ================== ТЕСТОВЫЙ МАРШРУТ ==================

@app.route('/ping', methods=['GET'])
def ping():
    """Проверка, что бот работает"""
    return jsonify({"status": "ok", "message": "Bot is alive!"})

# ================== ЗАПУСК ==================

if __name__ == '__main__':
    print("Starting Klimat Bot...")
    print(f"Bot token: {TELEGRAM_BOT_TOKEN[:10]}...")
    print(f"Admin ID: {ADMIN_TELEGRAM_ID}")
    print(f"Bot domain: {BOT_DOMAIN}")
    app.run(host='0.0.0.0', port=5000, debug=False)