use std::env;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use tracing::trace;


pub enum ProxyEnum {
    REST,
    WS,
}

pub enum ProxyResponseEnum {
    NO,
    YES(SocketAddr),
}


/**代理工具*/
#[derive(Debug)]
#[derive(Clone)]
pub struct ParsingDetail {
    pub ip_address: String,
    pub port: String,
}

impl ParsingDetail {
    pub fn env_proxy(proxy_enum: ProxyEnum) -> ProxyResponseEnum {
        let proxy_address = env::var("proxy_address");
        // 使用std::env::var函数获取环境变量的值，如果返回Err，则说明环境变量不存在
        let ip_port = match proxy_address {
            Ok(value) => {
                trace!("环境变量读取成功：key：proxy_address , val：{}", value);
                env::set_var("http_proxy", value.to_string());
                env::set_var("https_proxy", value.to_string());
                value
            }
            Err(_) => {
                trace!("环境变量读取失败:'proxy_address'");
                "".to_string()
            }
        };
        if ip_port.len() > 0 {
            match proxy_enum {
                ProxyEnum::REST => {
                    env::set_var("http_proxy", ip_port.to_string());
                    env::set_var("https_proxy", ip_port.to_string());
                return     ProxyResponseEnum::NO;
                }
                ProxyEnum::WS => {
                    let ip_port: Vec<&str> = ip_port.split(":").collect();
                    let ip_array: Vec<&str> = ip_port[0].split(".").collect();
                    let proxy = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(
                        ip_array[0].parse().unwrap(),
                        ip_array[1].parse().unwrap(),
                        ip_array[2].parse().unwrap(),
                        ip_array[3].parse().unwrap())
                    ), ip_port[1].parse().unwrap());
              return       ProxyResponseEnum::YES(proxy);
                }
            }
        }
        return  ProxyResponseEnum::NO;
    }

    fn new(ip_address: String,
           port: String, ) -> ParsingDetail {
        ParsingDetail { ip_address, port }
    }
    //获取环境变量配置'proxy_address'拿到代理地址
    pub fn parsing_environment_variables() -> ParsingDetail {
        let proxy_address = env::var("proxy_address");
        // 使用std::env::var函数获取环境变量的值，如果返回Err，则说明环境变量不存在
        match proxy_address {
            Ok(value) => {
                //trace!("环境变量读取成功：key：proxy_address , val：{}", value);
                env::set_var("http_proxy", value.to_string());
                env::set_var("https_proxy", value.to_string());

                let ip_port: Vec<&str> = value.split(":").collect();
                let parsing_detail = ParsingDetail::new(ip_port[0].to_string(), ip_port[1].to_string());
                parsing_detail
            }
            Err(_) => {
                trace!("环境变量读取失败:'proxy_address'");
                let parsing_detail = ParsingDetail::new("".to_string(), "".to_string());
                parsing_detail
            }
        }
    }

    //http请求是否开启代理:HTTP 只需要调用该方法即可
    //原理是 设置全局代理，所以程序如果要走代理只需要执行一次，后续的get,post..都会走代理
    pub fn http_enable_proxy() -> bool {
        //拿到环境变量解析的数据
        let parsing_detail = Self::parsing_environment_variables();
        if parsing_detail.ip_address.len() > 0 && parsing_detail.port.len() > 0 {
            let http_proxy = format!("http://{}:{}", parsing_detail.ip_address, parsing_detail.port);
            env::set_var("http_proxy", http_proxy.clone());
            env::set_var("https_proxy", http_proxy.clone());
            //trace!("代理设置成功{0}", http_proxy.to_string());
            true
        } else {
            //trace!("无法开启代理：环境变量获取失败：{:?}", parsing_detail);
            false
        }
    }
}