ruwebframe 0.1.8

use crate::rubase::{ BaseEntitySingle, rutils};

use crate::rubase::ruconst::ruconst;
use crate::rubase::rudto::cfgdto;

use crate::rubase::rudto::cfgdto::CfgDto;
use crate::rubase::rutils::{ru_file, str_utils};

use crate::rulog::ru_log;
use serde::Deserialize;
use spicex::Spice;
use std::fs::File;
use std::io::{BufReader, Read};
use std::sync::{ Mutex};
use crate::rucfg;
use crate::rucfg::find_bean_ru_config;

pub fn if_dev() -> bool {
    if_env("dev")
}

pub fn if_test() -> bool {
    if_env("test")
}
pub fn if_release() -> bool {
    if_env("release")
}

pub fn if_master() -> bool {
    if_env("prod") || if_env("master")
}

pub fn if_not_master() -> bool {
    !if_master()
}

// 干净的函数别名，零额外开销
pub fn find_env() -> String {
   find_bean_ru_config().unwrap().lock().unwrap().find_env()
}
pub fn if_env(env: &str) -> bool {
    find_bean_ru_config().unwrap().lock().unwrap().if_env(env)
}

#[derive(Debug,Clone, serde::Serialize, Deserialize)]
pub struct RuConfig {

    pub config: CfgDto,
}
impl BaseEntitySingle for RuConfig {}
impl RuConfig {
    pub fn new() -> Self {
        let mut rucfg = Self {
            config: CfgDto::default(),
        };
        rucfg.parse_config();
        rucfg
    }

    pub fn new_mutex() -> Mutex<RuConfig> {
        Mutex::new(Self::new())
    }
    pub fn get_config(&self, file: String) -> String {
        let mut cfgdir = rutils::find_base_path();
        cfgdir.push_str("/config/");
        cfgdir.push_str(file.as_str());
        cfgdir
    }
    pub fn parse_config(&mut self) {
        let envFile = self.get_config(self.parse_env2file());
        let file = File::open(&envFile);

        let mut read = BufReader::new(file.unwrap());
        let mut yaml_str = String::new();
        read.read_to_string(&mut yaml_str).unwrap();

        let ret = serde_yaml::from_str::<CfgDto>(&yaml_str);
        // ✅ 显式指定类型
        if let Ok(mut config) = ret {
            config.parse_env_var();
            self.config = config;
        } else {
            ru_log::error("parse config failed");
        }
        //self.parsed.store(true, Ordering::Relaxed);
    }

    pub fn find_env(&self) -> String {
        self.config.find_env()
    }

    pub fn parse_env2file(&self) -> String {
        let env_file = self.parse_env();
        let filename = String::from("ichub-") + &rutils::parse_env_var_only(env_file) + ".yml";
        ru_log::info2("filename:", filename.as_str());

        return filename;
    }
    pub fn parse_env(&self) -> String {
        let mut spice = Spice::new();
        spice
            .set_config_file(rutils::find_base_path() + ruconst::FILE_PATH_ENV)
            .unwrap();
        let env = spice.get_string("Env").unwrap();

        return env.unwrap();
    }
    pub fn read_json(&self) -> & CfgDto {
        self.read()
    }
    pub fn get_self(&self) -> &CfgDto {
        &self.config
    }

    pub fn find_base_path(&self) -> String {
        ru_file::find_base_path()
    }
    pub fn read_clone(&self) -> cfgdto::CfgDto {
        self.config.clone()
    }
    pub fn read(&self) -> & CfgDto {
        &self.config
    }

    pub fn if_env(&self, env: &str) -> bool {
        self.find_env().as_str() == env
    }
    pub fn if_master(&self) -> bool {
       self. if_env("prod") || self.if_env("master")
    }

    pub fn if_not_master(&self) -> bool {
        !self.if_master()
    }

    pub fn get_web_port(&self) -> u16 {

        if self.if_not_master() {
            ru_log::info2("ruwebframe config=>", self.config.clone());
        }
        str_utils::str2u16(self.config.web.server.port.as_str())
    }
}