use std::fmt::{self, Debug, Display};
use std::rc::Rc;

use gc::{Finalize, Trace};

use crate::obj::macros::*;
use crate::obj::prelude::*;
use crate::obj::BaseObj;
use crate::vm::Chunk;

#[derive(Trace, Finalize)]
pub struct Module {
    base: BaseObj,
    #[unsafe_ignore_trace]
    path: Rc<String>,
    #[unsafe_ignore_trace]
    chunk: Rc<Chunk>,
    globals: Vec<String>,
    evaluated_value: Option<ObjP>,
}

impl Module {
    pub fn new(path: impl ToString, chunk: Rc<Chunk>, globals: Vec<String>) -> Self {
        Module {
            base: Default::default(),
            path: Rc::new(path.to_string()),
            chunk,
            globals,
            evaluated_value: None,
        }
    }

    pub fn path(&self) -> &Rc<String> {
        &self.path
    }

    pub fn chunk(&self) -> &Rc<Chunk> {
        &self.chunk
    }

    pub fn globals(&self) -> &Vec<String> {
        &self.globals
    }

    pub fn evaluated_value(&self) -> &Option<ObjP> {
        &self.evaluated_value
    }

    pub fn set_evaluated_value(&mut self, value: Option<ObjP>) {
        self.evaluated_value = value;
    }

    impl_create!(path: impl ToString, chunk: Rc<Chunk>, globals: Vec<String>);
}

impl Debug for Module {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "<Module {}>", self.path())
    }
}

impl Display for Module {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(self, fmt)
    }
}

impl Object for Module {
    fn equals(&self, other: &dyn Object) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<Module>() {
            // only referential identity
            std::ptr::addr_eq(self, other)
        } else {
            false
        }
    }

    impl_base_obj!(Module);
}

////////////////////////////////////////////////////////////////////////////////
// Module method implementations
////////////////////////////////////////////////////////////////////////////////