use std::{
    convert::TryFrom,
    fmt::Display,
    path::{Path, PathBuf},
};

use crate::common::{DataIndex, Relocatable, Section, SectionInfo};
use crate::{common::BSI, error::Error};
use elf_utilities::{file::ELF64, parser::read_elf64};

pub struct ElfObject {
    object_index: usize,
    origin: PathBuf,
    elf: ELF64,
}

impl ElfObject {
    pub fn new(origin: PathBuf, object_index: usize) -> Result<Self, Error> {
        let str_origin = origin
            .as_path()
            .to_str()
            .ok_or(Error::InvalidObjectType(404))?;
        let elf = match read_elf64(str_origin) {
            Ok(val) => val,
            Err(err) => return Err(Error::ParseError(err)),
        };

        is_relocatable(&elf)?;
        let result = ElfObject {
            object_index,
            origin,
            elf,
        };

        Ok(result)
    }
}

impl Relocatable for ElfObject {
    fn new(origin: PathBuf, di: DataIndex) -> Result<Self, Error> {
        ElfObject::new(origin, di.object_index)
    }

    fn origin(&self) -> &Path {
        &self.origin
    }

    fn sections(&self) -> BSI {
        use elf_utilities::section::{Contents64, Type};

        let iter = self
            .elf
            .sections
            .iter()
            .enumerate()
            .filter_map(move |(i, s)| match s.header.get_type() {
                Type::ProgBits => {
                    if s.header.sh_size > 0 {
                        if match &s.contents {
                            Contents64::Raw(v) => Some(v),
                            _ => None,
                        }
                        .is_some()
                        {
                            let si = SectionInfo {
                                file_size: s.header.sh_size,
                                data_size: s.header.sh_size,
                                data_index: Some(DataIndex::new(self.object_index, i)),
                                offset: s.header.sh_offset,
                            };
                            let s_name: &str = &s.name;

                            match Section::try_from((s_name, si)) {
                                Ok(s) => Some(Ok(s)),
                                Err(Error::InvalidSectionName) => None, // skip
                                Err(err) => Some(Err(err)),
                            }
                        } else {
                            Some(Err(Error::InvalidSectionData))
                        }
                    } else {
                        None
                    }
                }
                Type::NoBits => Some(Ok(Section::Bss(SectionInfo {
                    file_size: 0,
                    data_size: s.header.sh_size,
                    data_index: None,
                    offset: s.header.sh_offset,
                }))),
                _ => None,
            });

        Box::new(iter)
    }

    fn section_data(&self, index: DataIndex) -> Result<&[u8], Error> {
        use elf_utilities::section::Contents64;
        let section = &self.elf.sections[index.section_index];

        match &section.contents {
            Contents64::Raw(v) => Ok(&v),
            _ => Err(Error::InvalidSectionData),
        }
    }
}

impl Display for ElfObject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "==={:?}===\n>Symbols:\n{}\n>Sections:\n",
            self.origin().file_name().unwrap(),
            "TODO"
        )?;

        for section in self.sections() {
            let u = section.unwrap();
            write!(f, "{}", u)?;
        }

        Ok(())
    }
}

// impl TryFrom<PathBuf> for ElfObject {
//     type Error = Error;

//     fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
//         Self::new(path)
//     }
// }

fn is_relocatable(elf: &ELF64) -> Result<(), Error> {
    use elf_utilities::header::Type;

    if elf.ehdr.get_type() != Type::Rel {
        return Err(Error::InvalidObjectType(elf.ehdr.e_type.into()));
    }

    Ok(())
}