"""
Bot Telegram de validation des réponses LinkedIn.
Compatible Python 3.6 / python-telegram-bot v13 — mode polling.

Lancement : screen -dmS linkedin_comments python3 bot.py
"""
import os, logging
from dotenv import load_dotenv

load_dotenv(os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env'))

from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    Updater, CallbackQueryHandler, MessageHandler, Filters,
    ConversationHandler, CommandHandler
)

import db, linkedin

LOG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'bot.log')
logging.basicConfig(filename=LOG_FILE, level=logging.INFO,
                    format='%(asctime)s %(levelname)s %(message)s')

BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
CHAT_ID   = int(os.getenv('TELEGRAM_CHAT_ID'))

WAITING_EDIT = 1


# ─────────────────────────── Callbacks ───────────────────────────

def cb_approve(update, context):
    """Publier la réponse sur LinkedIn."""
    query = update.callback_query
    query.answer()
    if query.message.chat_id != CHAT_ID:
        return

    pending_id = int(query.data.replace('approve_', ''))
    row = db.get_pending_by_id(pending_id)
    if not row:
        query.edit_message_text("❌ Entrée introuvable.")
        return

    # (id, tg_msg_id, comment_id, post_id, comment_urn, proposed_response, created_at, status)
    _, tg_msg_id, comment_id, post_id, comment_urn, proposed_response, _, status = row

    if status == 'posted':
        query.edit_message_text(
            query.message.text + "\n\n✅ _(déjà publié)_", parse_mode='Markdown')
        return

    try:
        linkedin.post_reply(post_id, proposed_response, parent_comment_urn=comment_urn)
        db.increment_post_response_count(post_id)
        db.update_pending(pending_id, 'posted')
        db.update_comment_status(comment_id, 'posted')
        query.edit_message_text(
            query.message.text + "\n\n✅ *Publié sur LinkedIn !*",
            parse_mode='Markdown'
        )
        logging.info("Réponse publiée pour commentaire {}".format(comment_id))
    except Exception as e:
        logging.error("Erreur LinkedIn publish : {}".format(e))
        query.edit_message_text("❌ Erreur LinkedIn : {}".format(str(e)))


def cb_edit(update, context):
    """Passer en mode édition."""
    query = update.callback_query
    query.answer()
    if query.message.chat_id != CHAT_ID:
        return ConversationHandler.END

    pending_id = int(query.data.replace('edit_', ''))
    context.user_data['editing_id'] = pending_id
    db.update_pending(pending_id, 'editing')

    query.message.reply_text(
        "✏️ *Mode édition* — Envoie ta nouvelle réponse :\n_(ou /annuler pour abandonner)_",
        parse_mode='Markdown'
    )
    return WAITING_EDIT


def cb_reject(update, context):
    """Ignorer le commentaire."""
    query = update.callback_query
    query.answer()
    if query.message.chat_id != CHAT_ID:
        return

    pending_id = int(query.data.replace('reject_', ''))
    row = db.get_pending_by_id(pending_id)
    if row:
        db.update_pending(pending_id, 'rejected')
        db.update_comment_status(row[2], 'rejected')

    query.edit_message_text(
        query.message.text + "\n\n❌ *Ignoré.*",
        parse_mode='Markdown'
    )


def receive_edit(update, context):
    """Reçoit le texte modifié et propose confirmation."""
    if update.message.chat_id != CHAT_ID:
        return ConversationHandler.END

    pending_id = context.user_data.get('editing_id')
    new_text   = update.message.text
    if not pending_id:
        return ConversationHandler.END

    db.update_pending(pending_id, 'waiting', new_response=new_text)

    keyboard = InlineKeyboardMarkup([[
        InlineKeyboardButton("✅ Confirmer et publier",
                             callback_data="approve_{}".format(pending_id)),
        InlineKeyboardButton("❌ Annuler",
                             callback_data="reject_{}".format(pending_id)),
    ]])

    update.message.reply_text(
        "📝 *Nouvelle réponse :*\n_{}_\n\nConfirmer la publication ?".format(new_text),
        reply_markup=keyboard,
        parse_mode='Markdown'
    )
    return ConversationHandler.END


def cmd_cancel(update, context):
    """Annuler l'édition en cours."""
    context.user_data.clear()
    update.message.reply_text("Édition annulée.")
    return ConversationHandler.END


# ─────────────────────────── Main ───────────────────────────

def main():
    db.init_db()
    updater = Updater(BOT_TOKEN, use_context=True)
    dp = updater.dispatcher

    conv = ConversationHandler(
        entry_points=[CallbackQueryHandler(cb_edit, pattern='^edit_')],
        states={WAITING_EDIT: [
            MessageHandler(Filters.text & ~Filters.command, receive_edit),
            CommandHandler('annuler', cmd_cancel),
        ]},
        fallbacks=[CommandHandler('annuler', cmd_cancel)]
    )

    dp.add_handler(conv)
    dp.add_handler(CallbackQueryHandler(cb_approve, pattern='^approve_'))
    dp.add_handler(CallbackQueryHandler(cb_reject,  pattern='^reject_'))

    logging.info("Bot démarré en mode polling.")
    updater.start_polling()
    updater.idle()


if __name__ == '__main__':
    main()