use std::collections::HashMap;

use crate::vm_debug;
use oxide_types::object::JsObject;
use oxide_types::value::JsValue;
use rustc_hash::FxBuildHasher;

use crate::vm::Vm;
use oxide_builtins::{array_buffer, data_view, disposable_stack, map, regexp, set, typed_array};

impl Vm {
    pub(crate) fn is_session_escape_root_ptr(&self, target_ptr: *mut JsObject) -> bool {
        if target_ptr.is_null() {
            return false;
        }
        let global_ptr = self.session.global_object().as_ptr() as *mut JsObject;
        std::ptr::eq(target_ptr, global_ptr) || unsafe { (&*target_ptr).is_session_epoch() }
    }

    pub(crate) fn promote_object(&mut self, src: *mut JsObject) -> *mut JsObject {
        vm_debug!("promote_object: src={:p}", src);
        let mut forwarding = std::mem::take(&mut self.gc_state.forwarding);
        let result = self.promote_object_inner(src, &mut forwarding);
        forwarding.clear();
        self.gc_state.forwarding = forwarding;
        result
    }

    pub(crate) fn promote_object_inner(
        &mut self, src: *mut JsObject, forwarding: &mut HashMap<*mut JsObject, *mut JsObject, FxBuildHasher>,
    ) -> *mut JsObject {
        vm_debug!("promote_object_inner: src={:p}", src);
        if src.is_null() {
            return src;
        }
        let src_ref = unsafe { &*src };
        if src_ref.is_session_epoch() || !self.epoch.is_epoch_ptr(src.cast::<u8>()) {
            return src;
        }
        if let Some(dst) = forwarding.get(&src).copied() {
            return dst;
        }

        let clone = src_ref.clone_for_session_epoch();
        let dst = self.gc_state.session_epoch.alloc(clone) as *mut JsObject;
        forwarding.insert(src, dst);
        self.gc_state.session_object_ptrs.push(dst);
        self.gc_state.session_bytes_allocated += std::mem::size_of::<JsObject>();

        let dst_ref = unsafe { &mut *dst };
        dst_ref.rewrite_object_values(|value| self.promote_value_if_epoch_object(value, forwarding));
        if src_ref.is_map() {
            map::clone_map_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_set() {
            set::clone_set_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_disposable_stack_obj() || src_ref.is_async_disposable_stack_obj() {
            // 资源栈状态盒深拷贝到新对象：源盒随 epoch 释放，互不共享。
            disposable_stack::clone_dispose_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_typed_array_obj() {
            typed_array::clone_typed_array_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_data_view_obj() {
            data_view::clone_data_view_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_array_buffer_obj() {
            // 字节缓冲深拷贝到新对象：源 Vec 随 epoch 释放，互不共享。
            array_buffer::clone_array_buffer_native(src_ref, dst_ref);
        } else if src_ref.is_generator_obj() {
            // 生成器状态盒深拷贝到新对象：源盒随 epoch 释放，互不共享。
            crate::generator::clone_generator_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_promise_obj() {
            // Promise 状态盒深拷贝到新对象：源盒随 epoch 释放，互不共享。
            crate::promise::clone_promise_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_async_obj() {
            // 异步状态盒深拷贝到新对象：源盒随 epoch 释放，互不共享。
            crate::async_func::clone_async_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_async_generator_obj() {
            // 异步生成器状态盒深拷贝到新对象：源盒随 epoch 释放，互不共享。
            crate::async_generator::clone_async_generator_native_with_rewrite(src_ref, dst_ref, |value| {
                self.promote_value_if_epoch_object(value, forwarding)
            });
        } else if src_ref.is_regexp_obj() {
            // 已编译正则是 Box 深拷贝到新对象：源盒随 epoch 释放，互不共享。
            regexp::clone_regexp_native(src_ref, dst_ref);
        }
        dst
    }

    pub(crate) fn promote_value_if_epoch_object(
        &mut self, value: JsValue, forwarding: &mut HashMap<*mut JsObject, *mut JsObject, FxBuildHasher>,
    ) -> JsValue {
        if !value.is_object() {
            return value;
        }
        let ptr = value.as_js_object_ptr();
        if ptr.is_null() || !self.epoch.is_epoch_ptr(ptr.cast::<u8>()) {
            return value;
        }
        JsValue::from_js_object(self.promote_object_inner(ptr, forwarding))
    }

    pub(crate) fn promote_if_needed_for_write_ptr(&mut self, target_ptr: *mut JsObject, value: JsValue) -> JsValue {
        if !value.is_object() || !self.is_session_escape_root_ptr(target_ptr) {
            return value;
        }
        let value_ptr = value.as_js_object_ptr();
        if value_ptr.is_null() || !self.epoch.is_epoch_ptr(value_ptr.cast::<u8>()) {
            return value;
        }
        JsValue::from_js_object(self.promote_object(value_ptr))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
    use oxide_types::object::{PropAttributes, PropMetaEntry};

    fn plain_object(vm: &mut Vm) -> *mut JsObject {
        let proto = vm.session.builtin_world().object_proto.as_ptr() as *mut JsObject;
        vm.epoch
            .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(proto)))
    }

    fn is_epoch_object(vm: &Vm, value: JsValue) -> bool {
        value.is_object() && vm.epoch.is_epoch_ptr(value.as_js_object_ptr().cast::<u8>())
    }

    #[test]
    fn session_arena_promotion_preserves_cycle_identity() {
        let mut vm = Vm::new();
        let root = plain_object(&mut vm);
        unsafe {
            (*root).set_prop_at(0, JsValue::from_js_object(root));
        }

        let promoted = vm.promote_object(root);
        let promoted_obj = unsafe { &*promoted };

        assert!(promoted_obj.is_session_epoch());
        assert!(std::ptr::eq(promoted_obj.get_prop_at(0).as_js_object_ptr(), promoted));
    }

    #[test]
    fn session_arena_promotion_preserves_duplicate_child_reference() {
        let mut vm = Vm::new();
        let root = plain_object(&mut vm);
        let child = plain_object(&mut vm);
        unsafe {
            (*root).set_prop_at(0, JsValue::from_js_object(child));
            (*root).set_prop_at(1, JsValue::from_js_object(child));
        }

        let promoted = vm.promote_object(root);
        let promoted_obj = unsafe { &*promoted };
        let left = promoted_obj.get_prop_at(0).as_js_object_ptr();
        let right = promoted_obj.get_prop_at(1).as_js_object_ptr();

        assert!(std::ptr::eq(left, right));
        assert!(!std::ptr::eq(left, child));
        assert!(unsafe { (&*left).is_session_epoch() });
    }

    #[test]
    fn session_arena_captured_and_home_object_links_promote() {
        let mut vm = Vm::new();
        let root = plain_object(&mut vm);
        let proto = plain_object(&mut vm);
        let captured = plain_object(&mut vm);
        let home = plain_object(&mut vm);
        let getter = plain_object(&mut vm);
        let setter = plain_object(&mut vm);
        unsafe {
            (*root).set_proto(JsValue::from_js_object(proto)).expect("proto");
            (*root).set_captured_this(JsValue::from_js_object(captured));
            (*root).set_home_object(JsValue::from_js_object(home));
            (*root).set_prop_at(0, JsValue::undefined());
            (*root).set_accessor_meta(
                0,
                JsValue::from_js_object(getter),
                JsValue::from_js_object(setter),
                PropAttributes::DEFAULT_DATA,
            );
        }

        let promoted = vm.promote_object(root);
        let promoted_obj = unsafe { &*promoted };
        let meta = promoted_obj.prop_meta_at(0).expect("meta");

        assert!(!is_epoch_object(&vm, promoted_obj.proto()));
        assert!(!is_epoch_object(&vm, promoted_obj.captured_this()));
        assert!(!is_epoch_object(&vm, promoted_obj.home_object()));
        assert!(!is_epoch_object(&vm, meta.get));
        assert!(!is_epoch_object(&vm, meta.set));
    }

    #[test]
    fn session_arena_promotes_array_elements_and_element_meta() {
        let mut vm = Vm::new();
        let elem_child = plain_object(&mut vm);
        let meta_getter = plain_object(&mut vm);
        let array_proto = vm.session.builtin_world().array_proto.as_ptr() as *mut JsObject;
        let arr = vm.epoch.alloc(JsObject::new_array(
            EMPTY_SHAPE_ID,
            JsValue::from_js_object(array_proto),
            2,
            vm.epoch.bump(),
        ));
        unsafe {
            (*arr).set_prop_at(0, JsValue::from_js_object(elem_child));
            (*arr).set_accessor_meta(
                1,
                JsValue::from_js_object(meta_getter),
                JsValue::undefined(),
                PropAttributes::DEFAULT_DATA,
            );
            (*arr).set_prop_shape(0, JsValue::int(99));
        }

        let promoted = vm.promote_object(arr);
        let promoted_arr = unsafe { &*promoted };

        assert!(promoted_arr.is_session_epoch());
        // 数组元素（含访问器 get）与命名属性随 clone + rewrite 迁移到 session。
        assert!(!is_epoch_object(&vm, promoted_arr.get_prop_at(0)));
        let meta = promoted_arr.prop_meta_at(1).expect("element accessor meta");
        assert!(!is_epoch_object(&vm, meta.get));
        assert_eq!(promoted_arr.get_prop_shape(0), JsValue::int(99));
        // 元素计数与长度不因 promotion 改变。
        assert_eq!(promoted_arr.prop_count(), 2);
    }

    #[test]
    fn session_arena_barrier_promotes_global_root_write() {
        let mut vm = Vm::new();
        let value = JsValue::from_js_object(plain_object(&mut vm));
        let global_ptr = vm.session.global_object().as_ptr() as *mut JsObject;

        let promoted = vm.promote_if_needed_for_write_ptr(global_ptr, value);

        assert!(promoted.is_object());
        assert!(!is_epoch_object(&vm, promoted));
        assert!(unsafe { (&*promoted.as_js_object_ptr()).is_session_epoch() });
    }

    #[test]
    fn session_arena_barrier_promotes_already_session_target_write() {
        let mut vm = Vm::new();
        let target_epoch = plain_object(&mut vm);
        let target = vm.promote_object(target_epoch);
        let value = JsValue::from_js_object(plain_object(&mut vm));

        let promoted = vm.promote_if_needed_for_write_ptr(target, value);

        assert!(!is_epoch_object(&vm, promoted));
        assert!(unsafe { (&*promoted.as_js_object_ptr()).is_session_epoch() });
    }

    #[test]
    fn session_arena_barrier_leaves_non_escape_target_write_unchanged() {
        let mut vm = Vm::new();
        let target = plain_object(&mut vm);
        let value = JsValue::from_js_object(plain_object(&mut vm));

        let unchanged = vm.promote_if_needed_for_write_ptr(target, value);

        assert_eq!(unchanged, value);
    }

    #[test]
    fn session_arena_promotion_rewrites_accessor_metadata_values() {
        let mut vm = Vm::new();
        let root = plain_object(&mut vm);
        let getter = plain_object(&mut vm);
        let setter = plain_object(&mut vm);
        unsafe {
            (*root).set_prop_at(0, JsValue::undefined());
            (*root).set_accessor_meta(
                0,
                JsValue::from_js_object(getter),
                JsValue::from_js_object(setter),
                PropAttributes::DEFAULT_DATA,
            );
        }

        let promoted = vm.promote_object(root);
        let meta: PropMetaEntry = unsafe { &*promoted }.prop_meta_at(0).expect("meta");

        assert!(!is_epoch_object(&vm, meta.get));
        assert!(!is_epoch_object(&vm, meta.set));
    }

    #[test]
    fn promote_clears_forwarding_map() {
        let mut vm = Vm::new();
        let first = plain_object(&mut vm);
        let promoted = vm.promote_object(first);
        assert!(!promoted.is_null());
        // 共享 forwarding 表必须在每次 promote 后清空，使后续 promote（或 GC 清扫）
        // 永不观察到过期的 old->new 映射。
        assert!(vm.gc_state.forwarding.is_empty());

        let second = plain_object(&mut vm);
        let promoted2 = vm.promote_object(second);
        assert!(!promoted2.is_null());
        assert!(vm.gc_state.forwarding.is_empty());
    }
}