# This file is part of Senator Sperma
# Licensed under the GPL-3.0 License
# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
# https://codeberg.org/salmonik/senator-sperma

import discord
from discord.ext import commands
import httpx
import logging
import os

logger = logging.getLogger(__name__)

class Jarvis(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.keyword = os.getenv("ASSISTANT_KEYWORD", "jarvis").lower()

    @commands.Cog.listener()
    async def on_message(self, message):
        if message.author == self.bot.user:
            return

        logger.info(message.content)

        if message.mentions:
            if message.mentions[0].id == self.bot.user.id:
                await self.assistant(message)

        elif self.keyword in message.content.lower():
            await self.assistant(message)

    @staticmethod
    async def assistant(message):
        headers = {
            "Authorization": f"Bearer {os.getenv('OPENROUTER_API_KEY')}",
            "Content-Type": "application/json"
        }

        chain = await Jarvis._build_message_chain(message)
        messages = Jarvis._build_messages(message, chain)
        payload = Jarvis._build_payload(messages)

        response_data = await Jarvis._safe_api_call(payload, headers)
        if response_data is None:
            await message.reply("Przepraszam, nie mogę teraz odpowiedzieć. Spróbuj ponownie później.")
            return

        response_message = Jarvis._parse_response(response_data)

        channel = message.channel
        await message.reply(response_message)

    @staticmethod
    async def _build_message_chain(message):
        chain = []
        current = message
        max_depth = 5

        while current and len(chain) < max_depth:
            chain.append(current)
            if not current.reference:
                break
            try:
                if current.reference.resolved:
                    current = current.reference.resolved
                else:
                    current = await current.channel.fetch_message(current.reference.message_id)
            except discord.NotFound:
                break

        return list(reversed(chain))

    @staticmethod
    def _build_messages(message, chain=None):
        messages = [{
            "role": "system",
            "content": "Jesteś Senator Sperma Armostrong, także znany jako Jarvis."
                       "Twoim zadaniem jest asystowanie użytkownika"
                       "zachowuj sie jak Jarvis, bądź osobistym asystentem użytkownika, nie używaj emotikon"
                       "nie pytaj sie użytkownika czy chce abyś coś zrobił, użytkownik ci sam powie abyś coś wykonał"
                       "Nie pozostawiaj wiadomości pustej oraz nie dawaj swojej wiadomości w pole myślenia"
        }]

        if chain is None:
            chain = [message]

        for msg in chain:
            messages.append({
                "role": "user",
                "content": f"USER: {msg.author.display_name}\nMESSAGE: {msg.content}"
            })

        return messages

    @staticmethod
    def _build_payload(messages):
        return {
            "model": os.getenv("OPENROUTER_MODEL"),
            "messages": messages,
            "plugins": [{"id": "response-healing"}]
        }

    @staticmethod
    async def _make_api_request(payload, headers):
        async with httpx.AsyncClient(timeout=30.0) as client:
            url = "https://openrouter.ai/api/v1/chat/completions"
            response = await client.post(url=url, headers=headers, json=payload)
            response_data = response.json()
            logger.info(response_data)
            return response_data

    @staticmethod
    async def _safe_api_call(payload, headers):
        try:
            return await Jarvis._make_api_request(payload, headers)
        except httpx.HTTPError as e:
            logger.error(f"API request failed: {e}")
            return None

    @staticmethod
    def _parse_response(response_data):
        content = response_data['choices'][0]['message']['content']

        logger.info(content)

        return content

def setup(bot):
    bot.add_cog(Jarvis(bot))