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

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

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

impl ElfObject {
    pub fn new(storage: &mut Storage) -> Result<Self, Error> {
        let origin = storage.origin()?;
        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 { origin, elf };

        Ok(result)
    }
}

impl Relocatable for ElfObject {
    fn origin(&self) -> &Path {
        &self.origin
    }

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

        let iter = self
            .elf
            .sections
            .iter()
            .filter_map(|s| match s.header.get_type() {
                Type::ProgBits => {
                    if s.header.sh_size > 0 {
                        if let Some(di) = match &s.contents {
                            Contents64::Raw(v) => Some(v.iter()),
                            _ => None,
                        } {
                            let si = SectionInfo {
                                size: s.header.sh_size,
                                data: Some(Box::new(di.copied())),
                                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 {
                    size: 0,
                    data: None,
                    offset: s.header.sh_offset,
                }))),
                _ => None,
            });

        Box::new(iter)
    }
}

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(())
    }
}

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(())
}