sharing/

paths.rs

use std::path::{PathBuf};
#[cfg(target_os = "windows")]
use std::path::{Path};
use std::string::ToString;
use once_cell::sync::Lazy;

use lazy_static::lazy_static;
// use winapi::um::winnt::{KEY_READ, KEY_WRITE};
#[cfg(target_os = "windows")]
use winreg::RegKey;
#[cfg(target_os = "windows")]
use winreg::enums::HKEY_LOCAL_MACHINE;
#[cfg(target_os = "windows")]
use crate::{
    NAME_SHORTCUT_DESKTOP, proc,
    PROGRAM_FILES_ENV_VAR, PROGRAM_FILES_KEY, PROGRAM_FILES_SUBKEY,    
};

use crate::{BASE_FOLDER, BEEPER_PDF_FILE, CONFIG_FILE_NAME, ICON_PISPAS, LOGS_PATH, OLD_SERVICE_PYTHON_NAME, POS_DRIVER_FILE, PRINTER_TEST_FILE, PRINTSVC_PYTHON_NAME, ROOT_FOLDER, WKHTMLTOPDF_FILE, PYTHON_FOLDER, PRINT_SERVICE, SERVICE_PYTHON_NAME, ORDER_KITCHEN, PISPAS_CONFIGURATOR, TRAY_ICON_NAME, PISPAS_ELEVATOR};

lazy_static! {
    pub static ref HOME_DIR: PathBuf = {
       user_profile_dir()
    };

}

#[cfg(target_os = "windows")]
lazy_static! {
    pub static ref PROGRAM_HOME_DIR: PathBuf = {
     if let Some(program_files_dir) = get_program_files_dir() {
            tracing::info!("Folder Program Files: {:?}", program_files_dir);
            program_files_dir.join(BASE_FOLDER)
        } else {
            panic!("Don't find Program Files folder")
        }

    };
}

#[cfg(target_os = "windows")]
lazy_static! {
    pub static ref PROGRAM_DATA_DIR: PathBuf = {
     if let Some(program_files_dir) = get_program_data_dir() {
            tracing::info!("Folder Program Files: {:?}", program_files_dir);
            program_files_dir.join(BASE_FOLDER)
        } else {
            panic!("Don't find Program Files folder")
        }

    };
}

#[cfg(not(target_os = "windows"))]
lazy_static! {
    pub static ref PROGRAM_HOME_DIR: PathBuf = HOME_DIR.clone();
    pub static ref PROGRAM_DATA_DIR: PathBuf = HOME_DIR.clone();
}

#[cfg(target_os = "windows")]
pub fn get_elevator_path(working_dir: &PathBuf) -> PathBuf {
    working_dir.join(crate::PISPAS_ELEVATOR)
}
#[cfg(not(target_os = "windows"))]
pub fn get_elevator_path(working_dir: &PathBuf) -> PathBuf {
    working_dir.join(crate::PISPAS_ELEVATOR)
}



pub fn get_install_dir() -> PathBuf {
    PROGRAM_HOME_DIR.clone()
}

#[cfg(target_os = "windows")]
fn get_program_files_dir() -> Option<PathBuf> {
    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
    let subkey = hklm.open_subkey(PROGRAM_FILES_KEY).ok()?;

    if let Ok(program_files_dir) = subkey.get_value::<String, _>(PROGRAM_FILES_SUBKEY) {
        tracing::info!("Program Files: {:?}", program_files_dir);
        Some(PathBuf::from(program_files_dir))
    } else {
        tracing::info!("Program Files: {:?}", std::env::var(PROGRAM_FILES_ENV_VAR).ok().map(PathBuf::from));
        std::env::var(PROGRAM_FILES_ENV_VAR).ok().map(PathBuf::from)
    }
}
// #[cfg(target_os = "windows")]
// pub fn add_to_system_path(path_to_add: &str) -> Result<(), Box<dyn std::error::Error>> {
//
//     let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
//     let environment = hklm.open_subkey_with_flags("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment", KEY_READ | KEY_WRITE)?;
//
//     // Leer el valor actual de PYTHON_PATH
//     let current_python_path: Option<String> = environment.get_value("PYTHONPATH").ok();
//
//     // Comprobar si el PYTHON_PATH actual es igual al valor que queremos establecer
//     if let Some(existing_path) = current_python_path {
//         if existing_path == path_to_add {
//             println!("The value is already set in the PYTHONPATH.");
//             return Ok(());
//         }
//     }
//
//     // Establecer el nuevo valor de PYTHON_PATH en el registro
//     environment.set_value("PYTHONPATH", &path_to_add)?;
//
//     Ok(())
// }
#[cfg(target_os = "windows")]
fn get_program_data_dir() -> Option<PathBuf> {
    std::env::var("ProgramData").ok().map(PathBuf::from)
}


pub fn user_home() -> PathBuf {
    dirs::home_dir()
        .unwrap_or_default()
}


pub fn log_dir() -> PathBuf {
    PROGRAM_DATA_DIR.join(LOGS_PATH)
}

pub fn log_bin_dir() -> PathBuf {
    PROGRAM_HOME_DIR.join(LOGS_PATH)
}
pub fn user_log_dir() -> PathBuf {
    HOME_DIR.join(LOGS_PATH)
}
pub fn service_log_dir() -> PathBuf {
    HOME_DIR.join(LOGS_PATH)
}

pub fn backup_dir() -> PathBuf {
    HOME_DIR.join("backup")
}

pub fn lib_dir() -> PathBuf {
    PROGRAM_HOME_DIR.clone()
}

pub fn bin_dir() -> PathBuf {
    PROGRAM_HOME_DIR.clone()
}

pub fn jobs_dir() -> PathBuf {
    PROGRAM_HOME_DIR.join("jobs")
}

pub fn env_file_path() -> PathBuf {
    if cfg!(target_os = "windows") {
        HOME_DIR.join(crate::ENV_FILE_NAME)
    } else { 
        bin_dir().join(".env")
    }

    
}

#[cfg(target_os = "windows")]
pub fn icon_desktop() -> PathBuf {
    match proc::get_gran_father_info() {
        Ok(user_info) => {
            let path_icon = Path::new(&user_info.desktop).join(NAME_SHORTCUT_DESKTOP);
            tracing::info!("Path icon desktop: {:?}", path_icon);
            path_icon
        }
        Err(err) => {
            tracing::error!("Error getting user info: {:?}", err);
            let desktop_path = dirs::desktop_dir().expect("Can't get desktop path");
            desktop_path.join(NAME_SHORTCUT_DESKTOP)
        }
    }
}

#[cfg(target_os = "windows")]
pub fn user_profile_dir() -> PathBuf {
    match proc::get_gran_father_info() {
        Ok(user_info) => {
            let user_profile = Path::new(&user_info.userprofile);
            tracing::info!("User profile path: {:?}", user_profile);
            if user_profile.to_str().is_none() {
                tracing::warn!("User profile path is not valid, using default path");
                return PathBuf::from(ROOT_FOLDER).join(BASE_FOLDER);
            }
            user_profile.to_path_buf()
                .join(ROOT_FOLDER)
                .join(BASE_FOLDER)
        }
        Err(err) => {
            tracing::error!("Error getting user info: {:?}", err);
            //best match
            match dirs::home_dir() {
                Some(home) => {
                    tracing::info!("Using home directory: {:?}", home);
                    home.join(ROOT_FOLDER).join(BASE_FOLDER)
                },
                None => {
                    tracing::warn!("Can't get home directory, using default path");
                    PathBuf::from(ROOT_FOLDER).join(BASE_FOLDER)
                },
            }            
        }
    }
}

#[cfg(not(target_os = "windows"))]
pub fn user_profile_dir() -> PathBuf {
    dirs::home_dir()
        .unwrap_or_default()
        .join(ROOT_FOLDER)
        .join(BASE_FOLDER)
}

// Files


pub fn config_file_path() -> PathBuf {
    bin_dir().join(CONFIG_FILE_NAME)
}


pub fn get_persistance_path() -> PathBuf {    
    let filename = format!("{}-data.bin", whoami::realname());
    HOME_DIR.join(filename)
}


pub fn tray_icon_path() -> PathBuf { bin_dir().join(TRAY_ICON_NAME) }




pub fn elevator_path() -> PathBuf { bin_dir().join(PISPAS_ELEVATOR) }


pub const WINDOWS_SYSTEM32: &str = "C:\\Windows\\System32";
pub const PREFIX_PISPAS: &str = "pispas-";
pub const WIN_BINARIES_PATH: &str = "win";
pub fn win_dir() -> PathBuf {
    bin_dir().join(WIN_BINARIES_PATH)
}

pub static SUMATRA_PATH: Lazy<String> = Lazy::new(|| {
    win_dir().join(crate::SUMATRA_FILE).display().to_string()
});

pub static WKHTMLTOPDF_PATH: Lazy<String> = Lazy::new(|| {
    win_dir().join(WKHTMLTOPDF_FILE).display().to_string()
});

pub const MODULES_FOLDER: &str = "modules";
pub fn modules_dir() -> PathBuf {
    PROGRAM_HOME_DIR.join(MODULES_FOLDER)
}

pub fn configurator_path() -> PathBuf { bin_dir().join(PISPAS_CONFIGURATOR) }
pub fn get_python_service() -> PathBuf{ bin_dir().join(SERVICE_PYTHON_NAME) }
pub fn get_python_service_old() -> PathBuf{ bin_dir().join(OLD_SERVICE_PYTHON_NAME) }
pub fn get_printsvc_service() -> PathBuf{ bin_dir().join(PRINTSVC_PYTHON_NAME) }
pub fn get_printsvc_service_new() -> PathBuf{ bin_dir().join(PRINTSVC_PYTHON_NAME) }

pub fn pdf_info_file_path() -> PathBuf {
    bin_dir().join(WIN_BINARIES_PATH).join(crate::PDF_INFO_FILE)
}
pub fn pos_driver_file_path() -> PathBuf {
    bin_dir().join(WIN_BINARIES_PATH).join(POS_DRIVER_FILE)
}
pub fn printer_test_file_path() -> PathBuf {
    bin_dir().join(WIN_BINARIES_PATH).join(PRINTER_TEST_FILE)
}
pub fn beep_pdf_file_path() -> PathBuf {
    bin_dir().join(WIN_BINARIES_PATH).join(BEEPER_PDF_FILE)
}

pub fn icon_pispas() -> PathBuf {
    bin_dir().join(ICON_PISPAS)
}
pub fn get_python_folder() -> PathBuf {
    bin_dir().join(PYTHON_FOLDER)
}
pub fn print_service_path() -> PathBuf {
    bin_dir().join(PRINT_SERVICE)
}
pub fn order_kitchen_path() -> PathBuf {
    bin_dir().join(ORDER_KITCHEN)
}