use super::model::*;
use axum::extract::ws::{CloseFrame, Message, WebSocket};
use redis::{TypedCommands, cmd};

#[deprecated]
pub async fn send_close_message(mut socket: WebSocket, code: u16, reason: &str) {
    _ = socket
        .send(Message::Close(Some(CloseFrame {
            code,
            reason: reason.into(),
        })))
        .await;
}

#[deprecated]
pub async fn fetch_content_from_redis(redis: redis::Client, key: &str) -> Result<String, String> {
    let mut rcli = redis.clone();
    match rcli.get(key) {
        Ok(s) => {
            if let Some(res) = s {
                Ok(res)
            } else {
                Err(format!("result error from key: {key}"))
            }
        }
        Err(e) => Err(format!("redis get failed: {e}")),
    }
}

pub async fn fetch_content_from_redis_byte(
    redis: redis::Client,
    key: &str,
) -> Result<Vec<u8>, String> {
    let mut conn = match redis.get_connection() {
        Ok(cnn) => cnn,
        Err(e) => {
            println!("get connection fail, {e}");
            return Ok(vec![]);
        }
    };

    let res = cmd("GET").arg(key).query::<Vec<u8>>(&mut conn);

    match res {
        Ok(res) => Ok(res),
        Err(e) => {
            println!("get fail, {e}");
            return Ok(vec![]);
        }
    }
}

#[deprecated]
pub fn convert_ack_command(cmd_req: &serde_json::Value) -> Option<CommandRequestPayload> {
    match serde_json::from_value(cmd_req.clone()) {
        Ok(req) => Some(req),
        Err(_) => None,
    }
}

pub fn convert_sys_msg_command(msg: &serde_json::Value) -> Option<SysMessage> {
    match serde_json::from_value(msg.clone()) {
        Ok(req) => Some(req),
        Err(_) => None,
    }
}