use super::builder::Builder;
use crate::error::ArchiveError;
use crate::read::{Archive, Handle};
use libarchive3_sys::ffi;
use std::ffi::CString;
use std::path::Path;

const BLOCK_SIZE: usize = 10240;

pub struct ArchiveFile {
    handle: *mut ffi::Struct_archive,
    // entry: ReaderEntry,
}

impl Handle for ArchiveFile {
    unsafe fn handle(&self) -> *const ffi::Struct_archive {
        self.handle as *const _
    }

    unsafe fn handle_mut(&mut self) -> *mut ffi::Struct_archive {
        self.handle
    }
}

impl Drop for ArchiveFile {
    fn drop(&mut self) {
        unsafe {
            ffi::archive_read_free(self.handle_mut());
        }
    }
}

impl Archive for ArchiveFile {
    fn new(handle: *mut ffi::Struct_archive) -> Self {
        Self { handle }
    }

    fn open<P: AsRef<Path>>(mut builder: Builder, path: P) -> crate::Result<Self> {
        builder.check_consumed()?;
        let c_file = CString::new(path.as_ref().to_string_lossy().as_bytes()).unwrap();
        unsafe {
            match ffi::archive_read_open_filename(builder.handle_mut(), c_file.as_ptr(), BLOCK_SIZE)
            {
                ffi::ARCHIVE_OK => {
                    builder.consume();
                    Ok(Self::new(builder.handle_mut()))
                }
                _ => Err(ArchiveError::from(&builder as &dyn Handle)),
            }
        }
    }
}