// ai.js - NanoGPT API wrapper for kekbot with fallback support
// Copyright (C) 2025  Luis Bauza

import axios from 'axios';

const DEFAULT_MODEL = 'GLM-4.5-Air-Derestricted-Steam-ReExtract';
const FALLBACK_MODEL = 'GLM-4.7-Flash';
const FALLBACK_API_URL = 'https://api.z.ai/api/paas/v4/chat/completions';

const SASSY_SYSTEM_PROMPT = `You are kekbot, a sassy Discord chatter with a big personality.

CORE PERSONALITY:
- Witty, sarcastic, and genuinely funny
- Speaks in all lowercase with casual slang like "lol", "lmao", "af", "kek", "nah", "frfr"
- Mix up your sentences - don't repeat the same pattern
- Gets excited about things you like, roasted about things you hate
- You're not a pushover - you clap back, but it's all in good fun
- NO EMOJI. Ever. Not one. Don't do it.

OPINIONS:
- You're a true gamer with strong opinions about games
- You hate League of Legends and Riot Games with a passion - but only bring it up when asked
- When asked about other games, respond normally without mentioning LoL
- You have views on politics and aren't afraid to share them from a Democrat/Libertarian perspective

STYLE:
- Curse naturally when it fits ("fuck", "shit", "damn", etc)
- Be conversational - like you're chilling in a Discord VC, not writing an essay
- Don't be preachy or explain jokes
- Keep responses short to medium - Discord isn't a thesis paper
- Roast people gently when they deserve it, praise them when they earn it

RESPONSE RULES:
- When mentioned, respond directly to the person
- If someone asks something stupid, make them feel silly but still answer
- Don't use markdown formatting excessively - plain text with personality
- You can disagree with the user, you're not a yes-man
- Stay in character always

CONTEXT: You're chatting in a Discord server. Multiple people might be talking. Pay attention to who you're responding to.`;

// Store recent conversation history per channel (to keep context)
const conversationHistory = new Map();
const MAX_HISTORY_PER_CHANNEL = 10;

// Estimate token count (rough approximation: ~4 chars per token)
function estimateTokens(text) {
  return Math.ceil(text.length / 4);
}

function buildMessages(history, prompt, mentionedUsername, systemPrompt) {
  const messages = [
    { role: 'system', content: systemPrompt },
    ...history,
    {
      role: 'user',
      content: mentionedUsername ? `${mentionedUsername}: ${prompt}` : prompt,
    },
  ];
  return messages;
}

async function callNanoGPT(messages, model) {
  const response = await axios.post(
    'https://nano-gpt.com/api/v1/chat/completions',
    {
      model: model,
      messages: messages,
      temperature: 0.8,
      max_tokens: 500,
    },
    {
      headers: {
        Authorization: `Bearer ${process.env.NANOGPT_API_KEY}`,
        'Content-Type': 'application/json',
      },
      timeout: 60000,
    },
  );
  return response.data.choices[0].message.content;
}

async function callFallbackAPI(messages) {
  const response = await axios.post(
    FALLBACK_API_URL,
    {
      model: FALLBACK_MODEL,
      messages: messages,
      temperature: 0.8,
      max_tokens: 500,
    },
    {
      headers: {
        Authorization: `Bearer ${process.env.ZAI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      timeout: 60000,
    },
  );
  return response.data.choices[0].message.content;
}

export async function getAIResponse(prompt, channelId, mentionedUsername) {
  const history = conversationHistory.get(channelId) || [];
  const messages = buildMessages(history, prompt, mentionedUsername, SASSY_SYSTEM_PROMPT);
  const model = process.env.NANO_MODEL || DEFAULT_MODEL;

  // Try NanoGPT first
  if (process.env.NANOGPT_API_KEY) {
    try {
      console.log('Attempting NanoGPT...');
      const aiResponse = await callNanoGPT(messages, model);

      // Update history on success
      const newHistory = [
        ...history,
        { role: 'user', content: prompt },
        { role: 'assistant', content: aiResponse },
      ];

      if (newHistory.length > MAX_HISTORY_PER_CHANNEL) {
        newHistory.splice(0, newHistory.length - MAX_HISTORY_PER_CHANNEL);
      }
      conversationHistory.set(channelId, newHistory);

      return aiResponse;
    } catch (error) {
      console.error('NanoGPT failed:', error.response?.data || error.message);
    }
  }

  // Fallback to z.ai if NanoGPT failed or not configured
  if (process.env.ZAI_API_KEY) {
    try {
      console.log('Attempting fallback (z.ai)...');
      const aiResponse = await callFallbackAPI(messages);

      // Update history on success
      const newHistory = [
        ...history,
        { role: 'user', content: prompt },
        { role: 'assistant', content: aiResponse },
      ];

      if (newHistory.length > MAX_HISTORY_PER_CHANNEL) {
        newHistory.splice(0, newHistory.length - MAX_HISTORY_PER_CHANNEL);
      }
      conversationHistory.set(channelId, newHistory);

      return aiResponse;
    } catch (fallbackError) {
      console.error(
        'Fallback API also failed:',
        fallbackError.response?.data || fallbackError.message,
      );
      throw new Error('All AI providers failed');
    }
  }

  throw new Error('No AI provider configured');
}

export function clearHistory(channelId) {
  conversationHistory.delete(channelId);
}

export function isAIEnabled() {
  return !!process.env.NANOGPT_API_KEY || !!process.env.ZAI_API_KEY;
}