use crate::webdav::dav_metadata::MarkBaseDavMetaData;
use bytes::{Buf, Bytes};
use dav_server::fs::{DavFile, DavMetaData, FsError, FsFuture};
use std::sync::Mutex;

#[derive(Debug)]
pub struct MarkBaseDavFile {
    content: Mutex<FileContent>,
}

#[derive(Debug)]
struct FileContent {
    data: Vec<u8>,
    position: u64,
}

impl MarkBaseDavFile {
    pub fn new(data: Vec<u8>) -> Self {
        Self {
            content: Mutex::new(FileContent { data, position: 0 }),
        }
    }
}

impl DavFile for MarkBaseDavFile {
    fn metadata(&'_ mut self) -> FsFuture<'_, Box<dyn DavMetaData>> {
        let content = self.content.lock().unwrap();
        let len = content.data.len() as u64;
        Box::pin(std::future::ready(Ok(
            Box::new(MarkBaseDavMetaData::new(len, false)) as Box<dyn DavMetaData>,
        )))
    }

    fn write_buf(&'_ mut self, _buf: Box<dyn Buf + Send>) -> FsFuture<'_, ()> {
        Box::pin(std::future::ready(Err(FsError::NotImplemented)))
    }

    fn write_bytes(&'_ mut self, _buf: Bytes) -> FsFuture<'_, ()> {
        Box::pin(std::future::ready(Err(FsError::NotImplemented)))
    }

    fn read_bytes(&'_ mut self, count: usize) -> FsFuture<'_, Bytes> {
        let mut content = self.content.lock().unwrap();

        let start = content.position as usize;
        let end = std::cmp::min(start + count, content.data.len());

        if start >= content.data.len() {
            Box::pin(std::future::ready(Ok(Bytes::new())))
        } else {
            let bytes = Bytes::copy_from_slice(&content.data[start..end]);
            content.position = end as u64;
            Box::pin(std::future::ready(Ok(bytes)))
        }
    }

    fn seek(&'_ mut self, pos: std::io::SeekFrom) -> FsFuture<'_, u64> {
        let mut content = self.content.lock().unwrap();

        let new_pos = match pos {
            std::io::SeekFrom::Start(offset) => offset,
            std::io::SeekFrom::Current(offset) => {
                let current = content.position as i64;
                (current + offset) as u64
            }
            std::io::SeekFrom::End(offset) => {
                let end = content.data.len() as i64;
                (end + offset) as u64
            }
        };

        content.position = new_pos;
        Box::pin(std::future::ready(Ok(new_pos)))
    }

    fn flush(&'_ mut self) -> FsFuture<'_, ()> {
        Box::pin(std::future::ready(Ok(())))
    }
}