use anyhow::Result;
use gethostname::gethostname;
use local_ip_address::local_ip;
use dns_lookup::lookup_addr;
use std::io;
use std::io::Write;
use std::env;
use std::process;
use uzers::{get_current_uid, get_current_gid, get_current_username, get_current_groupname};

use crate::meta_plugin::MetaPlugin;

#[derive(Debug, Clone, Default)]
pub struct CwdMetaPlugin {
    meta_name: String,
}

#[derive(Debug, Clone, Default)]
pub struct BinaryMetaPlugin {
    meta_name: String,
    buffer: Vec<u8>,
    max_buffer_size: usize,
}

impl BinaryMetaPlugin {
    pub fn new() -> BinaryMetaPlugin {
        BinaryMetaPlugin {
            meta_name: "binary".to_string(),
            buffer: Vec::new(),
            max_buffer_size: 4096, // 4KB
        }
    }
    
    /// Detect if data is binary or text
    /// Returns true if data is likely binary, false if likely text
    fn is_binary(data: &[u8]) -> bool {
        if data.is_empty() {
            return false;
        }
        
        // Check if it's valid UTF-8
        if std::str::from_utf8(data).is_ok() {
            // Valid UTF-8, but might still be binary
            // Check if it's UTF-16
            if data.len() >= 2 {
                // Check for BOM
                if (data[0] == 0xFF && data[1] == 0xFE) || (data[0] == 0xFE && data[1] == 0xFF) {
                    // UTF-16 with BOM is text
                    return false;
                }
            }
            
            // Count printable characters
            let printable_count = data.iter().filter(|&&b| {
                b.is_ascii_alphanumeric() || 
                b.is_ascii_punctuation() || 
                b.is_ascii_whitespace() ||
                b == b' ' || b == b'\t' || b == b'\n' || b == b'\r'
            }).count();
            
            // If less than 70% of bytes are printable, consider it binary
            let printable_ratio = printable_count as f64 / data.len() as f64;
            return printable_ratio < 0.7;
        } else {
            // Not valid UTF-8, likely binary
            // But check if it might be UTF-16 without BOM
            if data.len() >= 2 && data.len() % 2 == 0 {
                // Check if it looks like UTF-16 (every other byte is 0)
                let mut zero_count = 0;
                for (i, &byte) in data.iter().enumerate() {
                    if i % 2 == 1 && byte == 0 {
                        zero_count += 1;
                    }
                }
                // If more than 50% of odd positions are zero, might be UTF-16
                if zero_count as f64 / (data.len() / 2) as f64 > 0.5 {
                    return false; // Likely UTF-16 text
                }
            }
            
            // Check for common binary file signatures
            if data.len() >= 4 {
                // Check for common binary file headers
                let headers = [
                    // Image formats
                    &[0x89, 0x50, 0x4E, 0x47], // PNG
                    &[0xFF, 0xD8, 0xFF, 0xE0], // JPEG
                    &[0x47, 0x49, 0x46, 0x38], // GIF
                    &[0x42, 0x4D],             // BMP
                    // Document formats
                    &[0x25, 0x50, 0x44, 0x46], // PDF
                    // Archive formats
                    &[0x50, 0x4B, 0x03, 0x04], // ZIP
                    &[0x52, 0x61, 0x72, 0x21], // RAR
                    &[0x1F, 0x8B],             // GZIP
                    &[0x42, 0x5A, 0x68],       // BZIP2
                    &[0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00], // XZ
                    // TAR has no magic number, but we can check for common patterns
                    // Executables and object files
                    &[0x7F, 0x45, 0x4C, 0x46], // ELF
                    &[0x4D, 0x5A],             // Windows PE
                    // Compressed formats
                    &[0x1F, 0x9D],             // LZW compressed
                    &[0x1F, 0xA0],             // LZH compressed
                ];
                
                for header in &headers {
                    if data.starts_with(header) {
                        return true; // Definitely binary
                    }
                }
                
                // Special case for TAR files (no consistent magic number)
                // Check if it looks like a TAR header
                if data.len() >= 512 {
                    // TAR headers have specific structure
                    // First 100 bytes are filename (null-terminated)
                    // Next 8 bytes are file mode (octal, null-terminated)
                    // If we see this pattern, it's likely a TAR file
                    let has_tar_structure = 
                        data[0] != 0 && // First byte of filename should not be null
                        data[100] == 0 && // File mode should start with null
                        data[101] >= b'0' && data[101] <= b'7'; // File mode should be octal digit
                    
                    if has_tar_structure {
                        return true;
                    }
                }
            }
            
            // Check for AR format (used for static libraries)
            if data.len() >= 8 && &data[0..8] == b"!<arch>\n" {
                return true;
            }
            
            // Count printable characters as a fallback
            let printable_count = data.iter().filter(|&&b| {
                b.is_ascii_alphanumeric() || 
                b.is_ascii_punctuation() || 
                b.is_ascii_whitespace() ||
                b == b' ' || b == b'\t' || b == b'\n' || b == b'\r'
            }).count();
            
            // If less than 30% of bytes are printable, consider it binary
            let printable_ratio = printable_count as f64 / data.len() as f64;
            printable_ratio < 0.3
        }
    }
}

impl MetaPlugin for BinaryMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        let is_binary = Self::is_binary(&self.buffer);
        Ok(if is_binary { "true".to_string() } else { "false".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]);
        }
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

impl CwdMetaPlugin {
    pub fn new() -> CwdMetaPlugin {
        CwdMetaPlugin {
            meta_name: "cwd".to_string(),
        }
    }
}

impl MetaPlugin for CwdMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match env::current_dir() {
            Ok(path) => Ok(path.to_string_lossy().to_string()),
            Err(_) => Ok("unknown".to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct UidMetaPlugin {
    meta_name: String,
}

impl UidMetaPlugin {
    pub fn new() -> UidMetaPlugin {
        UidMetaPlugin {
            meta_name: "uid".to_string(),
        }
    }
}

impl MetaPlugin for UidMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        Ok(get_current_uid().to_string())
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct UserMetaPlugin {
    meta_name: String,
}

impl UserMetaPlugin {
    pub fn new() -> UserMetaPlugin {
        UserMetaPlugin {
            meta_name: "user".to_string(),
        }
    }
}

impl MetaPlugin for UserMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match get_current_username() {
            Some(username) => Ok(username.to_string_lossy().to_string()),
            None => Ok("unknown".to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct GidMetaPlugin {
    meta_name: String,
}

impl GidMetaPlugin {
    pub fn new() -> GidMetaPlugin {
        GidMetaPlugin {
            meta_name: "gid".to_string(),
        }
    }
}

impl MetaPlugin for GidMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        Ok(get_current_gid().to_string())
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct GroupMetaPlugin {
    meta_name: String,
}

impl GroupMetaPlugin {
    pub fn new() -> GroupMetaPlugin {
        GroupMetaPlugin {
            meta_name: "group".to_string(),
        }
    }
}

impl MetaPlugin for GroupMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match get_current_groupname() {
            Some(groupname) => Ok(groupname.to_string_lossy().to_string()),
            None => Ok("unknown".to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct ShellMetaPlugin {
    meta_name: String,
}

impl ShellMetaPlugin {
    pub fn new() -> ShellMetaPlugin {
        ShellMetaPlugin {
            meta_name: "shell".to_string(),
        }
    }
}

impl MetaPlugin for ShellMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match env::var("SHELL") {
            Ok(shell) => Ok(shell),
            Err(_) => Ok("unknown".to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct ShellPidMetaPlugin {
    meta_name: String,
}

impl ShellPidMetaPlugin {
    pub fn new() -> ShellPidMetaPlugin {
        ShellPidMetaPlugin {
            meta_name: "shell_pid".to_string(),
        }
    }
}

impl MetaPlugin for ShellPidMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match env::var("PPID") {
            Ok(ppid) => Ok(ppid),
            Err(_) => Ok(process::id().to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct KeepPidMetaPlugin {
    meta_name: String,
}

impl KeepPidMetaPlugin {
    pub fn new() -> KeepPidMetaPlugin {
        KeepPidMetaPlugin {
            meta_name: "keep_pid".to_string(),
        }
    }
}

impl MetaPlugin for KeepPidMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        Ok(process::id().to_string())
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct HostnameMetaPlugin {
    meta_name: String,
}

impl HostnameMetaPlugin {
    pub fn new() -> HostnameMetaPlugin {
        HostnameMetaPlugin {
            meta_name: "hostname".to_string(),
        }
    }
}

impl MetaPlugin for HostnameMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        match gethostname().into_string() {
            Ok(hostname) => Ok(hostname),
            Err(_) => Ok("unknown".to_string()),
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed for hostname
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}

#[derive(Debug, Clone, Default)]
pub struct FullHostnameMetaPlugin {
    meta_name: String,
}

impl FullHostnameMetaPlugin {
    pub fn new() -> FullHostnameMetaPlugin {
        FullHostnameMetaPlugin {
            meta_name: "full_hostname".to_string(),
        }
    }
}

impl MetaPlugin for FullHostnameMetaPlugin {
    fn create(&self) -> Result<Box<dyn Write>> {
        Ok(Box::new(io::sink()))
    }

    fn finalize(&mut self) -> io::Result<String> {
        // Try to get the FQDN through reverse DNS lookup
        match local_ip() {
            Ok(my_local_ip) => {
                match lookup_addr(&my_local_ip) {
                    Ok(hostname) => Ok(hostname),
                    Err(_) => {
                        // Fall back to regular hostname if reverse DNS fails
                        match gethostname().into_string() {
                            Ok(hostname) => Ok(hostname),
                            Err(_) => Ok("unknown".to_string()),
                        }
                    }
                }
            }
            Err(_) => {
                // Fall back to regular hostname if we can't get local IP
                match gethostname().into_string() {
                    Ok(hostname) => Ok(hostname),
                    Err(_) => Ok("unknown".to_string()),
                }
            }
        }
    }

    fn update(&mut self, _data: &[u8]) {
        // No update needed for full hostname
    }

    fn meta_name(&mut self) -> String {
        self.meta_name.clone()
    }
}