use std::{fmt::Display, path::PathBuf};

use crate::{
    common::{DataIndex, Loadable, Output, Relocatable},
    error::Error,
};

pub struct Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    relocatables: Vec<R>,
    loadable: Loadable,
    output: O,
}

impl<R, O> Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    pub fn new(output: O) -> Self {
        Self {
            relocatables: Vec::new(),
            loadable: Loadable::default(),
            output,
        }
    }

    pub fn add_relocatable(&mut self, origin: PathBuf) -> Result<(), Error> {
        let r = R::new(origin, DataIndex::for_object(self.relocatables.len()))?;

        // TODO: parallelize?
        for s in r.sections() {
            self.loadable.process_section(s?)?;
        }

        self.relocatables.push(r);

        Ok(())
    }

    pub fn link(mut self) -> Result<PathBuf, Error> {
        self.loadable.start_offset = Some(4096); // TODO: get from .start symbol location
        self.output.finalize(&self.relocatables, &self.loadable)
    }

    // pub fn object_path(origin: &Path) -> Result<PathBuf, Error> {
    //     let mut dest = std::fs::canonicalize(origin)?;
    //     if !dest.pop() {
    //         let err = std::io::Error::new(ErrorKind::Other, "Destination path invalid");
    //         Err(Error::IOError(Box::new(err)))
    //     } else {
    //         dest.push("rld.out");
    //         Ok(dest)
    //     }
    // }
}

impl<R, O> Display for Linker<R, O>
where
    R: Relocatable,
    O: Output<R>,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "===Relocatables===")?;

        for r in self.relocatables.iter() {
            write!(f, "{}", r)?;
        }

        Ok(())
    }
}