- id: "hjob.shizhuang-inc.com"
  server_name: "hjob.shizhuang-inc.com"
  service_in:
  - "default_80"
  - "default_443"
  redirect: true
  location:
  - path: "/"
    access_rule_names:
    - "access_allow_d803a06f39ad4dcd8dfe517359a33a61"
    - "access_deny_all"
    client_max_body_size: "100M"
    proxy_headers:
    - "clientport:$remote_port"
    - "Upgrade:$http_upgrade"
    - "Connection:$http_connection"
    - "Host:$host"
    - "X-Forwarded-For:$proxy_add_x_forwarded_for"
    - "X-Forwarded-Proto:$scheme"
    proxy_pass: "http://hangzhou-csprd-hjob-8899"


 - name: "hangzhou-csprd-hjob-8899"
  peers:
  - server: "1.1.1.1:8899"
    weight: 100
    backup: false
    down: false
  - server: "2.2.2.2:8899"
    weight: 1
    backup: false
    down: false
  max_fails: 3
  fail_timeout: "10s"
  max_connections: 1000

/// A map of server names to their respective configurations.
#[serde(skip)]
pub servers: HashMap<String, Arc<Mutex<ServerConf>>>,
/// A map of upstream names to their respective configurations.
#[serde(skip)]
pub upstreams: HashMap<String, Arc<Mutex<UpstreamConf>>>,

impl TryFrom<&UpstreamConf> for RunTimeUpStream {
    type Error = Error;
    fn try_from(value: &UpstreamConf) -> std::result::Result<Self, Self::Error> {
    }
}

pub static GLOBAL_CONF: Lazy<RwLock<GlobalConf>> = Lazy::new(|| {
    RwLock::new(GlobalConf {
        main_conf: MainConf::default(),
        runtime_upstreams: HashMap::with_capacity(16),
        runtime_servers: HashMap::with_capacity(16),
        host_selectors: HashMap::with_capacity(16),
    })
});


#[derive(Default)]
pub struct GlobalConf {
    // main static configuration
    pub main_conf: MainConf,
    //one-to-one between upstreams and runtime_upstreams
    pub runtime_upstreams: HashMap<String, Arc<RunTimeUpStream>>,
    //one-to-one between servers and runtime_servers;
    pub runtime_servers: HashMap<String, Arc<RunTimeServer>>,
    //one service one host selector
    pub host_selectors: HashMap<String, Arc<HostSelector>>,
}

/// A struct to manage server selection based on host names.
///
/// This struct contains three fields: `equal`, `prefix`, and `regex`.
/// The `equal` field is a HashMap that stores server names and their corresponding IDs
/// when the server name exactly matches the host.
/// The `prefix` field is a Vec of tuples, where each tuple contains a prefix and its corresponding server ID.
/// The `regex` field is a Vec of tuples, where each tuple contains a Regex and its corresponding server ID.
///
/// The `HostSelector` struct provides methods to insert server names and IDs,
/// and to match a given host name with a server ID based on the rules defined in the struct.
#[derive(Clone)]
pub struct HostSelector {
    pub equal: HashMap<String, String>,
    pub prefixes: Vec<(String, String)>,  //原始前通配符數據
    pub prefix_nested_map: NestedHashMap, // 嵌套哈希結構優化匹配效率
    pub regex: Vec<(Regex, String)>,
}

#[derive(Debug, Clone)]
pub struct NestedHashMap {
    data: HashMap<String, NestedHashMap>, //層級域名節點
    value: Option<String>, // 終端節點關聯服務器ID
}


impl NestedHashMap
{
    /// 基于域名分段實現高效檢索（從右向左匹配）
    pub(crate) fn find(&self, key: &str) -> Option<String> {
        let tokens = key.split('.').collect::<Vec<&str>>();
        let mut current_map = self;
        let mut result = None;
        // 遍歷域名層級（如 www.example.com → [com, example, www]）
        for token in tokens.iter().rev() {
            // 優先記錄當前層級的有效值（實現最長匹配）
            if current_map.value.is_some() {
                result = Some(current_map.value.as_ref().unwrap());
            }
            // 向下一級域名跳轉
            let child = current_map.data.get(*token);
            match child{
                Some(child) => {
                    current_map = child;
                }
                None => {
                    break;
                }
            }
        }
        result.map(|value| value.to_owned())
    }
}

Syntax:location [ = | ~ | ~* | ^~ ] uri { ... }
location @name { ... }
Default:—
Context:server, location

#[derive(Clone, Default)]
#[allow(unused)]
/// A struct representing a shared runtime server configuration.
pub struct RunTimeServer {
    /// Unique identifier for the server.
    pub id: String,
    /// Name of the server.
    pub server_name: String,
    /// Indicates whether the server should redirect requests.
    pub redirect: bool,
    /// A HashMap storing equal-matched locations, where the key is the path and the value is the location.
    pub equal_match: HashMap<String, Arc<RunTimeLocation>>,// 精確匹配字典
    /// A Vec storing regex-matched locations, where each tuple contains a Regex and the location.// 正則匹配隊列
    pub regex_match: Vec<(Regex, Arc<RunTimeLocation>)>,
    /// The root node of the static location tree.
    pub prefix_root: Option<Arc<static_location_tree::TreeNode>>,
}

pub fn find_location(path: &str, node: &Arc<TreeNode>) -> Option<(bool, Arc<RunTimeLocation>)> {
    let mut node = Some(node);
    let mut uri_len = 0;
    let mut search_node = None;


    while let Some(current) = node {
        let n = std::cmp::min(current.path.len(), path.len() - uri_len);
        let node_path = ¤t.path[..n];
        let temp_path = &path[uri_len..uri_len + n];


        match path_cmp(node_path, temp_path) {
            std::cmp::Ordering::Equal => {
                uri_len += n;
                search_node = Some((current.need_stop, current.val.clone()));
                node = current.tree.as_ref();
                if uri_len >= path.len() { break; }
            }
            std::cmp::Ordering::Greater => node = current.left.as_ref(),
            std::cmp::Ordering::Less => node = current.right.as_ref(),
        }
    }
    search_node
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RewriteFlags {
    Break,
    Last,
    Redirect,
    Permanent,
    NONE,
}


pub struct RewriteRule {
    pub reg_source: String,
    pub reg: Regex,
    pub target: String,
    pub flag: RewriteFlags,
}

#[async_trait]
pub trait ProxyFilter: Sync + Send {
    fn phase(&self) -> ProxyFilterPhase;
    
    fn name(&self) -> ProxyFilterName;
    
    fn order(&self) -> i32;
    
    async fn handle(&self, _session: &mut Session, _ctx: &mut ProxyContext) -> HandleResult {
        HandleResult::Continue
    }
}

#[derive(Debug, PartialEq, Clone, EnumString)]
pub enum HandleResult {
    /// 表示當前filter執行完成，繼續執行下一個 filter。
    Continue,
    /// 表示當前filter操作被中斷，停止filter chain 的執行動作。
    Break,
}