"""
Detecte les nouveaux commentaires sur les posts LinkedIn de Jimmy
via le Member Changelog API (DMA / r_dma_portability_self_serve).
Lance automatiquement par cron toutes les 5 minutes.
"""

import os, json, logging, requests, time
from dotenv import load_dotenv

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

import db, linkedin, claude_helper, gojiberry_helper

LOG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'monitor.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                = os.getenv('TELEGRAM_CHAT_ID')
MAX_RESPONSES_PER_POST = 20

# Fichier pour stocker le dernier timestamp traite
LAST_TS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'last_processed_ts.txt')


def get_last_processed_ts():
    """Lit le dernier timestamp processedAt traite (epoch ms)."""
    try:
        with open(LAST_TS_FILE, 'r') as f:
            return int(f.read().strip())
    except Exception:
        # Premiere execution : remonter 10 minutes en arriere
        return int(time.time() * 1000) - 10 * 60 * 1000


def save_last_processed_ts(ts_ms):
    """Sauvegarde le dernier timestamp traite."""
    with open(LAST_TS_FILE, 'w') as f:
        f.write(str(ts_ms))


def send_telegram(text, keyboard=None):
    url = 'https://api.telegram.org/bot{}/sendMessage'.format(BOT_TOKEN)
    payload = {'chat_id': CHAT_ID, 'text': text, 'parse_mode': 'Markdown'}
    if keyboard:
        payload['reply_markup'] = json.dumps(keyboard)
    r = requests.post(url, json=payload, timeout=10)
    r.raise_for_status()
    return r.json()


def make_keyboard(pending_id):
    return {"inline_keyboard": [[
        {"text": "Publier",  "callback_data": "approve_{}".format(pending_id)},
        {"text": "Modifier", "callback_data": "edit_{}".format(pending_id)},
        {"text": "Ignorer",  "callback_data": "reject_{}".format(pending_id)},
    ]]}


def check_new_comments():
    try:
        last_ts = get_last_processed_ts()
        logging.info("Recherche commentaires depuis ts={}".format(last_ts))

        comment_events = linkedin.get_comment_events(start_time_ms=last_ts)
        logging.info("{} evenement(s) commentaire trouve(s)".format(len(comment_events)))

        max_ts = last_ts

        for event in comment_events:
            event_id     = str(event.get('id', ''))
            processed_at = event.get('processedAt', 0)
            comment_text = linkedin.extract_comment_text(event)
            post_urn     = linkedin.extract_post_urn(event)
            comment_urn  = event.get('resourceUri', '') or event_id

            if not event_id or not comment_text:
                continue

            # Mettre a jour le timestamp max
            if processed_at > max_ts:
                max_ts = processed_at

            # Deja traite ?
            if db.is_comment_processed(event_id):
                continue

            # Limite de 20 reponses par post
            count = db.get_post_response_count(post_urn)
            if count >= MAX_RESPONSES_PER_POST:
                logging.info("Limite atteinte pour {} ({}/{})".format(
                    post_urn, count, MAX_RESPONSES_PER_POST))
                db.add_processed_comment(event_id, post_urn, comment_text, 'limit_reached')
                continue

            # Enregistrer le commentaire
            db.add_processed_comment(event_id, post_urn, comment_text)

            # Generer une reponse avec Claude
            try:
                proposed = claude_helper.generate_response(comment_text, '')
            except Exception as e:
                logging.error("Erreur Claude : {}".format(e))
                proposed = "_(Erreur de generation - ecris ta reponse manuellement)_"

            # Sauvegarder en attente de validation
            pending_id = db.add_pending_response(
                comment_id=event_id,
                post_id=post_urn,
                comment_urn=comment_urn,
                proposed_response=proposed
            )

            # Pousser vers Gojiberry
            actor_info = linkedin.extract_actor_info(event)
            if actor_info.get('profile_url'):
                try:
                    campaigns = gojiberry_helper.get_active_campaigns()
                    list_id   = claude_helper.choose_campaign(comment_text, campaigns)
                    if list_id:
                        campaign_name = next(
                            (c['name'] for c in campaigns if c['list_id'] == list_id), 'N/A')
                        gojiberry_helper.add_to_list(
                            list_id=list_id,
                            first_name=actor_info['first_name'],
                            last_name=actor_info['last_name'],
                            profile_url=actor_info['profile_url'],
                            note=comment_text[:500],
                            intent="Commentaire LinkedIn",
                            linkedin_identifier=actor_info.get('linkedin_id', '')
                        )
                        logging.info("Gojiberry : {} {} -> campagne '{}'".format(
                            actor_info['first_name'], actor_info['last_name'], campaign_name))
                    else:
                        logging.warning("Gojiberry : aucune campagne active trouvee")
                except Exception as e:
                    logging.error("Erreur Gojiberry push : {}".format(e))

            # Envoyer la notification Telegram
            actor_info = linkedin.extract_actor_info(event)
            gojiberry_note = ""
            if actor_info.get('profile_url'):
                gojiberry_note = "\n\n*Profil :* {}".format(actor_info['profile_url'])

            msg = ("*Nouveau commentaire sur ton post*\n\n"
                   "*Commentaire :*\n_{}_\n\n"
                   "*Reponse proposee :*\n{}{}").format(
                       comment_text, proposed, gojiberry_note)

            try:
                tg = send_telegram(msg, make_keyboard(pending_id))
                tg_msg_id = tg.get('result', {}).get('message_id')
                db.update_pending(pending_id, 'waiting', telegram_message_id=tg_msg_id)
                logging.info("Commentaire {} envoye sur Telegram (msg {})".format(
                    event_id, tg_msg_id))
            except Exception as e:
                logging.error("Erreur Telegram : {}".format(e))

        # Sauvegarder le nouveau timestamp
        if max_ts > last_ts:
            save_last_processed_ts(max_ts)

    except Exception as e:
        logging.error("Erreur check_new_comments : {}".format(e))


if __name__ == '__main__':
    logging.info("=== Monitor demarre ===")
    db.init_db()
    check_new_comments()
    logging.info("=== Monitor termine ===")