keep/src/services/item_service.rs

use crate::common::PIPESIZE;
use crate::config::Settings;
use crate::services::compression_service::CompressionService;
use crate::services::error::CoreError;
use crate::services::meta_service::MetaService;
use crate::services::types::{ItemWithContent, ItemWithMeta};
use crate::meta_plugin::{get_meta_plugin, MetaPlugin, MetaPluginType};
use crate::db::{self, Meta};
use crate::compression_engine::{get_compression_engine, CompressionType};
use crate::modes::common::settings_compression_type;
use clap::Command;
use log::{debug, warn};
use rusqlite::Connection;
use std::collections::HashMap;
use std::fs;
use std::io::{IsTerminal, Read, Write};
use std::path::PathBuf;

pub struct ItemService {
    data_path: PathBuf,
    compression_service: CompressionService,
    meta_service: MetaService,
}

impl ItemService {
    pub fn new(data_path: PathBuf) -> Self {
        debug!("ITEM_SERVICE: Creating new ItemService with data_path: {:?}", data_path);
        Self {
            data_path,
            compression_service: CompressionService::new(),
            meta_service: MetaService::new(),
        }
    }

    pub fn get_item(&self, conn: &Connection, id: i64) -> Result<ItemWithMeta, CoreError> {
        debug!("ITEM_SERVICE: Getting item with id: {}", id);
        let item = db::get_item(conn, id)?.ok_or(CoreError::ItemNotFound(id))?;
        debug!("ITEM_SERVICE: Found item: {:?}", item);
        let tags = db::get_item_tags(conn, &item)?;
        debug!("ITEM_SERVICE: Found {} tags for item {}", tags.len(), id);
        let meta = db::get_item_meta(conn, &item)?;
        debug!("ITEM_SERVICE: Found {} meta entries for item {}", meta.len(), id);
        Ok(ItemWithMeta { item, tags, meta })
    }

    pub fn get_item_content(&self, conn: &Connection, id: i64) -> Result<ItemWithContent, CoreError> {
        debug!("ITEM_SERVICE: Getting item content for id: {}", id);
        let item_with_meta = self.get_item(conn, id)?;
        let item_id = item_with_meta.item.id.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;

        if item_id <= 0 {
            return Err(CoreError::InvalidInput(format!("Invalid item ID: {}", item_id)));
        }

        let mut item_path = self.data_path.clone();
        item_path.push(item_id.to_string());
        debug!("ITEM_SERVICE: Reading content from path: {:?}", item_path);

        let content = self
            .compression_service
            .get_item_content(item_path, &item_with_meta.item.compression)?;
        debug!("ITEM_SERVICE: Read {} bytes of content for item {}", content.len(), id);

        Ok(ItemWithContent {
            item_with_meta,
            content,
        })
    }

    pub fn get_item_content_info(&self, conn: &Connection, id: i64) -> Result<(Vec<u8>, String, bool), CoreError> {
        let item_with_content = self.get_item_content(conn, id)?;
        let metadata = item_with_content.item_with_meta.meta_as_map();

        let mime_type = metadata
            .get("mime_type")
            .map(|s| s.to_string())
            .unwrap_or_else(|| "application/octet-stream".to_string());

        // Check if content is binary
        let is_binary = if let Some(binary_val) = metadata.get("binary") {
            binary_val == "true"
        } else {
            crate::common::is_binary::is_binary(&item_with_content.content)
        };

        Ok((item_with_content.content, mime_type, is_binary))
    }

    pub fn get_item_content_info_streaming(
        &self,
        conn: &Connection,
        id: i64,
    ) -> Result<(Box<dyn Read + Send>, String, bool), CoreError> {
        let item_with_meta = self.get_item(conn, id)?;
        let item_id = item_with_meta.item.id.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;

        if item_id <= 0 {
            return Err(CoreError::InvalidInput(format!("Invalid item ID: {}", item_id)));
        }

        let mut item_path = self.data_path.clone();
        item_path.push(item_id.to_string());

        let reader = self.compression_service.stream_item_content(item_path.clone(), &item_with_meta.item.compression)?;

        let metadata = item_with_meta.meta_as_map();
        let mime_type = metadata
            .get("mime_type")
            .map(|s| s.to_string())
            .unwrap_or_else(|| "application/octet-stream".to_string());

        // Check if content is binary using only the first 8192 bytes
        let is_binary = if let Some(binary_val) = metadata.get("binary") {
            binary_val == "true"
        } else {
            // Read only the first 8192 bytes for binary detection
            let mut sample_reader = self.compression_service.stream_item_content(
                item_path,
                &item_with_meta.item.compression
            )?;
            let mut sample_buffer = vec![0; 8192];
            let bytes_read = sample_reader.read(&mut sample_buffer)?;
            crate::common::is_binary::is_binary(&sample_buffer[..bytes_read])
        };

        Ok((reader, mime_type, is_binary))
    }

    pub fn find_item(&self, conn: &Connection, ids: &[i64], tags: &[String], meta: &HashMap<String, String>) -> Result<ItemWithMeta, CoreError> {
        debug!("ITEM_SERVICE: Finding item with ids: {:?}, tags: {:?}, meta: {:?}", ids, tags, meta);
        let item_maybe = match (ids.is_empty(), tags.is_empty() && meta.is_empty()) {
            (false, _) => {
                debug!("ITEM_SERVICE: Finding by ID: {}", ids[0]);
                db::get_item(conn, ids[0])?
            },
            (true, true) => {
                debug!("ITEM_SERVICE: Finding last item");
                db::get_item_last(conn)?
            },
            (true, false) => {
                debug!("ITEM_SERVICE: Finding by tags/meta");
                db::get_item_matching(conn, &tags.to_vec(), meta)?
            }
        };

        let item = item_maybe.ok_or(CoreError::ItemNotFoundGeneric)?;
        debug!("ITEM_SERVICE: Found matching item: {:?}", item);

        // Get tags and meta directly instead of calling get_item which makes redundant queries
        let item_id = item.id.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;
        let tags = db::get_item_tags(conn, &item)?;
        debug!("ITEM_SERVICE: Found {} tags for item {}", tags.len(), item_id);
        let meta = db::get_item_meta(conn, &item)?;
        debug!("ITEM_SERVICE: Found {} meta entries for item {}", meta.len(), item_id);

        Ok(ItemWithMeta { item, tags, meta })
    }

    pub fn list_items(&self, conn: &Connection, tags: &[String], meta: &HashMap<String, String>) -> Result<Vec<ItemWithMeta>, CoreError> {
        debug!("ITEM_SERVICE: Listing items with tags: {:?}, meta: {:?}", tags, meta);
        let items = db::get_items_matching(conn, &tags.to_vec(), meta)?;
        debug!("ITEM_SERVICE: Found {} matching items", items.len());

        let item_ids: Vec<i64> = items.iter().filter_map(|item| item.id).collect();
        if item_ids.is_empty() {
            debug!("ITEM_SERVICE: No items found, returning empty list");
            return Ok(Vec::new());
        }

        debug!("ITEM_SERVICE: Getting tags and meta for {} items", item_ids.len());
        let tags_map = db::get_tags_for_items(conn, &item_ids)?;
        let meta_map_db = db::get_meta_for_items(conn, &item_ids)?;

        let mut result = Vec::new();
        for item in items {
            let item_id = item.id.unwrap();
            let tags = tags_map.get(&item_id).cloned().unwrap_or_default();
            let meta_hm = meta_map_db.get(&item_id).cloned().unwrap_or_default();
            let meta = meta_hm.into_iter().map(|(name, value)| Meta { id: item_id, name, value }).collect();

            result.push(ItemWithMeta { item, tags, meta });
        }

        debug!("ITEM_SERVICE: Returning {} items with full metadata", result.len());
        Ok(result)
    }

    pub fn delete_item(&self, conn: &mut Connection, id: i64) -> Result<(), CoreError> {
        debug!("ITEM_SERVICE: Deleting item with id: {}", id);
        if id <= 0 {
            return Err(CoreError::InvalidInput(format!("Invalid item ID: {}", id)));
        }
        let item = db::get_item(conn, id)?.ok_or(CoreError::ItemNotFound(id))?;
        debug!("ITEM_SERVICE: Found item to delete: {:?}", item);

        let mut item_path = self.data_path.clone();
        item_path.push(id.to_string());
        debug!("ITEM_SERVICE: Deleting file at path: {:?}", item_path);

        let tx = conn.transaction()?;
        db::delete_item(&tx, item)?;
        fs::remove_file(&item_path).or_else(|e| if e.kind() == std::io::ErrorKind::NotFound { Ok(()) } else { Err(e) })?;
        tx.commit()?;
        debug!("ITEM_SERVICE: Successfully deleted item {}", id);

        Ok(())
    }

    pub fn save_item<R: Read>(
        &self,
        mut input: R,
        cmd: &mut Command,
        settings: &Settings,
        tags: &mut Vec<String>,
        conn: &mut Connection,
    ) -> Result<i64, CoreError> {
        debug!("ITEM_SERVICE: Starting save_item with tags: {:?}", tags);
        if tags.is_empty() {
             tags.push("none".to_string());
             debug!("ITEM_SERVICE: No tags provided, using default 'none' tag");
        }

        let compression_type = settings_compression_type(cmd, settings);
        debug!("ITEM_SERVICE: Using compression type: {:?}", compression_type);
        let compression_engine = get_compression_engine(compression_type.clone())?;

        let tx = conn.transaction()?;

        let item_id;
        let mut item;
        {
            item = db::create_item(&tx, compression_type.clone())?;
            item_id = item.id.unwrap();
            debug!("ITEM_SERVICE: Created new item with id: {}", item_id);
            db::set_item_tags(&tx, item.clone(), tags)?;
            debug!("ITEM_SERVICE: Set tags for item {}", item_id);
            let item_meta = self.meta_service.collect_initial_meta();
            debug!("ITEM_SERVICE: Collected {} initial meta entries", item_meta.len());
            for (k, v) in item_meta.iter() {
               db::add_meta(&tx, item_id, k, v)?;
            }
        }

        // Print the "KEEP: New item" message before starting to read input
        if !settings.quiet {
            if std::io::stderr().is_terminal() {
                let mut t = term::stderr().unwrap();
                let _ = t.reset();
                let _ = t.attr(term::Attr::Bold);
                let _ = write!(t, "KEEP:");
                let _ = t.reset();
                let _ = write!(t, " New item ");
                let _ = t.attr(term::Attr::Bold);
                let _ = write!(t, "{item_id}");
                let _ = t.reset();
                let _ = write!(t, "  tags: ");
                let _ = t.attr(term::Attr::Bold);
                let _ = write!(t, "{}", tags.join(" "));
                let _ = t.reset();
                let _ = writeln!(t);
                let _ = std::io::stderr().flush();
            } else {
                let mut t = std::io::stderr();
                let _ = writeln!(t, "KEEP: New item: {}  tags: {:?}", item_id, tags);
            }
        }

        let mut plugins = self.meta_service.get_plugins(cmd, settings);
        debug!("ITEM_SERVICE: Got {} meta plugins", plugins.len());
        self.meta_service.initialize_plugins(&mut plugins, &tx, item_id);

        let mut item_path = self.data_path.clone();
        item_path.push(item_id.to_string());
        debug!("ITEM_SERVICE: Writing item to path: {:?}", item_path);

        let mut item_out = compression_engine.create(item_path.clone())?;

        let mut buffer = [0; PIPESIZE];
        let mut total_bytes = 0;

        debug!("ITEM_SERVICE: Starting to read and process input data");
        loop {
            let n = input.read(&mut buffer)?;
            if n == 0 { break; }

            total_bytes += n as i64;
            item_out.write_all(&buffer[..n])?;
            self.meta_service.process_chunk(&mut plugins, &buffer[..n], &tx, item_id);
        }
        debug!("ITEM_SERVICE: Processed {} bytes total", total_bytes);

        item_out.flush()?;
        drop(item_out);

        debug!("ITEM_SERVICE: Finalizing meta plugins");
        self.meta_service.finalize_plugins(&mut plugins, &tx, item_id);

        item.size = Some(total_bytes);
        db::update_item(&tx, item.clone())?;

        tx.commit()?;
        debug!("ITEM_SERVICE: Transaction committed successfully");

        Ok(item_id)
    }

    pub fn save_item_from_mcp(
        &self,
        content: &[u8],
        tags: &Vec<String>,
        metadata: &HashMap<String, String>,
        conn: &mut Connection,
    ) -> Result<ItemWithMeta, CoreError> {
        debug!("ITEM_SERVICE: Starting save_item_from_mcp with {} bytes, {} tags, {} metadata entries",
               content.len(), tags.len(), metadata.len());
        let compression_type = CompressionType::LZ4;
        let compression_engine = get_compression_engine(compression_type.clone())?;

        let tx = conn.transaction()?;
        let item_id;
        let mut item;

        {
            item = db::create_item(&tx, compression_type.clone())?;
            item_id = item.id.unwrap();
            debug!("ITEM_SERVICE: Created MCP item with id: {}", item_id);

            // Add tags
            for tag in tags {
                db::add_tag(&tx, item_id, tag)?;
            }
            debug!("ITEM_SERVICE: Added {} tags to MCP item", tags.len());

            // Add custom metadata
            for (key, value) in metadata {
                db::add_meta(&tx, item_id, key, value)?;
            }
            debug!("ITEM_SERVICE: Added {} custom metadata entries to MCP item", metadata.len());
        }

        let mut item_path = self.data_path.clone();
        item_path.push(item_id.to_string());
        debug!("ITEM_SERVICE: Writing MCP item to path: {:?}", item_path);

        let mut writer = compression_engine.create(item_path.clone())?;
        writer.write_all(content)?;
        drop(writer);

        let plugin_types = vec![
            MetaPluginType::FileMime,
            MetaPluginType::FileEncoding,
            MetaPluginType::Binary,
            MetaPluginType::LineCount,
            MetaPluginType::WordCount,
            MetaPluginType::DigestSha256,
            MetaPluginType::User,
            MetaPluginType::Hostname,
        ];

        let mut plugins: Vec<Box<dyn MetaPlugin>> =
            plugin_types.iter().map(|p| get_meta_plugin(p.clone())).collect();
        debug!("ITEM_SERVICE: Created {} meta plugins for MCP item", plugins.len());

        self.meta_service
            .initialize_plugins(&mut plugins, &tx, item_id);
        self.meta_service
            .process_chunk(&mut plugins, content, &tx, item_id);
        self.meta_service.finalize_plugins(&mut plugins, &tx, item_id);
        debug!("ITEM_SERVICE: Processed MCP item through meta plugins");

        item.size = Some(content.len() as i64);
        db::update_item(&tx, item.clone())?;

        tx.commit()?;
        debug!("ITEM_SERVICE: MCP item transaction committed successfully");

        self.get_item(conn, item_id)
    }

    pub fn get_compression_service(&self) -> &CompressionService {
        &self.compression_service
    }

    pub fn get_data_path(&self) -> &PathBuf {
        &self.data_path
    }
}