use server_framework::{Decode, Encode};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CapabilityKind {
    Display,
    Input,
    AudioPlayback,
    AudioCapture,
    Camera,
    Storage,
    Network,
    Gps,
    Bluetooth,
}

#[derive(Debug, PartialEq)]
pub enum PermissionRequest {
    RequestCapability { process: u16, kind: CapabilityKind },
    RevokeCapability { process: u16, kind: CapabilityKind },
    CheckCapability { process: u16, kind: CapabilityKind },
    ListGranted { process: u16 },
}

#[derive(Debug, PartialEq)]
pub enum PermissionResponse {
    Granted,
    Denied,
    Revoked,
    HasCapability(bool),
    GrantedList(u16),
}

fn encode_kind(kind: CapabilityKind) -> usize {
    match kind {
        CapabilityKind::Display => 0,
        CapabilityKind::Input => 1,
        CapabilityKind::AudioPlayback => 2,
        CapabilityKind::AudioCapture => 3,
        CapabilityKind::Camera => 4,
        CapabilityKind::Storage => 5,
        CapabilityKind::Network => 6,
        CapabilityKind::Gps => 7,
        CapabilityKind::Bluetooth => 8,
    }
}

fn decode_kind(v: usize) -> Option<CapabilityKind> {
    match v {
        0 => Some(CapabilityKind::Display),
        1 => Some(CapabilityKind::Input),
        2 => Some(CapabilityKind::AudioPlayback),
        3 => Some(CapabilityKind::AudioCapture),
        4 => Some(CapabilityKind::Camera),
        5 => Some(CapabilityKind::Storage),
        6 => Some(CapabilityKind::Network),
        7 => Some(CapabilityKind::Gps),
        8 => Some(CapabilityKind::Bluetooth),
        _ => None,
    }
}

impl Encode for PermissionRequest {
    fn encode(&self) -> [usize; 4] {
        match self {
            PermissionRequest::RequestCapability { process, kind } => {
                [0, *process as usize, encode_kind(*kind), 0]
            }
            PermissionRequest::RevokeCapability { process, kind } => {
                [1, *process as usize, encode_kind(*kind), 0]
            }
            PermissionRequest::CheckCapability { process, kind } => {
                [2, *process as usize, encode_kind(*kind), 0]
            }
            PermissionRequest::ListGranted { process } => {
                [3, *process as usize, 0, 0]
            }
        }
    }
}

impl Decode for PermissionRequest {
    fn decode(words: [usize; 4]) -> Option<Self> {
        match words[0] {
            0 => Some(PermissionRequest::RequestCapability {
                process: words[1] as u16,
                kind: decode_kind(words[2])?,
            }),
            1 => Some(PermissionRequest::RevokeCapability {
                process: words[1] as u16,
                kind: decode_kind(words[2])?,
            }),
            2 => Some(PermissionRequest::CheckCapability {
                process: words[1] as u16,
                kind: decode_kind(words[2])?,
            }),
            3 => Some(PermissionRequest::ListGranted {
                process: words[1] as u16,
            }),
            _ => None,
        }
    }
}

impl Encode for PermissionResponse {
    fn encode(&self) -> [usize; 4] {
        match self {
            PermissionResponse::Granted => [0, 0, 0, 0],
            PermissionResponse::Denied => [1, 0, 0, 0],
            PermissionResponse::Revoked => [2, 0, 0, 0],
            PermissionResponse::HasCapability(has) => [3, *has as usize, 0, 0],
            PermissionResponse::GrantedList(bits) => [4, *bits as usize, 0, 0],
        }
    }
}

impl Decode for PermissionResponse {
    fn decode(words: [usize; 4]) -> Option<Self> {
        match words[0] {
            0 => Some(PermissionResponse::Granted),
            1 => Some(PermissionResponse::Denied),
            2 => Some(PermissionResponse::Revoked),
            3 => Some(PermissionResponse::HasCapability(words[1] != 0)),
            4 => Some(PermissionResponse::GrantedList(words[1] as u16)),
            _ => None,
        }
    }
}