use server_framework::Server;

use crate::filesystem::{FileSystem, DirEntry};
use crate::protocol::{StorageRequest, StorageResponse};

pub struct StorageServer<F: FileSystem> {
    fs: F,
}

impl<F: FileSystem> StorageServer<F> {
    pub fn new(fs: F) -> Self {
        Self { fs }
    }

    pub fn filesystem(&self) -> &F {
        &self.fs
    }
}

impl<F: FileSystem> Server for StorageServer<F> {
    type Request = StorageRequest;
    type Response = StorageResponse;

    fn handle(&mut self, request: StorageRequest) -> StorageResponse {
        match request {
            StorageRequest::Open { path } => {
                let buf = path.to_bytes();
                let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
                match self.fs.open(&buf[..len]) {
                    Some(h) => StorageResponse::Handle(h),
                    None => StorageResponse::NotFound,
                }
            }
            StorageRequest::Read { handle, max_bytes } => {
                let mut buf = [0u8; 512];
                let read_len = max_bytes.min(buf.len());
                match self.fs.read(handle, &mut buf[..read_len]) {
                    Some(n) => StorageResponse::Data { bytes_read: n },
                    None => StorageResponse::Error,
                }
            }
            StorageRequest::Write { handle, data_word } => {
                let data = data_word.to_le_bytes();
                match self.fs.write(handle, &data) {
                    Some(n) => StorageResponse::Written { bytes_written: n },
                    None => StorageResponse::Error,
                }
            }
            StorageRequest::Close { handle } => {
                self.fs.close(handle);
                StorageResponse::Ok
            }
            StorageRequest::ListDir { path } => {
                let buf = path.to_bytes();
                let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
                let mut entries = [DirEntry::empty(); 16];
                match self.fs.list_dir(&buf[..len], &mut entries) {
                    Some(count) => StorageResponse::DirEntries { count },
                    None => StorageResponse::NotFound,
                }
            }
            StorageRequest::Create { path } => {
                let buf = path.to_bytes();
                let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
                match self.fs.create(&buf[..len]) {
                    Some(h) => StorageResponse::Handle(h),
                    None => StorageResponse::Error,
                }
            }
            StorageRequest::Delete { path } => {
                let buf = path.to_bytes();
                let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
                if self.fs.delete(&buf[..len]) {
                    StorageResponse::Ok
                } else {
                    StorageResponse::NotFound
                }
            }
            StorageRequest::FileSize { handle } => {
                match self.fs.file_size(handle) {
                    Some(size) => StorageResponse::Size(size),
                    None => StorageResponse::Error,
                }
            }
        }
    }
}