use crate::avm1::function::{Executable, NativeFunction};
use crate::avm1::property::{Attribute, Property};
use crate::avm1::return_value::ReturnValue;
use crate::avm1::{Avm1, Error, Object, ObjectCell, UpdateContext, Value};
use crate::display_object::DisplayNode;
use core::fmt;
use enumset::EnumSet;
use gc_arena::{GcCell, MutationContext};
use std::collections::hash_map::Entry;
use std::collections::HashMap;

pub const TYPE_OF_OBJECT: &str = "object";
pub const TYPE_OF_FUNCTION: &str = "function";
pub const TYPE_OF_MOVIE_CLIP: &str = "movieclip";

#[derive(Clone)]
pub struct ScriptObject<'gc> {
    prototype: Option<ObjectCell<'gc>>,
    display_node: Option<DisplayNode<'gc>>,
    values: HashMap<String, Property<'gc>>,
    function: Option<Executable<'gc>>,
    type_of: &'static str,
}

unsafe impl<'gc> gc_arena::Collect for ScriptObject<'gc> {
    fn trace(&self, cc: gc_arena::CollectionContext) {
        self.prototype.trace(cc);
        self.display_node.trace(cc);
        self.values.trace(cc);
    }
}

impl fmt::Debug for ScriptObject<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Object")
            .field("prototype", &self.prototype)
            .field("display_node", &self.display_node)
            .field("values", &self.values)
            .field("function", &self.function.is_some())
            .finish()
    }
}

impl<'gc> ScriptObject<'gc> {
    pub fn object(
        _gc_context: MutationContext<'gc, '_>,
        proto: Option<ObjectCell<'gc>>,
    ) -> ScriptObject<'gc> {
        ScriptObject {
            prototype: proto,
            type_of: TYPE_OF_OBJECT,
            display_node: None,
            values: HashMap::new(),
            function: None,
        }
    }

    /// Constructs and allocates an empty but normal object in one go.
    pub fn object_cell(
        gc_context: MutationContext<'gc, '_>,
        proto: Option<ObjectCell<'gc>>,
    ) -> ObjectCell<'gc> {
        GcCell::allocate(
            gc_context,
            Box::new(ScriptObject {
                prototype: proto,
                type_of: TYPE_OF_OBJECT,
                display_node: None,
                values: HashMap::new(),
                function: None,
            }),
        )
    }

    /// Constructs an object with no values, not even builtins.
    ///
    /// Intended for constructing scope chains, since they exclusively use the
    /// object values, but can't just have a hashmap because of `with` and
    /// friends.
    pub fn bare_object() -> Self {
        ScriptObject {
            prototype: None,
            type_of: TYPE_OF_OBJECT,
            display_node: None,
            values: HashMap::new(),
            function: None,
        }
    }

    /// Construct a function sans prototype.
    pub fn bare_function(
        function: impl Into<Executable<'gc>>,
        fn_proto: Option<ObjectCell<'gc>>,
    ) -> Self {
        ScriptObject {
            prototype: fn_proto,
            type_of: TYPE_OF_FUNCTION,
            function: Some(function.into()),
            display_node: None,
            values: HashMap::new(),
        }
    }

    /// Construct a function from an executable and associated protos.
    ///
    /// Since prototypes need to link back to themselves, this function builds
    /// both objects itself and returns the function to you, fully allocated.
    ///
    /// `fn_proto` refers to the implicit proto of the function object, and the
    /// `prototype` refers to the explicit prototype of the function. If
    /// provided, the function and it's prototype will be linked to each other.
    pub fn function(
        gc_context: MutationContext<'gc, '_>,
        function: impl Into<Executable<'gc>>,
        fn_proto: Option<ObjectCell<'gc>>,
        prototype: Option<ObjectCell<'gc>>,
    ) -> ObjectCell<'gc> {
        let function = GcCell::allocate(
            gc_context,
            Box::new(Self::bare_function(function, fn_proto)) as Box<dyn Object<'gc> + 'gc>,
        );

        //TODO: Can we make these proper sets or no?
        if let Some(p) = prototype {
            p.write(gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("constructor", Value::Object(function), EnumSet::empty());
            function
                .write(gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("prototype", p, EnumSet::empty());
        }

        function
    }

    pub fn set_display_node(&mut self, display_node: DisplayNode<'gc>) {
        self.display_node = Some(display_node);
    }

    pub fn display_node(&self) -> Option<DisplayNode<'gc>> {
        self.display_node
    }

    pub fn force_set_virtual<A>(
        &mut self,
        name: &str,
        get: Executable<'gc>,
        set: Option<Executable<'gc>>,
        attributes: A,
    ) where
        A: Into<EnumSet<Attribute>>,
    {
        self.values.insert(
            name.to_owned(),
            Property::Virtual {
                get,
                set,
                attributes: attributes.into(),
            },
        );
    }

    pub fn force_set<A>(&mut self, name: &str, value: impl Into<Value<'gc>>, attributes: A)
    where
        A: Into<EnumSet<Attribute>>,
    {
        self.values.insert(
            name.to_string(),
            Property::Stored {
                value: value.into(),
                attributes: attributes.into(),
            },
        );
    }

    /// Declare a native function on the current object.
    ///
    /// This is intended for use with defining host object prototypes. Notably,
    /// this creates a function object without an explicit `prototype`, which
    /// is only possible when defining host functions. User-defined functions
    /// always get a fresh explicit prototype, so you should never force set a
    /// user-defined function.
    pub fn force_set_function<A>(
        &mut self,
        name: &str,
        function: NativeFunction<'gc>,
        gc_context: MutationContext<'gc, '_>,
        attributes: A,
        fn_proto: Option<ObjectCell<'gc>>,
    ) where
        A: Into<EnumSet<Attribute>>,
    {
        self.force_set(
            name,
            Value::Object(ScriptObject::function(gc_context, function, fn_proto, None)),
            attributes,
        )
    }

    pub fn set_prototype(&mut self, prototype: ObjectCell<'gc>) {
        self.prototype = Some(prototype);
    }

    pub fn set_type_of(&mut self, type_of: &'static str) {
        self.type_of = type_of;
    }
}

impl<'gc> Object<'gc> for ScriptObject<'gc> {
    /// Get the value of a particular property on this object.
    ///
    /// The `avm`, `context`, and `this` parameters exist so that this object
    /// can call virtual properties. Furthermore, since some virtual properties
    /// may resolve on the AVM stack, this function may return `None` instead
    /// of a `Value`. *This is not equivalent to `undefined`.* Instead, it is a
    /// signal that your value will be returned on the ActionScript stack, and
    /// that you should register a stack continuation in order to get it.
    fn get(
        &self,
        name: &str,
        avm: &mut Avm1<'gc>,
        context: &mut UpdateContext<'_, 'gc, '_>,
        this: ObjectCell<'gc>,
    ) -> Result<ReturnValue<'gc>, Error> {
        if name == "__proto__" {
            return Ok(self
                .prototype
                .map_or(Value::Undefined, Value::Object)
                .into());
        }

        if let Some(value) = self.values.get(name) {
            return value.get(avm, context, this);
        }

        self.prototype
            .as_ref()
            .map_or(Ok(Value::Undefined.into()), |p| {
                p.read().get(name, avm, context, this)
            })
    }

    /// Set a named property on the object.
    ///
    /// This function takes a redundant `this` parameter which should be
    /// the object's own `GcCell`, so that it can pass it to user-defined
    /// overrides that may need to interact with the underlying object.
    fn set(
        &mut self,
        name: &str,
        value: Value<'gc>,
        avm: &mut Avm1<'gc>,
        context: &mut UpdateContext<'_, 'gc, '_>,
        this: ObjectCell<'gc>,
    ) -> Result<(), Error> {
        if name == "__proto__" {
            self.prototype = value.as_object().ok().to_owned();
        } else {
            match self.values.entry(name.to_owned()) {
                Entry::Occupied(mut entry) => {
                    entry.get_mut().set(avm, context, this, value)?;
                }
                Entry::Vacant(entry) => {
                    entry.insert(Property::Stored {
                        value,
                        attributes: Default::default(),
                    });
                }
            }
        }

        Ok(())
    }

    /// Call the underlying object.
    ///
    /// This function takes a redundant `this` parameter which should be
    /// the object's own `GcCell`, so that it can pass it to user-defined
    /// overrides that may need to interact with the underlying object.
    fn call(
        &self,
        avm: &mut Avm1<'gc>,
        context: &mut UpdateContext<'_, 'gc, '_>,
        this: ObjectCell<'gc>,
        args: &[Value<'gc>],
    ) -> Result<ReturnValue<'gc>, Error> {
        if let Some(function) = &self.function {
            function.exec(avm, context, this, args)
        } else {
            Ok(Value::Undefined.into())
        }
    }

    #[allow(clippy::new_ret_no_self)]
    fn new(
        &self,
        avm: &mut Avm1<'gc>,
        context: &mut UpdateContext<'_, 'gc, '_>,
        this: ObjectCell<'gc>,
        _args: &[Value<'gc>],
    ) -> Result<ObjectCell<'gc>, Error> {
        let proto = self
            .get("prototype", avm, context, this)?
            .resolve(avm, context)?
            .as_object()
            .unwrap_or(avm.prototypes.object);

        Ok(GcCell::allocate(
            context.gc_context,
            Box::new(ScriptObject::object(context.gc_context, Some(proto))) as Box<dyn Object<'gc>>,
        ))
    }

    /// Delete a named property from the object.
    ///
    /// Returns false if the property cannot be deleted.
    fn delete(&mut self, name: &str) -> bool {
        if let Some(prop) = self.values.get(name) {
            if prop.can_delete() {
                self.values.remove(name);
                return true;
            }
        }

        false
    }

    fn proto(&self) -> Option<ObjectCell<'gc>> {
        self.prototype
    }

    /// Checks if the object has a given named property.
    fn has_property(&self, name: &str) -> bool {
        self.has_own_property(name)
            || self
                .prototype
                .as_ref()
                .map_or(false, |p| p.read().has_property(name))
    }

    /// Checks if the object has a given named property on itself (and not,
    /// say, the object's prototype or superclass)
    fn has_own_property(&self, name: &str) -> bool {
        if name == "__proto__" {
            return true;
        }
        self.values.contains_key(name)
    }

    fn is_property_overwritable(&self, name: &str) -> bool {
        self.values
            .get(name)
            .map(|p| p.is_overwritable())
            .unwrap_or(false)
    }

    /// Checks if a named property appears when enumerating the object.
    fn is_property_enumerable(&self, name: &str) -> bool {
        if let Some(prop) = self.values.get(name) {
            prop.is_enumerable()
        } else {
            false
        }
    }

    /// Enumerate the object.
    fn get_keys(&self) -> Vec<String> {
        self.values
            .iter()
            .filter_map(|(k, p)| {
                if p.is_enumerable() {
                    Some(k.to_string())
                } else {
                    None
                }
            })
            .collect()
    }

    fn as_string(&self) -> String {
        if self.function.is_some() {
            "[type Function]".to_string()
        } else {
            "[object Object]".to_string()
        }
    }

    fn type_of(&self) -> &'static str {
        self.type_of
    }

    fn as_script_object(&self) -> Option<&ScriptObject<'gc>> {
        Some(self)
    }

    fn as_script_object_mut(&mut self) -> Option<&mut ScriptObject<'gc>> {
        Some(self)
    }

    /// Get the underlying display node for this object, if it exists.
    fn as_display_node(&self) -> Option<DisplayNode<'gc>> {
        self.display_node
    }

    /// Returns a copy of a given function.
    ///
    /// TODO: We have to clone here because of how executables are stored on
    /// objects directly. This might not be a good idea for performance.
    fn as_executable(&self) -> Option<Executable<'gc>> {
        self.function.clone()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::avm1::activation::Activation;
    use crate::avm1::property::Attribute::*;
    use crate::backend::audio::NullAudioBackend;
    use crate::backend::navigator::NullNavigatorBackend;
    use crate::backend::render::NullRenderer;
    use crate::display_object::{DisplayObject, MovieClip};
    use crate::library::Library;
    use crate::prelude::*;
    use gc_arena::rootless_arena;
    use rand::{rngs::SmallRng, SeedableRng};
    use std::sync::Arc;

    fn with_object<F, R>(swf_version: u8, test: F) -> R
    where
        F: for<'a, 'gc> FnOnce(
            &mut Avm1<'gc>,
            &mut UpdateContext<'a, 'gc, '_>,
            ObjectCell<'gc>,
        ) -> R,
    {
        rootless_arena(|gc_context| {
            let mut avm = Avm1::new(gc_context, swf_version);
            let movie_clip: Box<dyn DisplayObject> =
                Box::new(MovieClip::new(swf_version, gc_context));
            let root = GcCell::allocate(gc_context, movie_clip);
            let mut context = UpdateContext {
                gc_context,
                global_time: 0,
                player_version: 32,
                swf_version,
                root,
                start_clip: root,
                active_clip: root,
                target_clip: Some(root),
                target_path: Value::Undefined,
                rng: &mut SmallRng::from_seed([0u8; 16]),
                action_queue: &mut crate::context::ActionQueue::new(),
                audio: &mut NullAudioBackend::new(),
                background_color: &mut Color {
                    r: 0,
                    g: 0,
                    b: 0,
                    a: 0,
                },
                library: &mut Library::new(),
                navigator: &mut NullNavigatorBackend::new(),
                renderer: &mut NullRenderer::new(),
                swf_data: &mut Arc::new(vec![]),
                system_prototypes: avm.prototypes().clone(),
            };

            let object = GcCell::allocate(
                gc_context,
                Box::new(ScriptObject::object(
                    gc_context,
                    Some(avm.prototypes().object),
                )) as Box<dyn Object<'_>>,
            );

            let globals = avm.global_object_cell();
            avm.insert_stack_frame(GcCell::allocate(
                gc_context,
                Activation::from_nothing(swf_version, globals, gc_context),
            ));

            test(&mut avm, &mut context, object)
        })
    }

    #[test]
    fn test_get_undefined() {
        with_object(0, |avm, context, object| {
            assert_eq!(
                object
                    .read()
                    .get("not_defined", avm, context, object)
                    .unwrap(),
                ReturnValue::Immediate(Value::Undefined)
            );
        })
    }

    #[test]
    fn test_set_get() {
        with_object(0, |avm, context, object| {
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("forced", "forced", EnumSet::empty());
            object
                .write(context.gc_context)
                .set("natural", "natural".into(), avm, context, object)
                .unwrap();

            assert_eq!(
                object.read().get("forced", avm, context, object).unwrap(),
                ReturnValue::Immediate("forced".into())
            );
            assert_eq!(
                object.read().get("natural", avm, context, object).unwrap(),
                ReturnValue::Immediate("natural".into())
            );
        })
    }

    #[test]
    fn test_set_readonly() {
        with_object(0, |avm, context, object| {
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("normal", "initial", EnumSet::empty());
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("readonly", "initial", ReadOnly);

            object
                .write(context.gc_context)
                .set("normal", "replaced".into(), avm, context, object)
                .unwrap();
            object
                .write(context.gc_context)
                .set("readonly", "replaced".into(), avm, context, object)
                .unwrap();

            assert_eq!(
                object.read().get("normal", avm, context, object).unwrap(),
                ReturnValue::Immediate("replaced".into())
            );
            assert_eq!(
                object.read().get("readonly", avm, context, object).unwrap(),
                ReturnValue::Immediate("initial".into())
            );
        })
    }

    #[test]
    fn test_deletable_not_readonly() {
        with_object(0, |avm, context, object| {
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("test", "initial", DontDelete);

            assert_eq!(object.write(context.gc_context).delete("test"), false);
            assert_eq!(
                object.read().get("test", avm, context, object).unwrap(),
                ReturnValue::Immediate("initial".into())
            );

            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .set("test", "replaced".into(), avm, context, object)
                .unwrap();

            assert_eq!(object.write(context.gc_context).delete("test"), false);
            assert_eq!(
                object.read().get("test", avm, context, object).unwrap(),
                ReturnValue::Immediate("replaced".into())
            );
        })
    }

    #[test]
    fn test_virtual_get() {
        with_object(0, |avm, context, object| {
            let getter = Executable::Native(|_avm, _context, _this, _args| {
                Ok(ReturnValue::Immediate("Virtual!".into()))
            });

            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set_virtual("test", getter, None, EnumSet::empty());

            assert_eq!(
                object.read().get("test", avm, context, object).unwrap(),
                ReturnValue::Immediate("Virtual!".into())
            );

            // This set should do nothing
            object
                .write(context.gc_context)
                .set("test", "Ignored!".into(), avm, context, object)
                .unwrap();
            assert_eq!(
                object.read().get("test", avm, context, object).unwrap(),
                ReturnValue::Immediate("Virtual!".into())
            );
        })
    }

    #[test]
    fn test_delete() {
        with_object(0, |avm, context, object| {
            let getter = Executable::Native(|_avm, _context, _this, _args| {
                Ok(ReturnValue::Immediate("Virtual!".into()))
            });

            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set_virtual("virtual", getter.clone(), None, EnumSet::empty());
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set_virtual("virtual_un", getter, None, DontDelete);
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("stored", "Stored!", EnumSet::empty());
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("stored_un", "Stored!", DontDelete);

            assert_eq!(object.write(context.gc_context).delete("virtual"), true);
            assert_eq!(object.write(context.gc_context).delete("virtual_un"), false);
            assert_eq!(object.write(context.gc_context).delete("stored"), true);
            assert_eq!(object.write(context.gc_context).delete("stored_un"), false);
            assert_eq!(
                object.write(context.gc_context).delete("non_existent"),
                false
            );

            assert_eq!(
                object.read().get("virtual", avm, context, object).unwrap(),
                ReturnValue::Immediate(Value::Undefined)
            );
            assert_eq!(
                object
                    .read()
                    .get("virtual_un", avm, context, object)
                    .unwrap(),
                ReturnValue::Immediate("Virtual!".into())
            );
            assert_eq!(
                object.read().get("stored", avm, context, object).unwrap(),
                ReturnValue::Immediate(Value::Undefined)
            );
            assert_eq!(
                object
                    .read()
                    .get("stored_un", avm, context, object)
                    .unwrap(),
                ReturnValue::Immediate("Stored!".into())
            );
        })
    }

    #[test]
    fn test_iter_values() {
        with_object(0, |_avm, context, object| {
            let getter = Executable::Native(|_avm, _context, _this, _args| {
                Ok(ReturnValue::Immediate(Value::Null))
            });

            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("stored", Value::Null, EnumSet::empty());
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set("stored_hidden", Value::Null, DontEnum);
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set_virtual("virtual", getter.clone(), None, EnumSet::empty());
            object
                .write(context.gc_context)
                .as_script_object_mut()
                .unwrap()
                .force_set_virtual("virtual_hidden", getter, None, DontEnum);

            let keys = object.read().get_keys();
            assert_eq!(keys.len(), 2);
            assert_eq!(keys.contains(&"stored".to_string()), true);
            assert_eq!(keys.contains(&"stored_hidden".to_string()), false);
            assert_eq!(keys.contains(&"virtual".to_string()), true);
            assert_eq!(keys.contains(&"virtual_hidden".to_string()), false);
        })
    }
}