src/agent.ts

import { llm, currentModel } from './llm.js';
import { getCurrentTimeTool, executeGetCurrentTime } from './tools/time.js';
import { saveMemoryTool, searchMemoryTool, executeSaveMemory, executeSearchMemory } from './tools/memory.js';
import { shellCommandTool, executeShellCommand } from './tools/shell.js';
import { listFilesTool, readFileTool, writeToFileTool, executeListFiles, executeReadFile, executeWriteFile } from './tools/fs.js';
import { browserTool, executeBrowserVisit } from './tools/browser.js';
import { webSearchTool, executeWebSearch } from './tools/search.js';
import { scheduleTimerTool, scheduleCronJobTool, listScheduledTasksTool, deleteScheduledTaskTool, executeScheduleTimer, executeScheduleCronJob, executeListScheduledTasks, executeDeleteScheduledTask } from './tools/cron.js';
import { sendNotificationTool, executeSendNotification, sendPushSilent } from './tools/notify.js';
import { Message } from 'ollama';
import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import { MemoryModel, SessionModel } from './memory/db.js';

const MAX_ITERATIONS = 8;
const NOTIFICATIONS_FILE = path.join(process.cwd(), 'notifications.json');

// State: which session is active + session metadata
interface SessionMeta {
    id: string;
    title: string;
    createdAt: string;
    updatedAt: string;
}

interface ChatState {
    activeSessionId: string;
    sessions: SessionMeta[];
}

let chatState: ChatState = { activeSessionId: '', sessions: [] };
let conversationHistory: Message[] = [];

// --- State persistence (MongoDB) ---
export async function loadState() {
    try {
        const dbSessions = await SessionModel.find().lean();
        chatState.sessions = dbSessions.map(s => ({
            id: s.id as string,
            title: s.title,
            createdAt: s.createdAt as string,
            updatedAt: s.updatedAt as string
        }));

        if (chatState.sessions.length > 0) {
            // Keep the first one active by default if none selected
            if (!chatState.activeSessionId) {
                chatState.activeSessionId = chatState.sessions[0].id;
                await loadSessionHistory(chatState.activeSessionId);
            } else {
                // Or reload the currently active one
                await loadSessionHistory(chatState.activeSessionId);
            }
        } else {
            // Create the first session if database is empty
            await createSession();
        }
    } catch (e) {
        console.error("Failed to load chat state from MongoDB:", e);
    }
}

// Ensure the current history memory array matches the active DB session
async function saveSessionHistory(id: string, history: Message[]) {
    try {
        await SessionModel.findOneAndUpdate(
            { id },
            { $set: { history, updatedAt: new Date().toISOString() } }
        );
    } catch (e) {
        console.error(`Failed to save session ${id} to DB:`, e);
    }
}

async function loadSessionHistory(id: string) {
    try {
        const session = await SessionModel.findOne({ id }).lean();
        if (session && session.history) {
            conversationHistory = session.history as Message[];
        } else {
            conversationHistory = [];
        }
    } catch (e) {
        console.error(`Failed to load session ${id} from DB:`, e);
        conversationHistory = [];
    }
}

// --- Session management ---
export async function createSession(): Promise<SessionMeta> {
    // Save current session before switching
    if (chatState.activeSessionId && conversationHistory.length > 1) {
        await saveSessionHistory(chatState.activeSessionId, conversationHistory);
    }

    const id = crypto.randomUUID().substring(0, 8);
    const now = new Date().toISOString();
    const meta: SessionMeta = {
        id,
        title: 'Neuer Chat',
        createdAt: now,
        updatedAt: now
    };

    // Create directly in DB
    await SessionModel.create({
        id,
        title: 'Neuer Chat',
        history: [],
        createdAt: now,
        updatedAt: now
    });

    chatState.sessions.push(meta);
    chatState.activeSessionId = id;
    conversationHistory = [];

    console.log(`📝 Created new chat session in DB: ${id}`);
    return meta;
}

export async function switchSession(id: string): Promise<boolean> {
    const session = chatState.sessions.find(s => s.id === id);
    if (!session) return false;

    // Save current session
    if (chatState.activeSessionId && conversationHistory.length > 0) {
        await saveSessionHistory(chatState.activeSessionId, conversationHistory);
    }

    // Load target session
    chatState.activeSessionId = id;
    await loadSessionHistory(id);

    console.log(`🔄 Switched to session: ${id} (${session.title})`);
    return true;
}

export async function deleteSession(id: string): Promise<boolean> {
    const idx = chatState.sessions.findIndex(s => s.id === id);
    if (idx === -1) return false;

    // Delete from memory and DB
    chatState.sessions.splice(idx, 1);
    await SessionModel.deleteOne({ id });

    // If we deleted the active session, switch to the most recent one or create new
    if (chatState.activeSessionId === id) {
        if (chatState.sessions.length > 0) {
            await switchSession(chatState.sessions[0].id);
        } else {
            await createSession();
        }
    }

    return true;
}

export function listSessions(): SessionMeta[] {
    return [...chatState.sessions].sort((a, b) =>
        new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
    );
}

export function getCurrentSessionId(): string {
    return chatState.activeSessionId;
}

export function getHistory(): Message[] {
    return conversationHistory;
}

export function clearConversationHistory() {
    // "New Chat" = save current + create fresh session
    createSession();
}

// --- Notifications Inbox ---
interface Notification {
    id: string;
    type: 'cron' | 'heartbeat' | 'timer';
    message: string;
    timestamp: string;
}

export function pushNotification(type: Notification['type'], message: string) {
    let notifications: Notification[] = [];
    try {
        if (fs.existsSync(NOTIFICATIONS_FILE)) {
            notifications = JSON.parse(fs.readFileSync(NOTIFICATIONS_FILE, 'utf-8'));
        }
    } catch (e) { /* empty */ }

    notifications.push({
        id: crypto.randomUUID().substring(0, 8),
        type,
        message,
        timestamp: new Date().toISOString()
    });

    fs.writeFileSync(NOTIFICATIONS_FILE, JSON.stringify(notifications, null, 2), 'utf-8');

    // Also send a real push notification via ntfy.sh
    sendPushSilent(`Nui 🌀 ${type}`, message);
}

export function getAndClearNotifications(): Notification[] {
    let notifications: Notification[] = [];
    try {
        if (fs.existsSync(NOTIFICATIONS_FILE)) {
            notifications = JSON.parse(fs.readFileSync(NOTIFICATIONS_FILE, 'utf-8'));
            fs.writeFileSync(NOTIFICATIONS_FILE, '[]', 'utf-8');
        }
    } catch (e) { /* empty */ }
    return notifications;
}

// --- Initialize: load state, ensure active session ---
// We call this directly when the app starts. It's async, so we wrap in an IIFE
// but in a module context, we can just export an init function or rely on top-level await
// Since this is agent.ts, we'll let index.ts handle the boot sequence correctly.
// For now, we just declare the function. We will call it from api.ts or index.ts.

export async function initAgent() {
    await loadState();

    const CHATS_DIR = path.join(process.cwd(), 'chats');
    const OLD_HISTORY_FILE = path.join(process.cwd(), 'chat_history.json');

    // Migrate old chat_history.json
    if (fs.existsSync(OLD_HISTORY_FILE) && chatState.sessions.length === 0) {
        try {
            const oldHistory = JSON.parse(fs.readFileSync(OLD_HISTORY_FILE, 'utf-8'));
            if (oldHistory.length > 0) {
                const id = crypto.randomUUID().substring(0, 8);
                const firstUserMsg = oldHistory.find((m: any) => m.role === 'user');
                const now = new Date().toISOString();
                const title = firstUserMsg ? firstUserMsg.content.substring(0, 30) + '...' : 'Importierter Chat';

                await SessionModel.create({
                    id,
                    title,
                    history: oldHistory,
                    createdAt: now,
                    updatedAt: now
                });

                chatState.sessions.push({ id, title, createdAt: now, updatedAt: now });
                chatState.activeSessionId = id;
                console.log('📦 Migrated old chat_history.json into MongoDB.');
            }
            fs.renameSync(OLD_HISTORY_FILE, OLD_HISTORY_FILE + '.bak');
        } catch (e) {
            console.error("Failed to migrate old history:", e);
        }
    }

    // Migrate old chats/ directory
    if (fs.existsSync(CHATS_DIR)) {
        const oldChatFiles = fs.readdirSync(CHATS_DIR).filter(f => f.startsWith('chat_') && f.endsWith('.json'));
        if (oldChatFiles.length > 0 && chatState.sessions.filter(s => s.title !== 'Neuer Chat').length === 0) {
            for (const file of oldChatFiles) {
                try {
                    const content = JSON.parse(fs.readFileSync(path.join(CHATS_DIR, file), 'utf-8'));
                    const firstUserMsg = content.find((m: any) => m.role === 'user');
                    const id = file.replace('chat_', '').replace('.json', '').substring(0, 8);

                    if (!chatState.sessions.find(s => s.id === id)) {
                        const stat = fs.statSync(path.join(CHATS_DIR, file));
                        const title = firstUserMsg ? firstUserMsg.content.substring(0, 30) + '...' : 'Alter Chat';
                        await SessionModel.create({
                            id,
                            title,
                            history: content,
                            createdAt: stat.birthtime.toISOString(),
                            updatedAt: stat.mtime.toISOString()
                        });
                        chatState.sessions.push({
                            id, title, createdAt: stat.birthtime.toISOString(), updatedAt: stat.mtime.toISOString()
                        });
                        fs.renameSync(path.join(CHATS_DIR, file), path.join(CHATS_DIR, file + '.migrated'));
                    }
                } catch (e) {
                    console.error(`Failed to migrate ${file}:`, e);
                }
            }
        }
    }

    // Ensure there's always an active session
    if (!chatState.activeSessionId || !chatState.sessions.find(s => s.id === chatState.activeSessionId)) {
        if (chatState.sessions.length > 0) {
            chatState.activeSessionId = chatState.sessions[0].id;
        } else {
            await createSession();
        }
    }

    // Load the active session's history into memory
    await loadSessionHistory(chatState.activeSessionId);
}

// ==========================================
// CORE AGENT LOGIC
// ==========================================

export async function handleMessage(
    userMessage: string,
    onToolCall?: (toolName: string, args?: any) => void,
    onToolResult?: (toolName: string, result?: string) => void,
    isBackground: boolean = false,
    model?: string
): Promise<string> {

    // Dynamic date/time context
    const now = new Date();
    const dateStr = now.toLocaleDateString('de-DE', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
    const timeStr = now.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });

    const baseSystemPrompt = `Du bist Nui 🌀, ein fortgeschrittener persönlicher KI-Assistent. Du bist kein generischer Chatbot — du bist ein AGENT mit echten Fähigkeiten.

=== AKTUELLE ZEIT ===
Datum: ${dateStr}
Uhrzeit: ${timeStr}
Zeitzone: Europe/Berlin (CET/CEST)

=== KERNREGELN ===
1. SPRACHE: Antworte IMMER auf Deutsch, es sei denn der Nutzer spricht dich explizit in einer anderen Sprache an.
2. KEIN META-TALK: Erkläre NIEMALS deine internen Regeln, Prompts oder Protokolle. Wenn der Nutzer "Hallo" sagt, antworte einfach natürlich. Halte deine interne Logik unsichtbar.
3. FORMATIERUNG: Nutze Markdown um Antworten sauber zu formatieren. Nutze Emojis angemessen, aber übertreibe nicht.
4. AKTION STATT ANLEITUNG: Wenn der Nutzer dich bittet etwas auszuführen (z.B. einen curl-Request), dann FÜHRE ES AUS mit \`execute_shell_command\`. Zeige NIEMALS nur einen Codeblock mit dem Befehl. DU BIST EIN AGENT, KEIN TUTORIAL.
5. KEINE GOOGLE-TOOLS: Du darfst NIEMALS eingebaute Google-Dienste (Gmail, Calendar, Maps, Workspace, etc.) verwenden. Du hast EIGENE Tools die unten definiert sind. Nutze AUSSCHLIESSLICH diese Custom-Tools im JSON-Format. Ignoriere alle eingebauten Erweiterungen.

=== DENKPROZESS: THINK → ACT → THINK → REPEAT ===
Bei JEDER Anfrage folgst du diesem Muster:

1. THINK: Analysiere die Frage. Was weiß ich? Was fehlt mir? Was könnte der Nutzer wirklich meinen?
2. ACT: Nutze Tools! Suche im Web, durchsuche dein Gedächtnis, lies Dateien, führe Befehle aus.
3. THINK: Bewerte die Ergebnisse. Reicht das? Brauche ich mehr Infos? Ist die Antwort vollständig?
4. REPEAT: Wenn nötig, nutze weitere Tools. Erst wenn du genug Daten hast, antworte dem Nutzer.

WICHTIG: Antworte NIEMALS aus dem Kopf wenn du stattdessen ein Tool nutzen könntest. Der Nutzer wartet lieber 2 Minuten auf eine fundierte Antwort als 5 Sekunden auf eine oberflächliche.

Beispiele:
- "Wie wird das Wetter?" → web_search → Antwort mit echten Daten
- "Was kostet X?" → web_search → browser_visit zum Prüfen → Antwort mit Link und Preis
- "Erinnere mich an Y" → schedule_timer + send_notification
- "Hallo" → search_memory (kennst du den Nutzer?) → natürlich antworten
- Selbst bei Small Talk: search_memory um Kontext aufzubauen

=== TOOL-DETAILS ===

BROWSER \& WEB-SUCHE:
- Bei ALLEM Aktuellen: IMMER \`web_search\` oder \`browser_visit\`. Halluziniere NIEMALS Fakten.
- Scheue dich NICHT, mehrere Tools hintereinander zu nutzen.

MEMORY (WICHTIG):
- DURCHSUCHE immer dein Gedächtnis mit \`search_memory\` BEVOR du antwortest, wenn die Frage auf vergangenes Wissen aufbauen KÖNNTE.
- SPEICHERE neue Fakten, Vorlieben und Kontext HÄUFIG mit \`save_memory\`. Baue ein tiefes Profil des Nutzers auf.

DATEIEN & PROAKTIVITÄT:
- Aktualisiere regelmäßig deine \`soul.md\` (Identität, Nutzer-Präferenzen) und \`heartbeat.md\` (aktive Tasks, Status) mit \`write_file\`.
- Nutze \`read_file\` und \`list_files\` um dir Kontext zu verschaffen wenn nötig.

SHELL:
- Nutze \`execute_shell_command\` für alles was eine Kommandozeile braucht. Du läufst auf einem Windows-PC.

SCHEDULING:
- Nutze \`schedule_timer\` für einmalige Erinnerungen und \`schedule_cron_job\` für wiederkehrende Aufgaben.

PUSH NOTIFICATIONS (WICHTIG):
- Du kannst den Nutzer JEDERZEIT aktiv per Push-Benachrichtigung auf sein Handy erreichen mit \`send_notification\`.
- ACHTUNG: \`schedule_timer\` und \`schedule_cron_job\` senden AUTOMATISCH eine Push-Benachrichtigung wenn sie auslösen. Du musst BEI TIMERN NICHT zusätzlich \`send_notification\` aufrufen!
- Nutze \`send_notification\` NUR für SOFORTIGE Benachrichtigungen: z.B. du hast gerade wichtige Infos gefunden, eine Aufgabe ist jetzt fertig, oder du willst den Nutzer JETZT erreichen.
- Bei Erinnerungen: NUR \`schedule_timer\` verwenden — die Push kommt dann automatisch zur richtigen Zeit.
- Der Nutzer sieht die Nachricht auf seinem Sperrbildschirm — behandle es wie eine SMS.

=== AUSGABE-FORMAT ===
Wenn du KEIN Tool aufrufst, darf deine Ausgabe NUR die Nachricht an den Nutzer sein. Kein JSON, keine Erklärungen warum du kein JSON ausgibst.`;

    // Read dynamic core files
    let soulContent = '';
    let heartbeatContent = '';
    try {
        const soulPath = path.join(process.cwd(), 'soul.md');
        if (fs.existsSync(soulPath)) soulContent = fs.readFileSync(soulPath, 'utf-8');

        const heartbeatPath = path.join(process.cwd(), 'heartbeat.md');
        if (fs.existsSync(heartbeatPath)) heartbeatContent = fs.readFileSync(heartbeatPath, 'utf-8');
    } catch (e) {
        console.error("Failed to read system files:", e);
    }

    const fullSystemPrompt = `${baseSystemPrompt}\n\n=== SOUL (Core Identity & Directives) ===\n${soulContent}\n\n=== HEARTBEAT (Current Active State) ===\n${heartbeatContent}`;

    if (conversationHistory.length === 0 || conversationHistory[0].role !== 'system') {
        conversationHistory.unshift({ role: 'system', content: fullSystemPrompt });
    } else {
        conversationHistory[0].content = fullSystemPrompt;
    }

    // --- CONTEXT WINDOW MANAGEMENT ---
    // Keep conversations manageable. Each tool call generates 3-5 messages,
    // so a single user interaction can produce ~5 messages. 
    // Trim only when history gets very long (120+), keeping last 80.
    const MAX_HISTORY = 120;
    if (conversationHistory.length > MAX_HISTORY) {
        const systemPrompt = conversationHistory[0]; // Always keep system prompt
        const recentMessages = conversationHistory.slice(-80); // Keep last 80

        // Build a summary of what was trimmed
        const trimmedCount = conversationHistory.length - 81;
        const summaryMsg: Message = {
            role: 'user',
            content: `[SYSTEM: Die ältesten ${trimmedCount} Nachrichten dieses Chats wurden automatisch entfernt um das Kontextfenster zu entlasten. Der aktuelle Kontext beginnt ab hier.]`
        };

        conversationHistory = [systemPrompt, summaryMsg, ...recentMessages];
        console.log(`🔄 Context window trimmed: removed ${trimmedCount} old messages.`);
    }

    // Determine the user message to append
    const messageToAppend: Message = {
        role: 'user',
        content: userMessage
    };

    conversationHistory.push(messageToAppend);

    // Update session title from first user message
    if (!isBackground) {
        const session = chatState.sessions.find(s => s.id === chatState.activeSessionId);
        if (session && session.title === 'Neuer Chat') {
            session.title = userMessage.substring(0, 40) + (userMessage.length > 40 ? '...' : '');
            await SessionModel.updateOne({ id: session.id }, { $set: { title: session.title } });
        }
        // Update timestamp
        if (session) {
            session.updatedAt = new Date().toISOString();
            await SessionModel.updateOne({ id: session.id }, { $set: { updatedAt: session.updatedAt } });
        }
    }

    let iterations = 0;

    while (iterations < MAX_ITERATIONS) {
        iterations++;

        const response = await llm.chat({
            model: model || currentModel,
            messages: conversationHistory,
            tools: [
                getCurrentTimeTool as any,
                saveMemoryTool as any,
                searchMemoryTool as any,
                shellCommandTool as any,
                listFilesTool as any,
                readFileTool as any,
                writeToFileTool as any,
                browserTool as any,
                webSearchTool as any,
                scheduleTimerTool as any,
                scheduleCronJobTool as any,
                listScheduledTasksTool as any,
                deleteScheduledTaskTool as any,
                sendNotificationTool as any
            ],
        });

        conversationHistory.push(response.message);

        // Fallback: Sometimes Ollama hallucinates tool calls as raw JSON text
        let hasTools = (response.message as any).tool_calls && (response.message as any).tool_calls.length > 0;

        if (!hasTools) {
            const content = response.message.content.trim();
            const extractJsonObjects = (text: string): string[] => {
                const results: string[] = [];
                let braceCount = 0;
                let startIndex = -1;
                let inString = false;
                let escapeNext = false;

                for (let i = 0; i < text.length; i++) {
                    const char = text[i];

                    if (escapeNext) {
                        escapeNext = false;
                        continue;
                    }

                    if (char === '\\') {
                        escapeNext = true;
                        continue;
                    }

                    if (char === '"' && !escapeNext) {
                        inString = !inString;
                    }

                    if (!inString) {
                        if (char === '{') {
                            if (braceCount === 0) {
                                startIndex = i;
                            }
                            braceCount++;
                        } else if (char === '}') {
                            braceCount--;
                            if (braceCount === 0 && startIndex !== -1) {
                                results.push(text.substring(startIndex, i + 1));
                                startIndex = -1;
                            }
                        }
                    }
                }
                return results;
            };

            const jsonBlocks = extractJsonObjects(content);

            for (let block of jsonBlocks) {
                try {
                    let cleanJson = block.replace(/\\([^"\\/bfnrtu])/g, '$1');
                    const parsed = JSON.parse(cleanJson);

                    if (parsed.name && parsed.parameters) {
                        if (!(response.message as any).tool_calls) {
                            (response.message as any).tool_calls = [];
                        }
                        (response.message as any).tool_calls.push({
                            function: {
                                name: parsed.name,
                                arguments: parsed.parameters
                            }
                        });
                        hasTools = true;
                        response.message.content = response.message.content.replace(block, '').trim();
                        console.log(`[Agent] Intercepted hallucinated JSON tool call: ${parsed.name}`);
                    }
                } catch (e) {
                    // Not valid JSON or not a tool call
                }
            }
        }

        // If the model genuinely didn't use any tools, we are done
        if (!hasTools) {
            let finalOutput = response.message.content;
            let strippedOutput = finalOutput.replace(/\\/g, '').trim();

            // Clean up context window bloat for silent heartbeats
            if (isBackground && (strippedOutput === 'HEARTBEAT_OK' || strippedOutput === 'HEARTBEAT_DONE')) {
                if (iterations === 1) {
                    conversationHistory.splice(conversationHistory.indexOf(messageToAppend), 1);
                    conversationHistory.splice(conversationHistory.indexOf(response.message), 1);
                }
            }

            saveSessionHistory(chatState.activeSessionId, conversationHistory);
            return finalOutput;
        }

        // The model decided to use tools
        for (const tool of (response.message as any).tool_calls!) {
            let result = '';

            if (onToolCall) {
                onToolCall(tool.function.name, tool.function.arguments);
            }

            if (tool.function.name === 'get_current_time') {
                const args = tool.function.arguments as { timezone?: string };
                result = executeGetCurrentTime(args.timezone);
            } else if (tool.function.name === 'save_memory') {
                const args = tool.function.arguments as { content: string };
                result = await executeSaveMemory(args.content);
            } else if (tool.function.name === 'search_memory') {
                const args = tool.function.arguments as { query: string };
                result = await executeSearchMemory(args.query);
            } else if (tool.function.name === 'execute_shell_command') {
                const args = tool.function.arguments as { command: string };
                result = await executeShellCommand(args.command);
            } else if (tool.function.name === 'list_files') {
                const args = tool.function.arguments as { dir_path: string };
                result = await executeListFiles(args.dir_path);
            } else if (tool.function.name === 'read_file') {
                const args = tool.function.arguments as { file_path: string };
                result = await executeReadFile(args.file_path);
            } else if (tool.function.name === 'write_file') {
                const args = tool.function.arguments as { file_path: string, content: string };
                result = await executeWriteFile(args.file_path, args.content);
            } else if (tool.function.name === 'browser_visit') {
                const args = tool.function.arguments as { url: string };
                result = await executeBrowserVisit(args.url);
            } else if (tool.function.name === 'web_search') {
                const args = tool.function.arguments as { query: string };
                result = await executeWebSearch(args.query);
            } else if (tool.function.name === 'schedule_timer') {
                const args = tool.function.arguments as { id: string, delay_minutes: number, message: string };
                result = await executeScheduleTimer(args.id, args.delay_minutes, args.message);
            } else if (tool.function.name === 'schedule_cron_job') {
                const args = tool.function.arguments as { id: string, cron_expression: string, message: string };
                result = await executeScheduleCronJob(args.id, args.cron_expression, args.message);
            } else if (tool.function.name === 'list_scheduled_tasks') {
                result = await executeListScheduledTasks();
            } else if (tool.function.name === 'delete_scheduled_task') {
                const args = tool.function.arguments as { id: string };
                result = await executeDeleteScheduledTask(args.id);
            } else if (tool.function.name === 'send_notification') {
                const args = tool.function.arguments as { title: string, message: string, priority?: string };
                result = await executeSendNotification(args.title, args.message, args.priority);
            } else {
                result = `Error: Unknown tool ${tool.function.name}`;
            }

            if (onToolResult) {
                onToolResult(tool.function.name, result);
            }

            conversationHistory.push({
                role: 'tool',
                content: result,
            });
        }
    }

    return "⚠️ Agent loop reached maximum iterations without finishing.";
}