use oxide_kernel::shape_forge::{ShapeForge, EMPTY_SHAPE_ID};
use oxide_kernel::string_forge::StringForge;
use oxide_types::object::{JsObject, PropAttributes};
use oxide_types::value::JsValue;

use crate::coercion;
use crate::native::NativeResult;
use crate::vm::Vm;

pub(crate) fn walk_own_keys(vm: &Vm, obj: &JsObject) -> Vec<(u32, u32)> {
    let mut keys: Vec<(u32, u32)> = Vec::new();
    let shape_id = obj.shape_id();
    let mut pos: u32 = 0;
    let mut shape_ids = Vec::new();
    let mut cursor = Some(shape_id);
    while let Some(id) = cursor {
        if id == EMPTY_SHAPE_ID {
            break;
        }
        if let Some(shape) = vm.kernel().shape_forge().get_shape(id) {
            cursor = shape.parent;
            if shape.property_name != u32::MAX {
                shape_ids.push(id);
            }
        } else {
            break;
        }
    }
    for id in shape_ids.iter().rev() {
        if let Some(shape) = vm.kernel().shape_forge().get_shape(*id) {
            if shape.property_name != 0 {
                keys.push((shape.property_name, pos));
            }
        }
        pos += 1;
    }
    keys
}

pub fn object_constructor(vm: &mut Vm, _args: &[u8]) -> NativeResult {
    let obj = vm.epoch().alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()));
    Ok(JsValue::from_js_object(obj))
}

pub fn object_keys(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Err(JsValue::undefined());
    }
    let val = vm.reg(args[1]);
    if !val.is_object() {
        return Err(JsValue::undefined());
    }
    let obj_ptr = val.as_js_object_ptr();
    if obj_ptr.is_null() {
        return Err(JsValue::undefined());
    }

    let key_names: Vec<String>;
    {
        let obj = unsafe { &*obj_ptr };
        let keys = walk_own_keys(vm, obj);
        key_names = keys
            .iter()
            .map(|(si, _offset)| vm.kernel().string_forge().lookup(*si).unwrap_or_default())
            .collect();
    }

    let n = key_names.len();
    let array_proto = vm.kernel().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),
        n,
        vm.epoch().bump(),
    ));
    for (i, k) in key_names.iter().enumerate() {
        let str_val = vm.intern(k);
        unsafe {
            (*arr).set_prop_at(i, str_val);
        }
    }
    unsafe {
        (*arr).set_prop_count(n);
    }
    Ok(JsValue::from_js_object(arr))
}

pub fn object_create(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::undefined());
    }
    let proto_val = vm.reg(args[1]);
    if !proto_val.is_null() && !proto_val.is_object() {
        return Ok(JsValue::undefined());
    }
    let obj = vm.epoch().alloc(JsObject::new_empty(EMPTY_SHAPE_ID, proto_val));
    Ok(JsValue::from_js_object(obj))
}

pub fn object_assign(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Err(JsValue::undefined());
    }
    let target_val = vm.reg(args[1]);
    if !target_val.is_object() {
        return Ok(target_val);
    }
    let target_ptr = target_val.as_js_object_ptr();
    if target_ptr.is_null() {
        return Ok(target_val);
    }
    {
        let target = unsafe { &mut *target_ptr };
        for &arg_reg in args.iter().skip(2) {
            let source_val = vm.reg(arg_reg);
            if !source_val.is_object() {
                continue;
            }
            let source_ptr = source_val.as_js_object_ptr();
            if source_ptr.is_null() {
                continue;
            }
            let source = unsafe { &*source_ptr };
            let source_keys = walk_own_keys(vm, source);
            for (_si, offset) in source_keys {
                let prop_val = source.get_prop_at(offset);
                target.push_prop(prop_val);
            }
        }
    }
    Ok(target_val)
}

pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 4 {
        return Err(JsValue::undefined());
    }
    let obj_val = vm.reg(args[1]);
    if !obj_val.is_object() {
        return Err(JsValue::undefined());
    }
    let obj_ptr = obj_val.as_js_object_ptr();
    if obj_ptr.is_null() {
        return Err(JsValue::undefined());
    }
    let desc_val = vm.reg(args[3]);
    if !desc_val.is_object() {
        return Err(JsValue::undefined());
    }
    let desc_ptr = desc_val.as_js_object_ptr();
    if desc_ptr.is_null() {
        return Err(JsValue::undefined());
    }
    let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
    let si = vm.kernel().string_forge().intern(&prop_name_str).0;

    let value_si = vm.kernel().string_forge().intern("value").0;
    let get_si = vm.kernel().string_forge().intern("get").0;
    let set_si = vm.kernel().string_forge().intern("set").0;
    let writable_si = vm.kernel().string_forge().intern("writable").0;
    let enumerable_si = vm.kernel().string_forge().intern("enumerable").0;
    let configurable_si = vm.kernel().string_forge().intern("configurable").0;

    let desc = unsafe { &*desc_ptr };
    let value_field = own_field(vm, desc, value_si);
    let get_field = own_field(vm, desc, get_si);
    let set_field = own_field(vm, desc, set_si);
    let writable_field = own_field(vm, desc, writable_si);
    let enumerable = own_field(vm, desc, enumerable_si)
        .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
        .unwrap_or(false);
    let configurable = own_field(vm, desc, configurable_si)
        .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
        .unwrap_or(false);

    let has_data = value_field.is_some() || writable_field.is_some();
    let has_accessor = get_field.is_some() || set_field.is_some();
    if has_data && has_accessor {
        return Err(crate::builtins::error::create_type_error(
            vm,
            "Invalid property descriptor: cannot mix data and accessor fields",
        ));
    }

    let obj = unsafe { &mut *obj_ptr };
    if has_accessor {
        let get = get_field.unwrap_or(JsValue::undefined());
        let set = set_field.unwrap_or(JsValue::undefined());
        if (!get.is_undefined() && !is_callable(get)) || (!set.is_undefined() && !is_callable(set)) {
            return Err(crate::builtins::error::create_type_error(
                vm,
                "accessor descriptor get/set must be callable or undefined",
            ));
        }
        vm.define_accessor_property(obj, si, get, set, PropAttributes::new(false, enumerable, configurable))
            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
    } else {
        let value = value_field.unwrap_or(JsValue::undefined());
        let writable = writable_field
            .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref()))
            .unwrap_or(false);
        vm.define_data_property(obj, si, value, PropAttributes::new(writable, enumerable, configurable))
            .map_err(|_| crate::builtins::error::create_type_error(vm, "Cannot define property"))?;
    }
    Ok(obj_val)
}

pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 3 {
        return Err(JsValue::undefined());
    }
    let obj_val = vm.reg(args[1]);
    if !obj_val.is_object() {
        return Ok(JsValue::undefined());
    }
    let obj_ptr = obj_val.as_js_object_ptr();
    if obj_ptr.is_null() {
        return Ok(JsValue::undefined());
    }
    let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2]));
    let si = vm.kernel().string_forge().intern(&prop_name_str).0;

    let (found_value, found_meta, found) = {
        let obj = unsafe { &*obj_ptr };
        let keys = walk_own_keys(vm, obj);
        let mut found_value = JsValue::undefined();
        let mut found_meta = None;
        let mut found = false;
        for (prop_si, offset) in keys {
            if prop_si == si {
                found_value = obj.get_prop_at(offset);
                found_meta = obj.prop_meta_at(offset);
                found = true;
                break;
            }
        }
        (found_value, found_meta, found)
    };

    if !found {
        return Ok(JsValue::undefined());
    }

    let sf_ptr = vm.kernel().string_forge().as_ref() as *const StringForge;
    let sh_ptr = vm.kernel().shape_forge().as_ref() as *const ShapeForge;
    let desc_proto = vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject;
    let desc = vm
        .epoch()
        .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(desc_proto)));
    let sf = unsafe { &*sf_ptr };
    let sh = unsafe { &*sh_ptr };

    let d: &mut JsObject = unsafe { &mut *desc };
    let meta = found_meta.unwrap_or_else(|| oxide_types::object::PropMetaEntry::data(PropAttributes::DEFAULT_DATA));
    if meta.is_accessor {
        push_desc_prop(d, sh, sf.intern("get").0, meta.get);
        push_desc_prop(d, sh, sf.intern("set").0, meta.set);
        push_desc_prop(d, sh, sf.intern("enumerable").0, JsValue::bool(meta.attributes.enumerable()));
        push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(meta.attributes.configurable()));
    } else {
        push_desc_prop(d, sh, sf.intern("value").0, found_value);
        push_desc_prop(d, sh, sf.intern("writable").0, JsValue::bool(meta.attributes.writable()));
        push_desc_prop(d, sh, sf.intern("enumerable").0, JsValue::bool(meta.attributes.enumerable()));
        push_desc_prop(d, sh, sf.intern("configurable").0, JsValue::bool(meta.attributes.configurable()));
    }

    Ok(JsValue::from_js_object(desc))
}

fn own_field(vm: &Vm, obj: &JsObject, prop_si: u32) -> Option<JsValue> {
    vm.kernel()
        .shape_forge()
        .lookup_position(obj.shape_id(), prop_si)
        .and_then(|pos| {
            if obj.prop_vec_len() > pos as usize {
                Some(obj.get_prop_at(pos))
            } else {
                None
            }
        })
}

fn is_callable(value: JsValue) -> bool {
    value.is_object() && unsafe { &*value.as_js_object_ptr() }.is_function()
}

fn push_desc_prop(obj: &mut JsObject, shape_forge: &ShapeForge, prop_si: u32, val: JsValue) {
    let shape_id = shape_forge.make_shape(obj.shape_id(), prop_si);
    obj.set_shape_id(shape_id);
    obj.push_prop(val);
}

fn require_obj_arg(vm: &mut Vm, args: &[u8], fn_name: &str) -> Result<*mut JsObject, JsValue> {
    if args.len() < 2 {
        return Err(crate::builtins::error::create_type_error(
            vm,
            &format!("Object.{fn_name} called on non-object"),
        ));
    }
    let val = vm.reg(args[1]);
    if !val.is_object() {
        return Err(crate::builtins::error::create_type_error(
            vm,
            &format!("Object.{fn_name} called on non-object"),
        ));
    }
    let ptr = val.as_js_object_ptr();
    if ptr.is_null() {
        return Err(crate::builtins::error::create_type_error(
            vm,
            &format!("Object.{fn_name} called on non-object"),
        ));
    }
    Ok(ptr)
}

pub fn object_freeze(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::undefined());
    }
    let val = vm.reg(args[1]);
    if !val.is_object() || val.as_js_object_ptr().is_null() {
        return Ok(val);
    }
    Ok(val)
}

pub fn object_seal(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::undefined());
    }
    let val = vm.reg(args[1]);
    if !val.is_object() || val.as_js_object_ptr().is_null() {
        return Ok(val);
    }
    Ok(val)
}

pub fn object_prevent_extensions(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::undefined());
    }
    let val = vm.reg(args[1]);
    if !val.is_object() || val.as_js_object_ptr().is_null() {
        return Ok(val);
    }
    Ok(val)
}

pub fn object_is_frozen(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::bool(true));
    }
    let val = vm.reg(args[1]);
    if !val.is_object() || val.as_js_object_ptr().is_null() {
        return Ok(JsValue::bool(true));
    }
    Ok(JsValue::bool(false))
}

pub fn object_is_sealed(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::bool(true));
    }
    let val = vm.reg(args[1]);
    if !val.is_object() || val.as_js_object_ptr().is_null() {
        return Ok(JsValue::bool(true));
    }
    Ok(JsValue::bool(false))
}

pub fn object_is_extensible(vm: &mut Vm, args: &[u8]) -> NativeResult {
    require_obj_arg(vm, args, "isExtensible")?;
    Ok(JsValue::bool(true))
}

pub fn object_get_own_property_names(vm: &mut Vm, args: &[u8]) -> NativeResult {
    let obj_ptr = require_obj_arg(vm, args, "getOwnPropertyNames")?;

    let key_names: Vec<String> = {
        let obj = unsafe { &*obj_ptr };
        let keys = walk_own_keys(vm, obj);
        keys.iter()
            .map(|(si, _)| vm.kernel().string_forge().lookup(*si).unwrap_or_default())
            .collect()
    };

    let n = key_names.len();
    let array_proto = vm.kernel().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),
        n,
        vm.epoch().bump(),
    ));
    for (i, k) in key_names.iter().enumerate() {
        let str_val = vm.intern(k);
        unsafe {
            (*arr).set_prop_at(i, str_val);
        }
    }
    unsafe {
        (*arr).set_prop_count(n);
    }
    Ok(JsValue::from_js_object(arr))
}

pub fn object_define_properties(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 3 {
        return Ok(vm.reg(args[1]));
    }
    let _obj_ptr = require_obj_arg(vm, args, "defineProperties")?;
    let desc_val = vm.reg(args[2]);
    if !desc_val.is_object() {
        return Ok(vm.reg(args[1]));
    }
    Ok(vm.reg(args[1]))
}

pub fn object_from_entries(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 2 {
        return Ok(JsValue::null());
    }
    let entries = vm.reg(args[1]);
    if !entries.is_object() {
        return Ok(JsValue::null());
    }
    let obj_ptr = vm.epoch().alloc(JsObject::new_empty(
        EMPTY_SHAPE_ID,
        JsValue::from_js_object(vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject),
    ));
    Ok(JsValue::from_js_object(obj_ptr))
}

pub fn object_get_prototype_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
    let obj_ptr = require_obj_arg(vm, args, "getPrototypeOf")?;
    Ok(unsafe { (*obj_ptr).proto() })
}

pub fn object_has_own(vm: &mut Vm, args: &[u8]) -> NativeResult {
    if args.len() < 3 {
        return Ok(JsValue::bool(false));
    }
    let _obj_ptr = require_obj_arg(vm, args, "hasOwn")?;
    let key_val = vm.reg(args[2]);
    if !key_val.is_string() {
        return Ok(JsValue::bool(false));
    }
    Ok(JsValue::bool(false))
}

pub fn object_entries(vm: &mut Vm, args: &[u8]) -> NativeResult {
    let obj_ptr = require_obj_arg(vm, args, "entries")?;
    let obj = unsafe { &*obj_ptr };
    let keys = walk_own_keys(vm, obj);
    let n = keys.len();
    let array_proto = vm.kernel().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),
        n,
        vm.epoch().bump(),
    ));
    for (i, (si, offset)) in keys.iter().enumerate() {
        let key_str = vm.kernel().string_forge().lookup(*si).unwrap_or_default();
        let key_val = vm.intern(&key_str);
        let val = obj.get_prop_at(*offset);
        let pair = vm.epoch().alloc(JsObject::new_array(
            EMPTY_SHAPE_ID,
            JsValue::from_js_object(array_proto),
            2,
            vm.epoch().bump(),
        ));
        unsafe {
            (*pair).set_prop_at(0, key_val);
            (*pair).set_prop_at(1, val);
            (*pair).set_prop_count(2);
            (*arr).set_prop_at(i, JsValue::from_js_object(pair));
        }
    }
    unsafe {
        (*arr).set_prop_count(n);
    }
    Ok(JsValue::from_js_object(arr))
}

pub fn object_values(vm: &mut Vm, args: &[u8]) -> NativeResult {
    let obj_ptr = require_obj_arg(vm, args, "values")?;
    let obj = unsafe { &*obj_ptr };
    let keys = walk_own_keys(vm, obj);
    let n = keys.len();
    let array_proto = vm.kernel().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),
        n,
        vm.epoch().bump(),
    ));
    for (i, (_si, offset)) in keys.iter().enumerate() {
        let val = obj.get_prop_at(*offset);
        unsafe {
            (*arr).set_prop_at(i, val);
        }
    }
    unsafe {
        (*arr).set_prop_count(n);
    }
    Ok(JsValue::from_js_object(arr))
}