neutauri/neutauri_runtime/src/data.rs

use bincode::Options;
use serde::{Deserialize, Serialize};
use std::{
    fs,
    io::{self, Read, Result, Seek, SeekFrom},
    path::{self, Component, Path, PathBuf},
};
use wry::application::{
    dpi::{Position, Size}
};

const MAGIC_NUMBER_START: &[u8; 9] = b"NEUTFSv01";
const MAGIC_NUMBER_END: &[u8; 9] = b"NEUTFSEnd";
const USIZE_LEN: usize = usize::MAX.to_be_bytes().len();

#[non_exhaustive]
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum Compress {
    Brotli,
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct File {
    mime: String,
    data: Vec<u8>,
    compress: Compress,
}

#[derive(Serialize, Deserialize, Debug)]
struct Dir {
    files: Vec<(String, File)>,
    dirs: Vec<(String, Dir)>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Data {
    fs: Dir,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Icon {
    rgba: Vec<u8>,
    width: u32,
    height: u32,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct WindowAttr {
    pub inner_size: Option<Size>,
    pub min_inner_size: Option<Size>,
    pub max_inner_size: Option<Size>,
    pub position: Option<Position>,
    pub resizable: bool,
    pub fullscreen: bool,
    pub title: String,
    pub maximized: bool,
    pub visible: bool,
    pub transparent: bool,
    pub decorations: bool,
    pub always_on_top: bool,
    pub window_icon: Option<Icon>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct WebViewAttr {
    pub visible: bool,
    pub transparent: bool,
    pub url: Option<String>,
    pub html: Option<String>,
    pub initialization_scripts: Vec<String>,
}

impl File {
    pub fn decompressed_data(&mut self) -> Result<Vec<u8>> {
        let mut data = Vec::with_capacity(self.data.len());
        //brotli::BrotliDecompress(&mut self.data, &mut data);
        let mut r = brotli::Decompressor::new(self.data.as_slice(), 4096);
        r.read_to_end(&mut data)?;
        Ok(data)
    }
    pub fn mimetype(&self) -> String {
        self.mime.clone()
    }
}

impl Dir {
    // 使用本地文件系统填充 Dir 结构体
    fn fill_with<P: AsRef<path::Path>>(
        &mut self,
        root: P,
        path: P,
        length: &mut u64,
    ) -> Result<()> {
        // 遍历目录
        for entry in fs::read_dir(path)? {
            let path = entry?.path();
            // 获取目录/文件名，如果为".."则跳过
            let name = match path.file_name() {
                Some(s) => match s.to_str() {
                    Some(s) => s.to_string(),
                    None => break,
                },
                None => break,
            };
            // 优先填充文件
            if path.is_file() {
                let mut source = fs::File::open(&path)?;
                let mime = new_mime_guess::from_path(&path)
                    .first_or_octet_stream()
                    .to_string();
                let mut data = brotli::CompressorReader::new(&mut source, 4096, 9, 21);
                let mut buffer = Vec::new();
                data.read_to_end(&mut buffer)?;
                let size = buffer.len();
                let file = File {
                    mime,
                    data: buffer,
                    compress: Compress::Brotli,
                };
                *length += size as u64;
                self.files.push((name, file));
            } else if path.is_dir() {
                // 构造子目录
                let mut dir = Dir {
                    files: Vec::new(),
                    dirs: Vec::new(),
                };
                // 填充子目录
                dir.fill_with(root.as_ref(), &path, length)?;
                self.dirs.push((name, dir));
            }
        }
        Ok(())
    }
}

impl Data {
    pub fn build_from_dir<P: AsRef<path::Path>>(source: P) -> Result<Vec<u8>> {
        let embed_fs = Self::from_dir(source)?;
        embed_fs.build()
    }

    fn from_dir<P: AsRef<path::Path>>(source: P) -> Result<Self> {
        let source = source.as_ref();
        let mut length: u64 = 0;
        let mut dir = Dir {
            files: Vec::new(),
            dirs: Vec::new(),
        };
        dir.fill_with(source, source, &mut length)?;
        Ok(Self { fs: dir })
    }

    fn build(self) -> Result<Vec<u8>> {
        let serialize_options = bincode::DefaultOptions::new()
            .with_fixint_encoding()
            .allow_trailing_bytes()
            .with_limit(104857600 /* 100MiB */);
        // 构建文件头
        let data = match serialize_options.serialize(&self) {
            Ok(vec) => vec,
            Err(e) => {
                return Err(io::Error::new(io::ErrorKind::InvalidData, e));
            }
        };

        let mut target: Vec<u8> = Vec::new();
        target.extend(MAGIC_NUMBER_START);
        target.extend(&data.len().to_be_bytes());
        target.extend(&data);
        let target_length = target.len();
        let target_length = target_length + USIZE_LEN;
        let target_length = target_length + MAGIC_NUMBER_END.len();
        target.extend(target_length.to_be_bytes());
        target.extend(MAGIC_NUMBER_END);

        Ok(target)
    }

    pub fn pack<P: AsRef<path::Path>>(source: P, target: P) -> Result<()> {
        fs::write(target, Self::build_from_dir(source)?)?;
        Ok(())
    }

    pub fn new<P: AsRef<path::Path> + Copy>(path: P) -> Result<Self> {
        let mut base = fs::File::open(path)?;
        let base_length = base.metadata()?.len();
        let mut magic_number_start_data = [0; MAGIC_NUMBER_START.len()];
        let mut data_length_data = [0; USIZE_LEN];
        let mut data = Vec::new();
        let mut magic_number_end_data = [0; MAGIC_NUMBER_END.len()];
        base.seek(SeekFrom::Start(base_length - MAGIC_NUMBER_END.len() as u64))?;
        // 此时指针指向 MAGIC_NUMBER_END 之前
        base.read_exact(&mut magic_number_end_data)?;
        if &magic_number_end_data != MAGIC_NUMBER_END {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "MAGIC_NUMBER_END not found",
            ));
        }
        base.seek(SeekFrom::Start(
            base_length - MAGIC_NUMBER_END.len() as u64 - USIZE_LEN as u64,
        ))?;
        // 此时指针指向 data_length 之前
        base.read_exact(&mut data_length_data)?;
        base.seek(SeekFrom::Start(
            base_length - u64::from_be_bytes(data_length_data),
        ))?;
        // 此时指针指向 MAGIC_NUMBER_START
        base.read_exact(&mut magic_number_start_data)?;
        if &magic_number_start_data != MAGIC_NUMBER_START {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "MAGIC_NUMBER_START not found",
            ));
        }
        base.read_exact(&mut data_length_data)?;
        // 此时指针指向 Data 前
        base.take(u64::from_be_bytes(data_length_data))
            .read_to_end(&mut data)?;
        fs::write("test2", &data)?;
        let serialize_options = bincode::DefaultOptions::new()
            .with_fixint_encoding()
            .allow_trailing_bytes()
            .with_limit(104857600 /* 100MiB */);
        let fs: Self = match serialize_options.deserialize(&data) {
            Ok(fs) => fs,
            Err(e) => {
                return Err(io::Error::new(io::ErrorKind::InvalidData, e));
            }
        };
        Ok(fs)
    }

    fn open_file(&self, current_dir: &Dir, mut path: path::Iter) -> Result<File> {
        let next_path = match path.next() {
            Some(str) => str.to_string_lossy().to_string(),
            None => return Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
        };
        for (name, file) in &current_dir.files {
            if next_path == *name {
                return Ok(file.clone());
            }
        }
        for (name, dir) in &current_dir.dirs {
            if next_path == *name {
                return self.open_file(dir, path);
            }
        }
        Err(io::Error::new(io::ErrorKind::NotFound, "file not found"))
    }

    pub fn open<P: AsRef<path::Path>>(&self, path: P) -> Result<File> {
        let path = normalize_path(path.as_ref());
        let path = if path.starts_with("/") {
            path.strip_prefix("/")
                .unwrap_or_else(|_| Path::new(""))
                .to_path_buf()
        } else {
            path
        };
        self.open_file(&self.fs, path.iter())
    }
}

pub fn load<P: AsRef<path::Path> + Copy>(path: P) -> Result<Data> {
    Data::new(path)
}

pub fn pack<P: AsRef<path::Path>>(source: P, target: P) -> Result<()> {
    Data::pack(source, target)
}

fn normalize_path(path: &Path) -> PathBuf {
    let mut components = path.components().peekable();
    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
        components.next();
        PathBuf::from(c.as_os_str())
    } else {
        PathBuf::new()
    };

    for component in components {
        match component {
            Component::Prefix(..) => unreachable!(),
            Component::RootDir => {
                ret.push(component.as_os_str());
            }
            Component::CurDir => {}
            Component::ParentDir => {
                ret.pop();
            }
            Component::Normal(c) => {
                ret.push(c);
            }
        }
    }
    ret
}