use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::process::Command;
use std::time::{SystemTime, UNIX_EPOCH};

pub type BufferID = usize;
pub struct Buffer {
    pub content: String,
    pub name: String,
}

impl Buffer {
    pub fn new(name: String, content: String) -> Self {
        Self { name, content }
    }

    fn generate_shell_name(command: &str) -> String {
        let mut hasher = DefaultHasher::new();
        command.hash(&mut hasher);
        let command_hash = hasher.finish();

        let timestamp = match SystemTime::now().duration_since(UNIX_EPOCH) {
            Ok(x) => x.as_secs(),
            Err(_) => 0,
        };

        format!("shell_{:x}_{}", command_hash, timestamp)
    }

    pub fn from_shell_command(command: &str) -> Self {
        let name = Self::generate_shell_name(command);

        let output = Command::new("sh").arg("-c").arg(command).output();

        let content = match output {
            Ok(output) => match String::from_utf8(output.stdout) {
                Ok(s) => s,
                Err(e) => format!("UTF-8 decode error: {}", e),
            },
            Err(e) => format!("Command failed: {}", e),
        };

        Self { name, content }
    }
}