use json::{array, JsonValue, object};
use log::info;
use redis::{Commands, RedisResult, Connection, Client};
use crate::CacheBase;


#[derive(Clone)]
pub struct Redis {
    client: Client,
    db: i8,
}

impl Redis {
    pub fn connect(dsn: String) -> Self {
        // 读取配置
        let client = Client::open(dsn);
        return match client {
            Ok(client) => {
                Self {
                    client,
                    db: 0,
                }
            }
            Err(e) => {
                info!("开启错误: {}", e);
                Self {
                    client: None.unwrap(),
                    db: 0,
                }
            }
        };
    }
    pub fn con(&mut self) -> Connection {
        let mut conn = self.client.get_connection().unwrap();
        redis::pipe().cmd("SELECT").arg(self.db).execute(&mut conn);
        conn
    }
}

impl CacheBase for Redis {
    /// 切换到指定的数据库
    fn db(&mut self, db: i8) -> &mut Self {
        self.db = db;
        self
    }

    /// 设置
    ///
    /// * time 过期时间 s 秒
    fn set(&mut self, key: &str, value: JsonValue, time: usize) -> bool {
        let data: RedisResult<bool> = {
            if time > 0 {
                self.con().set_ex(key, value.to_string(), time)
            } else {
                self.con().set(key, value.to_string())
            }
        };
        return match data {
            Ok(_) => {
                true
            }
            Err(e) => {
                info!("{}", e);
                false
            }
        };
    }
    /// 集合 添加
    fn set_list(&mut self, key: &str, value: JsonValue) -> bool {
        let data: RedisResult<bool> = self.con().sadd(key, value.to_string());
        return match data {
            Ok(_) => {
                true
            }
            Err(_e) => {
                false
            }
        };
    }

    /// 删除
    fn del(&mut self, key: &str) -> bool {
        let data: RedisResult<bool> = self.con().del(key);
        return match data {
            Ok(_) => {
                true
            }
            Err(e) => {
                info!("{}", e);
                false
            }
        };
    }
    /// 获取
    fn get(&mut self, key: &str) -> JsonValue {
        let data: RedisResult<String> = self.con().get(key);
        return match data {
            Ok(e) => {
                JsonValue::from(e)
            }
            Err(_) => {
                JsonValue::from("")
            }
        };
    }
    /// 获取
    fn keys(&mut self, key: &str) -> JsonValue {
        let data: RedisResult<Vec<String>> = self.con().keys(key);
        return match data {
            Ok(e) => {
                JsonValue::from(e)
            }
            Err(_) => {
                array![]
            }
        };
    }
    /// 集合 获取
    fn get_list(&mut self, key: &str) -> JsonValue {
        let data: RedisResult<Vec<String>> = self.con().smembers(key);
        return match data {
            Ok(e) => {
                JsonValue::from(e)
            }
            Err(_) => {
                array![]
            }
        };
    }
    /// 设置消息队列
    fn set_message_queue(&mut self, key: &str, value: JsonValue) -> bool {
        let data: RedisResult<String> = self.con().xadd(key, "*", &[(value.to_string(), value.to_string())]);
        match data {
            Ok(_) => {
                return true;
            }
            Err(_) => {
                return false;
            }
        }
    }

    /// 消息队列获取
    fn get_message_queue(&mut self, key: &str) -> JsonValue {
        let data: RedisResult<Vec<String>> = self.con().xread(&[key], &[0]);
        return match data {
            Ok(e) => {
                JsonValue::from(e)
            }
            Err(_) => {
                array![]
            }
        };
    }
    // /// 订阅消息
    // pub fn subscribe_s(&mut self, channel: &str, fun: fn(channel: &str, data: &str)) {
    //     let mut pubsub = self.con.as_pubsub();
    //     pubsub.subscribe(channel).unwrap();
    //     loop {
    //         let msg = pubsub.get_message().unwrap();
    //         // 消息处理
    //         let data: String = msg.get_payload().unwrap();
    //         let channel = msg.get_channel_name();
    //         fun(channel, data.as_str())
    //     }
    // }
    // /// 发布消息
    // pub fn publish(&mut self, key: &str, value: JsonValue) -> bool {
    //     let data = self.con.publish(key, value.to_string());
    //     return match data {
    //         Ok(e) => {
    //             e
    //         }
    //         Err(_e) => {
    //             false
    //         }
    //     };
    // }

    /// 获取对象集合
    fn get_object(&mut self, key: &str) -> JsonValue {
        let data: RedisResult<Vec<String>> = self.con().hgetall(key);
        match data {
            Ok(e) => {
                let mut list = object! {};
                let mut index = 0;
                while index < e.len() {
                    list[e[index.clone()].to_string()] = e[index + 1].clone().into();
                    index += 2;
                }
                return list;
            }
            Err(_e) => {
                return object! {};
            }
        }
    }
    /// 设置对象集合
    fn set_object(&mut self, key: &str, field: &str, value: JsonValue) -> bool {
        let data: RedisResult<bool> = self.con().hset(key, field, value.to_string());
        return match data {
            Ok(_) => {
                true
            }
            Err(e) => {
                info!("{}", e);
                false
            }
        };
    }
}