// Copyright 2026 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use std::pin::Pin;

use starlark::values::{Heap, Value as StarlarkValue};

use crate::{bridge::Value, Immutable, OwnedSlice, Scope};

impl Scope {
    pub(crate) fn new<'b>(
        parent: &Self,
        keys: &[&str],
    ) -> (cxx::UniquePtr<Self>, OwnedSlice<Pin<&'b mut Value>>) {
        let mut nested_scope = cxx::UniquePtr::<Self>::null();
        let values = crate::bridge::NewScope(parent, keys, &mut nested_scope);
        (nested_scope, values.into())
    }

    /// Returns the settings for the given scope.
    pub fn settings(&self) -> &crate::Settings {
        // Safety: Settings pointer is always valid and non-null.
        unsafe { self.settings_cxx().as_ref() }.unwrap()
    }

    /// Returns the items currently in the scope (not including parent scopes).
    pub fn items(&self) -> Immutable<OwnedSlice<crate::bridge::KeyValue<'_>>> {
        let slice = crate::bridge::GetScopeItems(self);
        Immutable::from(crate::OwnedSlice::<crate::bridge::KeyValue>::from(slice))
    }

    /// Converts Scope items to Starlark key-value pairs.
    pub fn get_kv<'v>(&self, heap: &Heap<'v>) -> Vec<(&str, StarlarkValue<'v>)> {
        let owned = self.items();
        let mut items = Vec::new();
        for pair in owned.as_slice() {
            items.push((pair.key, pair.value.to_rust(heap)));
        }
        items
    }
}

pub struct OwnedScope(pub cxx::UniquePtr<Scope>);

impl types::Scope for OwnedScope {
    fn copy_with<'a, 'v>(&self, kv: impl Iterator<Item = (&'a str, StarlarkValue<'v>)>) -> Self {
        let parent = self.0.as_ref().unwrap();
        let (keys, vals): (Vec<&str>, Vec<StarlarkValue<'v>>) = kv.unzip();
        let (mut child_scope, mut placeholders) = Scope::new(parent, &keys);

        // Safety: The child scope will always be non-null.
        let child_ref = unsafe { child_scope.as_mut().unwrap().get_unchecked_mut() };
        for (placeholder, val) in placeholders.as_slice_mut().iter_mut().zip(vals) {
            placeholder
                .as_mut()
                .assign(val, child_ref, Default::default());
        }

        Self(child_scope)
    }

    fn get<'v>(&self, key: &str, heap: &Heap<'v>) -> Option<StarlarkValue<'v>> {
        let parent = self.0.as_ref().unwrap();
        let val_ptr = crate::bridge::GetValue(parent, key);
        // Safety: val_ptr is either null or a valid pointer backed by the parent scope
        // lifetime.
        unsafe { val_ptr.as_ref() }.map(|val| val.to_rust(heap))
    }
}

#[cfg(test)]
mod tests {
    use types::Scope as _;

    use super::*;
    use crate::TestWithScope;

    #[test]
    fn test_owned_scope_methods() {
        let mut setup = TestWithScope::new();
        let parent_scope = setup.scope();

        let (child_ptr, _) = Scope::new(parent_scope, &[]);
        let owned_scope = OwnedScope(child_ptr);

        starlark::environment::Module::with_temp_heap(|module| {
            let heap = module.heap();

            let val_int = heap.alloc(42);
            let val_str = heap.alloc("hello");

            let grandchild =
                owned_scope.copy_with(vec![("foo", val_int), ("bar", val_str)].into_iter());

            assert_eq!(grandchild.get("foo", &heap).unwrap().unpack_i32(), Some(42));
            assert_eq!(
                grandchild.get("bar", &heap).unwrap().unpack_str(),
                Some("hello")
            );
            assert!(grandchild.get("baz", &heap).is_none());
        });
    }
}
