use server_framework::{Decode, Encode};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LogLevel {
    Error,
    Warn,
    Info,
    Debug,
}

#[derive(Debug, PartialEq)]
pub enum LogRequest {
    Write { level: LogLevel, tag: u16, payload: usize },
    GetCount,
    GetEntry { index: usize },
}

#[derive(Debug, PartialEq)]
pub enum LogResponse {
    Ok,
    Count(usize),
    Entry { level: LogLevel, tag: u16, payload: usize },
    NotFound,
}

fn encode_level(level: LogLevel) -> usize {
    match level {
        LogLevel::Error => 0,
        LogLevel::Warn => 1,
        LogLevel::Info => 2,
        LogLevel::Debug => 3,
    }
}

fn decode_level(v: usize) -> Option<LogLevel> {
    match v {
        0 => Some(LogLevel::Error),
        1 => Some(LogLevel::Warn),
        2 => Some(LogLevel::Info),
        3 => Some(LogLevel::Debug),
        _ => None,
    }
}

impl Encode for LogRequest {
    fn encode(&self) -> [usize; 4] {
        match self {
            LogRequest::Write { level, tag, payload } => {
                [0, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
            }
            LogRequest::GetCount => [1, 0, 0, 0],
            LogRequest::GetEntry { index } => [2, *index, 0, 0],
        }
    }
}

impl Decode for LogRequest {
    fn decode(words: [usize; 4]) -> Option<Self> {
        match words[0] {
            0 => {
                let level = decode_level(words[1] & 0xFF)?;
                let tag = ((words[1] >> 8) & 0xFFFF) as u16;
                Some(LogRequest::Write { level, tag, payload: words[2] })
            }
            1 => Some(LogRequest::GetCount),
            2 => Some(LogRequest::GetEntry { index: words[1] }),
            _ => None,
        }
    }
}

impl Encode for LogResponse {
    fn encode(&self) -> [usize; 4] {
        match self {
            LogResponse::Ok => [0, 0, 0, 0],
            LogResponse::Count(n) => [1, *n, 0, 0],
            LogResponse::Entry { level, tag, payload } => {
                [2, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
            }
            LogResponse::NotFound => [3, 0, 0, 0],
        }
    }
}

impl Decode for LogResponse {
    fn decode(words: [usize; 4]) -> Option<Self> {
        match words[0] {
            0 => Some(LogResponse::Ok),
            1 => Some(LogResponse::Count(words[1])),
            2 => {
                let level = decode_level(words[1] & 0xFF)?;
                let tag = ((words[1] >> 8) & 0xFFFF) as u16;
                Some(LogResponse::Entry { level, tag, payload: words[2] })
            }
            3 => Some(LogResponse::NotFound),
            _ => None,
        }
    }
}