sharing/

utils.rs

use std::{env, fs};
use std::fs::File;
use std::io::Cursor;
use dotenv::from_path;
use serde::{Deserialize, Serialize};
use crate::{paths, PisPasResult};

pub async fn install_sharing(file_path: &str, args: &[&str]) -> std::process::ExitStatus {
    // Construye el comando completo en una sola cadena
    let full_command = format!(
        "Start-Process '{}' -ArgumentList '{}' -Wait",
        file_path,
        args.join(" ")
    );

    println!("Executing: {}", full_command);
    let status = std::process::Command::new("powershell")
        .arg("-Command")
        .arg(&full_command)
        .status()
        .expect("No se pudo ejecutar el instalador");

    println!("Install Script ended with status: {}", status);
    status
}

/// Runtime configuration loaded from the install's `.env` file.
///
/// `ConfigEnv` is the single struct that every binary reads at startup.
/// Fields are plain POD (strings, booleans, ports) so the type is trivially
/// serializable to JSON for the Tauri configurator UI.
///
/// ## Lifecycle
///
/// 1. The installer writes a default `.env` via `init_env` on first run.
/// 2. Each binary calls [`ConfigEnv::load`] at startup, which reads the
///    `.env` through `dotenv::from_path` and materialises the struct.
/// 3. The configurator calls [`ConfigEnv::save`] after the user edits a
///    field, then pushes an IPC restart message to `pispas-modules`.
///
/// ## Invariants
///
/// * `local_ussl = true` requires the embedded TLS cert and a client that
///   connects via `wss://local.unpispas.es:<local_port>`. Binding to
///   `127.0.0.1` is fine because DNS resolves `local.unpispas.es` there.
/// * `modules` is an ordered list used by
///   `pispas_modules::load_services` to instantiate the services. Names
///   not in the match arm are logged and ignored.
///
/// ## Extending
///
/// Adding a field requires touching four places — see `CLAUDE.md § 5`.
/// Forgetting one of them silently resets the new field to its default
/// every time the user saves from the configurator.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct ConfigEnv {
    /// Stable identity of this install. Used as the Windows Service name
    /// and echoed back in every WebSocket message envelope.
    pub service_name: String,
    /// Build version tag, echoed in message envelopes for log correlation.
    pub service_vers: String,
    /// Backend REST API hostname (e.g. `api.unpispas.es`).
    pub pispas_host: String,
    /// Backend WebSocket hostname that `pispas-modules` keeps an outbound
    /// connection to (e.g. `wss.unpispas.es`).
    pub remote_host: String,
    /// Backend WebSocket port. Usually `443`.
    pub remote_port: u16,
    /// `true` → connect with `wss://`, `false` → `ws://`.
    pub remote_ussl: bool,
    /// Bind address for the local WebSocket server. Almost always
    /// `127.0.0.1`. See `docs/CONFIGURATION.md` before changing.
    pub local_host: String,
    /// Bind port for the local WebSocket server. Default `5005`.
    pub local_port: u16,
    /// `true` → accept TLS on the local socket (recommended for browser
    /// clients that require `wss://`). The listener is dual-mode and still
    /// accepts plain `ws://` when this is on.
    pub local_ussl: bool,
    /// Ordered list of service modules to load at boot
    /// (`base`, `print`, `paytef`, …).
    pub modules: Vec<String>,
    /// Cached printer list shown in the configurator UI. Refreshed by the
    /// service on demand.
    pub list_printers: Option<Vec<String>>,
    /// Place this TPV belongs to. `None` until the first authenticated
    /// client opens the local WS and sends a `CHECK` with `place_id`
    /// (first-write-wins). Once set, mismatching `place_id` on a future
    /// CHECK is rejected — the operator must explicitly reset identity
    /// from the configurator to re-pair the TPV to a different place.
    pub place_id: Option<i64>,
    /// Backend-assigned technical id (PK of the `RASPPI` table). `None`
    /// until the WSR `CONNECT` response delivers it. Used for routing
    /// (the WSR indexes by `objid`, not by `service_name`) and as the
    /// FQDN prefix of the per-TPV LE cert (`<objid>.local.unpispas.es`).
    pub objid: Option<i64>,
}

impl Default for ConfigEnv {
    fn default() -> Self {
        Self {
            service_name: "local_service".to_string(),
            service_vers: env::var("SERVICE_VERS").unwrap_or_else(|_| "1.0.0.0".to_string()),
            pispas_host: env::var("PISPAS_HOST").unwrap_or_else(|_| "api.unpispas.es".to_string()),
            remote_host: env::var("REMOTE_HOST").unwrap_or_else(|_| "wss.unpispas.es".to_string()),
            remote_port: env::var("REMOTE_PORT")
                .unwrap_or_else(|_| "443".to_string())
                .parse()
                .unwrap_or(443),
            remote_ussl: env::var("REMOTE_USSL")
                .unwrap_or_else(|_| "true".to_string())
                .eq_ignore_ascii_case("true"),
            local_host: env::var("LOCAL_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
            local_port: env::var("LOCAL_PORT")
                .unwrap_or_else(|_| "5005".to_string())
                .parse()
                .unwrap_or(5005),
            local_ussl: env::var("LOCAL_USSL")
                .unwrap_or_else(|_| "true".to_string())
                .eq_ignore_ascii_case("true"),
            modules: env::var("MODULES")
                .unwrap_or_else(|_| "base,print".to_string()) // Valor predeterminado
                .split(',')
                .map(|s| s.trim().to_string())
                .collect(),
            list_printers: None, // Inicialmente vacío
            place_id: None,
            objid: None,
        }
    }
}

impl ConfigEnv {
    pub fn load() -> Self {
        let env_path = paths::env_file_path();
        tracing::info!("Loading cfg from {}", env_path.display());

        // Carga el archivo .env desde el directorio bin
        if env_path.exists() {
            from_path(&env_path).ok();
        } else {
            init_env();
        }

        Self {
            service_name: env::var("SERVICE_NAME").unwrap_or_else(|_| "unpispas_pdfwritter".to_string()),
            service_vers: env::var("SERVICE_VERS").unwrap_or_else(|_| "1.0.0.2".to_string()),
            pispas_host: env::var("PISPAS_HOST").unwrap_or_else(|_| "api.unpispas.es".to_string()),
            remote_host: env::var("REMOTE_HOST").unwrap_or_else(|_| "wss.unpispas.es".to_string()),
            remote_port: env::var("REMOTE_PORT")
                .unwrap_or_else(|_| "443".to_string())
                .parse()
                .unwrap_or(8765),
            remote_ussl: env::var("REMOTE_USSL")
                .unwrap_or_else(|_| "true".to_string())
                .parse()
                .unwrap_or(false),
            local_host: env::var("LOCAL_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
            local_port: env::var("LOCAL_PORT")
                .unwrap_or_else(|_| "5005".to_string())
                .parse()
                .unwrap_or(5005),
            local_ussl: env::var("LOCAL_USSL")
                .unwrap_or_else(|_| "true".to_string())
                .eq_ignore_ascii_case("true"),
            modules: env::var("MODULES")
                .unwrap_or_else(|_| "base,print".to_string()) // Valor predeterminado
                .split(',')
                .map(|s| s.trim().to_string())
                .collect(), // Convierte a Vec<String>
            list_printers: None, // Inicialmente vacío
            place_id: env::var("PLACE_ID").ok().and_then(|s| s.parse::<i64>().ok()),
            objid: env::var("OBJID").ok().and_then(|s| s.parse::<i64>().ok()),
        }
    }

    /// Set `place_id` and persist to `.env`. First-write-wins: returns
    /// `Err` if `place_id` is already set to a different value (the
    /// operator must explicitly reset identity to re-pair the TPV).
    /// Setting the same value is a no-op (idempotent).
    pub fn set_place_id(&mut self, new_place_id: i64) -> std::result::Result<(), String> {
        match self.place_id {
            Some(existing) if existing == new_place_id => Ok(()),
            Some(existing) => Err(format!(
                "place_id already set to {existing}; refusing overwrite to {new_place_id}"
            )),
            None => {
                self.place_id = Some(new_place_id);
                self.save();
                Ok(())
            }
        }
    }

    /// Set `objid` and persist. `objid` is assigned by the backend in
    /// the WSR `CONNECT` response. Once we have it, it should never
    /// change for the lifetime of the install — but we don't enforce
    /// that here; the backend is the source of truth.
    pub fn set_objid(&mut self, new_objid: i64) {
        self.objid = Some(new_objid);
        self.save();
    }

    /// Drop the bootstrap fields and let the TPV re-pair from scratch.
    /// Triggered by the configurator UI when an operator wants to move
    /// the TPV to a different place. The backend should also be told
    /// to delete the old `RASPPI` row separately.
    pub fn forget_identity(&mut self) {
        self.place_id = None;
        self.objid = None;
        self.save();
    }

    pub fn change_service_name(&mut self, new_name: &str) {
        self.service_name = new_name.to_string();
    }

    pub fn change_service_vers(&mut self, new_vers: &str) {
        self.service_vers = new_vers.to_string();
    }

    pub fn change_pispas_host(&mut self, new_host: &str) {
        self.pispas_host = new_host.to_string();
    }

    pub fn change_remote_host(&mut self, new_host: &str) {
        self.remote_host = new_host.to_string();
    }

    pub fn change_remote_port(&mut self, new_port: u16) {
        self.remote_port = new_port;
    }

    pub fn change_remote_ussl(&mut self, ussl: bool) {
        self.remote_ussl = ussl;
    }

    pub fn change_local_host(&mut self, new_host: &str) {
        self.local_host = new_host.to_string();
    }

    pub fn change_local_port(&mut self, new_port: u16) {
        self.local_port = new_port;
    }

    pub fn change_local_ussl(&mut self, ussl: bool) {
        self.local_ussl = ussl;
    }

    pub fn change_modules(&mut self, new_modules: Vec<String>) {
        self.modules = new_modules;
    }

    pub fn save(&self) {
        let list_printers_str = self.list_printers.as_ref().map_or("".to_string(), |printers| printers.join(","));
        // `place_id` and `objid` are written only when known; empty
        // means "still in PRE-BOOTSTRAP / waiting for backend".
        let place_id_str = self.place_id.map(|v| v.to_string()).unwrap_or_default();
        let objid_str = self.objid.map(|v| v.to_string()).unwrap_or_default();
        tracing::info!("Saving config: {:?}", self);
        let env_content = format!(
            "SERVICE_NAME={}\nSERVICE_VERS={}\nPISPAS_HOST={}\nREMOTE_HOST={}\nREMOTE_PORT={}\nREMOTE_USSL={}\nLOCAL_HOST={}\nLOCAL_PORT={}\nLOCAL_USSL={}\nMODULES={}\nLIST_PRINTERS={}\nPLACE_ID={}\nOBJID={}\n",
            self.service_name,
            self.service_vers,
            self.pispas_host,
            self.remote_host,
            self.remote_port,
            self.remote_ussl,
            self.local_host,
            self.local_port,
            self.local_ussl,
            self.modules.join(","),
            list_printers_str,
            place_id_str,
            objid_str,
        );

        let env_path = crate::paths::env_file_path();

        if !paths::bin_dir().exists() {
            fs::create_dir_all(paths::bin_dir()).unwrap();
        }
        
        println!("Saving config to {}", env_path.display());
        
        match fs::write(&env_path, env_content) {
            Ok(_) => tracing::info!("Config saved successfully to {}", env_path.display()),
            Err(e) => {
                println!("Failed to save config to {}: {}", env_path.display(), e);
                tracing::error!("Failed to save config to {}: {}", env_path.display(), e)
            },
        }        
    }
}
fn init_env() {
    let bin_dir = paths::bin_dir();
    let env_path = bin_dir.join(".env");

    let service_name =     crate::natives::api::get_name_service();
    

    if !env_path.exists() {
        let default_env_content = format!(r#"SERVICE_NAME={}
SERVICE_VERS=1.0.0.3
LOCAL_HOST=127.0.0.1
LOCAL_PORT=5005
LOCAL_USSL=true
REMOTE_USSL=true
REMOTE_HOST=wss.unpispas.es
REMOTE_PORT=443
PISPAS_HOST=api.unpispas.es
MODULES=base,print
LIST_PRINTERS=POS80, CommandViewer
"#, service_name);
        if !bin_dir.exists() {
            match fs::create_dir_all(&bin_dir) {
                Ok(_) => tracing::info!("Created bin directory at {}", bin_dir.display()),
                Err(e) => {
                    tracing::error!("Failed to create bin directory at {}: {}", bin_dir.display(), e);                    
                }
            }
        }

        match fs::write(&env_path, default_env_content) {
            Ok(_) => tracing::info!("Created default .env file at {}", env_path.display()),
            Err(e) => {
                tracing::error!("Failed to create .env file at {}: {}", env_path.display(), e);                
            }
        }
    }

    from_path(env_path).ok();
}



pub fn open_folder(path: &str) {
    let _ = std::process::Command::new("cmd")
        .args(&["/C", "explorer", &path])
        .spawn();
}





fn get_last_modified_time(path: &std::path::Path) -> std::io::Result<std::time::SystemTime> {
    let metadata = fs::metadata(path)?;
    metadata.modified()
}

pub fn delete_folders_with_prefix(path: &str, prefix: &str) -> std::io::Result<()> {
    let system32_path = std::path::Path::new(path);
    let mut latest_folder: Option<(std::time::SystemTime, std::path::PathBuf)> = None;

    // Itera sobre las carpetas y elimina las que no sean la más reciente
    for entry in fs::read_dir(system32_path)? {
        let entry = entry?;
        let path = entry.path();

        // Verifica si es un directorio y si tiene el prefijo deseado
        if path.is_dir() {
            if let Some(folder_name) = path.file_name() {
                if let Some(folder_name_str) = folder_name.to_str() {
                    if folder_name_str.starts_with(prefix) {
                        let modified_time = get_last_modified_time(&path)?;

                        // Compara y guarda la más reciente
                        if let Some((latest_time, _)) = &latest_folder {
                            if modified_time > *latest_time {
                                // Elimina la carpeta anterior más reciente
                                if let Some((_, old_path)) = latest_folder.take() {
                                    tracing::info!("Deleting older folder => {}", old_path.display());
                                    fs::remove_dir_all(&old_path)?;
                                }
                                // Guarda la nueva más reciente
                                latest_folder = Some((modified_time, path));
                            } else {
                                // Elimina la carpeta si es más antigua
                                tracing::info!("Deleting older folder => {}", path.display());
                                fs::remove_dir_all(&path)?;
                            }
                        } else {
                            // Si no hay carpeta guardada, asigna la primera como la más reciente
                            latest_folder = Some((modified_time, path));
                        }
                    }
                }
            }
        }
    }

    Ok(())
}

use include_dir::{include_dir, Dir};
use zip::read::ZipArchive;
pub const RESOURCES_WIN: Dir = include_dir!("resources/win");
pub const RESOURCES_TOOLS: Dir = include_dir!("resources/tools");

pub fn extract_all_resources(destination: &std::path::Path, resources: Dir) -> PisPasResult<()> {
    for file in resources.files() {
        let file_path = file.path();

        let final_destination = match file_path.file_name() {
            Some(filename) if filename == crate::SERVICE_PYTHON_NAME =>
                destination.parent().unwrap_or(destination).join(filename),
            Some(filename) => destination.join(filename),
            None => continue,
        };

        if let Some(parent) = final_destination.parent() {
            if !parent.exists() {
                fs::create_dir_all(parent)?;
            }
        }

        if file_path.extension().map_or(false, |ext| ext == "zip") {
            tracing::info!("Extracting zip file => {file_path:?}");
            // Si es un archivo .zip, extraemos en el directorio padre
            let zip_destination = final_destination.parent().unwrap_or(destination);

            let reader = Cursor::new(file.contents());
            let mut archive = ZipArchive::new(reader)?;

            for i in 0..archive.len() {
                let mut zip_file = archive.by_index(i)?;
                let outpath = zip_destination.join(zip_file.mangled_name());

                if (&*zip_file.name()).ends_with('/') {
                    fs::create_dir_all(&outpath)?;
                } else {
                    if let Some(p) = outpath.parent() {
                        if !p.exists() {
                            fs::create_dir_all(&p)?;
                        }
                    }
                    let mut outfile = File::create(&outpath)?;
                    std::io::copy(&mut zip_file, &mut outfile)?;
                }
            }
        } else {
            if final_destination.exists() {
                let content = fs::read(&final_destination)?;

                if content != file.contents() {
                    tracing::info!("Updating file => {:?}", final_destination);
                    fs::write(&final_destination, file.contents())?;
                } else {
                    tracing::info!("File already up-to-date => {:?}", final_destination);
                }
            } else {
                tracing::info!("Extracting new file => {:?}", final_destination);
                fs::write(&final_destination, file.contents())?;
            }
        }
    }

    // Recursivamente extrae los directorios.
    for dir in resources.dirs() {
        let dir_name = dir.path().file_name().unwrap_or_default();
        let final_destination = destination.join(dir_name);
        if !final_destination.exists() {
            fs::create_dir_all(&final_destination)?;
        }
        extract_all_resources(&final_destination, dir.clone())?;
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;

    #[test]
    fn test_config_env_default() {
        let config = ConfigEnv::default();

        assert_eq!(config.service_name, "local_service");
        assert!(!config.pispas_host.is_empty());
        assert!(!config.remote_host.is_empty());
        assert!(config.remote_port > 0);
        assert!(config.local_port > 0);
        assert!(!config.modules.is_empty());
        assert!(config.place_id.is_none(), "place_id starts unset (PRE-BOOTSTRAP)");
        assert!(config.objid.is_none(), "objid starts unset (PRE-BOOTSTRAP)");
    }

    #[test]
    fn test_set_place_id_first_write_wins() {
        let mut config = ConfigEnv::default();
        // First write succeeds.
        assert!(config.set_place_id(5).is_ok());
        assert_eq!(config.place_id, Some(5));
        // Same value is idempotent.
        assert!(config.set_place_id(5).is_ok());
        // Different value is rejected.
        assert!(config.set_place_id(99).is_err());
        assert_eq!(config.place_id, Some(5), "rejected write must not clobber");
    }

    #[test]
    fn test_forget_identity_clears_bootstrap_fields() {
        let mut config = ConfigEnv::default();
        let _ = config.set_place_id(5);
        config.set_objid(42);
        assert!(config.place_id.is_some() && config.objid.is_some());
        config.forget_identity();
        assert!(config.place_id.is_none());
        assert!(config.objid.is_none());
    }

    #[test]
    fn test_config_env_change_service_name() {
        let mut config = ConfigEnv::default();
        let new_name = "new_service_name";
        
        config.change_service_name(new_name);
        assert_eq!(config.service_name, new_name);
    }

    #[test]
    fn test_config_env_change_service_vers() {
        let mut config = ConfigEnv::default();
        let new_vers = "2.0.0";
        
        config.change_service_vers(new_vers);
        assert_eq!(config.service_vers, new_vers);
    }

    #[test]
    fn test_config_env_change_pispas_host() {
        let mut config = ConfigEnv::default();
        let new_host = "new.api.example.com";
        
        config.change_pispas_host(new_host);
        assert_eq!(config.pispas_host, new_host);
    }

    #[test]
    fn test_config_env_change_remote_host() {
        let mut config = ConfigEnv::default();
        let new_host = "new.remote.example.com";
        
        config.change_remote_host(new_host);
        assert_eq!(config.remote_host, new_host);
    }

    #[test]
    fn test_config_env_change_remote_port() {
        let mut config = ConfigEnv::default();
        let new_port = 8080;
        
        config.change_remote_port(new_port);
        assert_eq!(config.remote_port, new_port);
    }

    #[test]
    fn test_config_env_change_remote_ussl() {
        let mut config = ConfigEnv::default();
        
        config.change_remote_ussl(false);
        assert_eq!(config.remote_ussl, false);
        
        config.change_remote_ussl(true);
        assert_eq!(config.remote_ussl, true);
    }

    #[test]
    fn test_config_env_change_local_host() {
        let mut config = ConfigEnv::default();
        let new_host = "192.168.1.1";
        
        config.change_local_host(new_host);
        assert_eq!(config.local_host, new_host);
    }

    #[test]
    fn test_config_env_change_local_port() {
        let mut config = ConfigEnv::default();
        let new_port = 9000;
        
        config.change_local_port(new_port);
        assert_eq!(config.local_port, new_port);
    }

    #[test]
    fn test_config_env_change_modules() {
        let mut config = ConfigEnv::default();
        let new_modules = vec!["module1".to_string(), "module2".to_string()];
        
        config.change_modules(new_modules.clone());
        assert_eq!(config.modules, new_modules);
    }

    #[test]
    fn test_config_env_default_modules_parsing() {
        let config = ConfigEnv::default();
        // Default should have modules parsed from comma-separated string
        assert!(!config.modules.is_empty());
    }

    #[test]
    fn test_delete_folders_with_prefix() {
        // Create a temporary directory structure
        let temp_dir = std::env::temp_dir().join("test_delete_prefix");
        let prefix = "test-prefix-";
        
        // Clean up if exists
        let _ = fs::remove_dir_all(&temp_dir);
        fs::create_dir_all(&temp_dir).unwrap();

        // Create folders with prefix
        let folder1 = temp_dir.join(format!("{}folder1", prefix));
        let folder2 = temp_dir.join(format!("{}folder2", prefix));
        let other_folder = temp_dir.join("other-folder");
        
        fs::create_dir_all(&folder1).unwrap();
        fs::create_dir_all(&folder2).unwrap();
        fs::create_dir_all(&other_folder).unwrap();
        
        // Add a file to folder1 to make it "newer"
        let file1 = folder1.join("file.txt");
        fs::write(&file1, "content").unwrap();
        
        // Wait a bit to ensure different modification times
        std::thread::sleep(std::time::Duration::from_millis(100));
        
        // Add a file to folder2
        let file2 = folder2.join("file.txt");
        fs::write(&file2, "content").unwrap();

        // Run the function
        let result = delete_folders_with_prefix(temp_dir.to_str().unwrap(), prefix);
        assert!(result.is_ok(), "delete_folders_with_prefix should succeed");

        // Verify that only one folder with prefix remains (the newest)
        let entries: Vec<_> = fs::read_dir(&temp_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        
        let prefix_folders: Vec<_> = entries
            .iter()
            .filter(|e| {
                e.path().is_dir() && 
                e.path().file_name()
                    .and_then(|n| n.to_str())
                    .map(|s| s.starts_with(prefix))
                    .unwrap_or(false)
            })
            .collect();
        
        // Should have at most one folder with prefix remaining
        assert!(prefix_folders.len() <= 1, "Should keep at most one folder with prefix");
        
        // Other folder should still exist
        assert!(other_folder.exists(), "Non-prefix folder should not be deleted");

        // Clean up
        let _ = fs::remove_dir_all(&temp_dir);
    }
}