goosedump 0.1.2

// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) Jarkko Sakkinen 2026

use crate::context::ContextReader;
use crate::message::{
    AssistantResponse, Context, ContextListing, ConversationMessage, MessageKind, TextContent,
    ToolCall,
};
use anyhow::Context as _;
use rusqlite::Connection;
use serde_json::Value;
use std::path::PathBuf;

pub struct CrushReader {
    db_path: PathBuf,
}

impl CrushReader {
    pub fn new(db_path: PathBuf) -> Self {
        Self { db_path }
    }
}

impl ContextReader for CrushReader {
    fn list_contexts(&self) -> anyhow::Result<Vec<ContextListing>> {
        let conn = Connection::open(&self.db_path)
            .with_context(|| format!("failed to open crush db at {}", self.db_path.display()))?;

        let sql = "SELECT session_id, COUNT(*) FROM messages GROUP BY session_id";
        let mut stmt = conn.prepare(sql)?;
        let rows = stmt.query_map([], |row| {
            Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
        })?;

        let mut contexts = Vec::new();
        for row in rows {
            let (session_id, count) = row?;
            let detail = format!("{count} messages");
            contexts.push(ContextListing {
                id: session_id,
                detail,
                path: Some(self.db_path.clone()),
            });
        }
        Ok(contexts)
    }

    fn read_context(&self, context_id: &str) -> anyhow::Result<Context> {
        let conn = Connection::open(&self.db_path)
            .with_context(|| format!("failed to open crush db at {}", self.db_path.display()))?;

        let sql = "SELECT role, parts FROM messages WHERE session_id = ?1 ORDER BY created_at";
        let mut stmt = conn.prepare(sql)?;
        let rows = stmt.query_map(rusqlite::params![context_id], |row| {
            Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
        })?;

        let mut messages = Vec::new();
        for (idx, row) in rows.enumerate() {
            let (role, parts_str) = row?;

            let parts: Value = serde_json::from_str(&parts_str)?;

            let kind = crush_build_message_kind(&role, &parts)?;

            let entry_id = format!("crush-{idx}");
            messages.push(ConversationMessage { entry_id, kind });
        }

        Ok(Context {
            path: self.db_path.clone(),
            entries: Vec::new(),
            messages,
        })
    }
}

fn crush_build_message_kind(role: &str, parts: &Value) -> anyhow::Result<MessageKind> {
    let parts = parts.as_array().context("parts is not an array")?;

    match role {
        "user" => {
            let text: String = parts
                .iter()
                .filter(|p| p["type"].as_str() == Some("text"))
                .map(|p| p["text"].as_str().unwrap_or("").to_string())
                .collect::<Vec<_>>()
                .join("\n");
            Ok(MessageKind::TextContent(TextContent {
                role: "user".to_string(),
                text,
            }))
        }
        "assistant" => {
            let mut text = String::new();
            let mut tool_calls = Vec::new();
            let mut tool_results = Vec::new();

            for part in parts {
                match part["type"].as_str() {
                    Some("text") => {
                        if let Some(t) = part["text"].as_str() {
                            text.push_str(t);
                        }
                    }
                    Some("tool_use") => {
                        let name = part["name"].as_str().unwrap_or("").to_string();
                        let arguments = part.get("input").cloned().unwrap_or(Value::Null);
                        tool_calls.push(ToolCall { name, arguments });
                        if let Some(res) = part["result"].as_str() {
                            tool_results.push(format!("[tool_result] {res}"));
                        }
                    }
                    Some("tool_result") => {
                        if let Some(content) = part["content"].as_str() {
                            tool_results.push(format!("[tool_result] {content}"));
                        }
                    }
                    _ => {}
                }
            }

            if !tool_results.is_empty() {
                if !text.is_empty() {
                    text.push('\n');
                }
                text.push_str(&tool_results.join("\n"));
            }

            Ok(MessageKind::AssistantResponse(AssistantResponse {
                thinking: Vec::new(),
                tool_calls,
                text,
            }))
        }
        _ => {
            let text: String = parts
                .iter()
                .filter(|p| p["type"].as_str() == Some("text"))
                .map(|p| p["text"].as_str().unwrap_or("").to_string())
                .collect::<Vec<_>>()
                .join("\n");
            Ok(MessageKind::TextContent(TextContent {
                role: role.to_string(),
                text,
            }))
        }
    }
}