// #![allow(incomplete_features)]
// #![feature(unsized_locals)]
mod structs;
use crate::structs::{ElfHeader, ElfSectionHeader};
use std::io::Read;

#[repr(C)]
#[derive(Debug)]
struct Elf {
    header: &'static ElfHeader,
    sections: &'static [ElfSectionHeader],
    strtab: *const u8,
}

impl Elf {
    pub fn new(bytes: &[u8]) -> Elf {
        let header = unsafe { &*(bytes.as_ptr() as *const ElfHeader) };
        assert_eq!(&header.ident.magic, b"\x7fELF");

        let sections = unsafe {
            std::slice::from_raw_parts(
                bytes.as_ptr().add(header.shoff as usize) as *const ElfSectionHeader,
                header.shnum as usize,
            )
        };

        let strtab = unsafe {
            bytes
                .as_ptr()
                .add((&sections[header.shstrndx as usize]).offset as usize)
        };

        // for sec in sections {
        //     println!("{:?}", unsafe { std::ffi::CStr::from_ptr(
        //         strtab.add(sec.name as usize) as *const i8
        //     )});
        // }
        Elf {
            header,
            sections,
            strtab,
        }
    }
}

// readelf behavior here
impl std::fmt::Display for Elf {
    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("ELF Header:\n")?;
        formatter.write_fmt(format_args!("{}\n", self.header))?;

        formatter.write_str("Section Headers:\n")?;
        formatter
            .write_str("  [Nr] Name              Type             Address           Offset\n")?;
        formatter
            .write_str("       Size              EntSize          Flags  Link  Info  Align\n")?;

        for (i, section) in self.sections.iter().enumerate() {
            let name = unsafe {
                std::ffi::CStr::from_ptr(self.strtab.add(section.name as usize) as *const i8)
                    .to_str()
                    .expect("Bad section name")
            };
            formatter.write_fmt(format_args!("  [{: >2}] {: <17.17} {}\n", i, name, section))?;
        }

        formatter.write_str("Key to Flags:\n")?;
        formatter.write_str("  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n")?;
        formatter.write_str("  L (link order), O (extra OS processing required), G (group), T (TLS),\n")?;
        formatter.write_str("  C (compressed), x (unknown), o (OS specific), E (exclude),\n")?;
        formatter.write_str("  D (mbind), l (large), p (processor specific)\n")?;
        Ok(())
    }
}

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let buffer = {
        let mut f = std::fs::File::open(&args[1]).expect("no file found");
        let metadata = std::fs::metadata(&args[1]).expect("unable to read metadata");
        let mut buffer = vec![0; metadata.len() as usize];
        f.read(&mut buffer).expect("buffer overflow");
        buffer
    };
    let elf = Elf::new(&buffer[..]);
    println!("{}", elf);
}