use crate::file::{ArchiveFile, ArchiveFileRead, ArchiveFileWrite};
use crate::result::{ArchiveError, ArchiveResult};
use chrono::NaiveDateTime;
use std::io::{Read, Write};

pub struct GeneralPurposeBitFlag {}

pub enum CompressionMethod {
    Store,
    Deflate,
    Bzip2,
    LZMA,
    Zstandard,
}

impl TryFrom<u16> for CompressionMethod {
    type Error = ArchiveError;

    fn try_from(value: u16) -> ArchiveResult<Self> {
        Ok(match value {
            0 => Self::Store,
            8 => Self::Deflate,
            12 => Self::Bzip2,
            14 => Self::LZMA,
            93 | 20 => Self::Zstandard,
            _ => return Err(ArchiveError::UnsupportedCompressionMethod { method: value }),
        })
    }
}

pub struct FileInfo {
    number: u64,
    version_made_by: u16,
    version_needed: u16,
    general_purpose_bit_flag: GeneralPurposeBitFlag,
    compression_method: CompressionMethod,
    file_modified_at: NaiveDateTime,
    crc32: u32,
    compressed_size: u64,
    uncompressed_size: u64,
    name: String,
    comment: String,
    header_offset: u64,
}

impl FileInfo {
    pub fn new(
        number: u64,
        version_made_by: u16,
        version_needed: u16,
        general_purpose_bit_flag: GeneralPurposeBitFlag,
        compression_method: CompressionMethod,
        file_modified_at: NaiveDateTime,
        crc32: u32,
        compressed_size: u64,
        uncompressed_size: u64,
        name: String,
        comment: String,
        header_offset: u64,
    ) -> Self {
        Self {
            number,
            version_made_by,
            version_needed,
            general_purpose_bit_flag,
            compression_method,
            file_modified_at,
            crc32,
            compressed_size,
            uncompressed_size,
            name,
            comment,
            header_offset,
        }
    }
}

pub struct FileReader {
    info: FileInfo,
}

impl ArchiveFile for FileReader {
    type Info = FileInfo;

    fn new(info: Self::Info) -> Self {
        Self { info }
    }
}

impl Read for FileReader {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        todo!()
    }
}

impl ArchiveFileRead for FileReader {}

impl FileReader {}

pub struct FileWriter {
    info: FileInfo,
}

impl ArchiveFile for FileWriter {
    type Info = FileInfo;

    fn new(info: Self::Info) -> Self {
        Self { info }
    }
}

impl Write for FileWriter {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        todo!()
    }

    fn flush(&mut self) -> std::io::Result<()> {
        todo!()
    }
}

impl ArchiveFileWrite for FileWriter {}

impl FileWriter {}