use memmap2::*;
use serde::Serialize;

use crate::{app_error::AppError, pe_parse::{header::{ImageDosHeader, ImageFileHeader, ImageNTHeaders, ImageNTHeaders32, ImageOptionalHeader}, pe::PE}};

use super::{GLOBAL_FILE_DATA, GLOBAL_IS_64_BIT};

pub fn mmap_mut_file(file_path: &str) -> Result<Mmap, std::io::Error> {
    let file = std::fs::OpenOptions::new().read(true).open(file_path)?;

    unsafe {
        MmapOptions::new()
        .map(&file)
            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
    }
}


#[derive(Serialize)]
pub struct ResponseDOSHeaderData {
    pub fields: ImageDosHeader,
    pub base_offset: usize,
}

#[derive(Serialize)]
pub struct ResponseNTHeaderData {
    fields: ImageNTHeaders,
    base_offset: usize,
}

pub fn get_nt_headers_data<'a>() -> Result<ResponseNTHeaderData, AppError> {
        // pub static GLOBAL_FILE_DATA: Mutex<Option<PeData>> = Mutex::new(None);
        let binding = GLOBAL_FILE_DATA.lock().unwrap();
        // `binding` does not live long enough borrowed value does not live long enough
        let file_data = binding.as_ref().unwrap();
        let nt_header_enmu= file_data.get_nt_headers()?;
        let nt_offset = file_data.get_nt_headers_offset()?;
        let result = ResponseNTHeaderData {
            fields: nt_header_enmu,
            base_offset: nt_offset,
        };
        Ok(result)
}

// 获取文件头数据
#[derive(Serialize)]
pub struct ResponseFileHeaderData {
    pub fields: ImageFileHeader,
    pub base_offset: usize,
}

pub fn get_file_header_data() -> Result<ResponseFileHeaderData, AppError> {
    let binding = GLOBAL_FILE_DATA.lock().unwrap();
    let file_data = binding.as_ref().unwrap();
    let file_header = file_data.get_file_header()?;
    let file_header_offset = file_data.get_file_header_offset()?;
    let result = ResponseFileHeaderData {
        fields: file_header.clone(),
        base_offset: file_header_offset,
    };
    Ok(result)
}
// 获取可选头数据
#[derive(Serialize)]
pub struct ResponseOptionalHeaderData {
    pub fields: ImageOptionalHeader,
    pub base_offset: usize,
}


pub fn get_optional_header_data() -> Result<ResponseOptionalHeaderData, AppError> {
    let binding = GLOBAL_FILE_DATA.lock().unwrap();
    let file_data = binding.as_ref().unwrap();
    let optional_header = file_data.get_optional_header()?;
    let optional_header_offset = file_data.get_optional_header_offset()?;
    let result = ResponseOptionalHeaderData {
        fields: optional_header.clone(),
        base_offset: optional_header_offset,
    };
    Ok(result)
}