use anyhow::Result;
use magic::{Cookie, CookieFlags};
use std::io;
use rusqlite::Connection;

use crate::meta_plugin::MetaPlugin;

#[derive(Debug)]
pub struct MagicFileMetaPlugin {
    buffer: Vec<u8>,
    max_buffer_size: usize,
    is_saved: bool,
    item_id: Option<i64>,
    conn: Option<*mut Connection>,
    cookie: Option<Cookie>,
}

impl MagicFileMetaPlugin {
    pub fn new() -> MagicFileMetaPlugin {
        MagicFileMetaPlugin {
            buffer: Vec::new(),
            max_buffer_size: 4096, // Same as BinaryMetaPlugin
            is_saved: false,
            item_id: None,
            conn: None,
            cookie: None,
        }
    }

    fn get_magic_result(&self, flags: CookieFlags) -> io::Result<String> {
        if let Some(ref cookie) = self.cookie {
            let result = cookie.buffer(&self.buffer)
                .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("Failed to analyze buffer: {}", e)))?;

            // Clean up the result - remove extra whitespace and take first part if needed
            let trimmed = result.trim();
            
            // For some magic results, we might want just the first part before semicolon or comma
            let cleaned = if trimmed.contains(';') {
                trimmed.split(';').next().unwrap_or(trimmed).trim()
            } else if trimmed.contains(',') && flags.contains(CookieFlags::MIME_TYPE | CookieFlags::MIME_ENCODING) {
                trimmed.split(',').next().unwrap_or(trimmed).trim()
            } else {
                trimmed
            };

            Ok(cleaned.to_string())
        } else {
            Err(io::Error::new(
                io::ErrorKind::Other,
                "Magic cookie not initialized".to_string(),
            ))
        }
    }

    fn save_all_magic_metadata(&mut self) -> Result<()> {
        if let (Some(conn), Some(item_id)) = (self.conn, self.item_id) {
            let conn = unsafe { &*conn };
            
            // Save file type
            if let Ok(file_type) = self.get_magic_result(CookieFlags::empty()) {
                let meta = crate::db::Meta {
                    id: item_id,
                    name: "magic_file_type".to_string(),
                    value: file_type,
                };
                crate::db::store_meta(conn, meta)?;
            }
            
            // Save MIME type
            if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
                let meta = crate::db::Meta {
                    id: item_id,
                    name: "magic_mime_type".to_string(),
                    value: mime_type,
                };
                crate::db::store_meta(conn, meta)?;
            }
            
            // Save MIME encoding
            if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
                let meta = crate::db::Meta {
                    id: item_id,
                    name: "magic_mime_encoding".to_string(),
                    value: mime_encoding,
                };
                crate::db::store_meta(conn, meta)?;
            }
            
            self.is_saved = true;
        }
        Ok(())
    }
}

impl MetaPlugin for MagicFileMetaPlugin {
    fn is_internal(&self) -> bool {
        true
    }
    
    fn initialize(&mut self, conn: &Connection, item_id: i64) -> Result<()> {
        self.item_id = Some(item_id);
        self.conn = Some(conn as *const Connection as *mut Connection);
        
        // Initialize magic cookie
        let cookie = Cookie::open(CookieFlags::empty())
            .map_err(|e| anyhow::anyhow!("Failed to open magic cookie: {}", e))?;
        cookie.load(&[] as &[&str])
            .map_err(|e| anyhow::anyhow!("Failed to load magic database: {}", e))?;
        self.cookie = Some(cookie);
        
        Ok(())
    }

    fn finalize(&mut self) -> io::Result<String> {
        // Save all magic metadata if not already saved
        if !self.is_saved {
            if let Err(e) = self.save_all_magic_metadata() {
                return Err(io::Error::new(io::ErrorKind::Other, format!("Failed to save magic metadata: {}", e)));
            }
        }
        // Return empty string since we save during finalize
        Ok("".to_string())
    }

    fn update(&mut self, data: &[u8]) {
        // Only collect up to max_buffer_size
        let remaining_capacity = self.max_buffer_size.saturating_sub(self.buffer.len());
        if remaining_capacity > 0 {
            let bytes_to_copy = std::cmp::min(data.len(), remaining_capacity);
            self.buffer.extend_from_slice(&data[..bytes_to_copy]);
            
            // Check if we've reached our buffer limit and save if so
            if self.buffer.len() >= self.max_buffer_size && !self.is_saved {
                if let (Some(_conn), Some(_item_id)) = (self.conn, self.item_id) {
                    if let Err(e) = self.save_all_magic_metadata() {
                        eprintln!("Warning: Failed to save magic metadata early: {}", e);
                    }
                }
            }
        }
    }

    fn meta_name(&mut self) -> String {
        "magic_file".to_string()
    }
}