gguppy_data 0.4.0

//! Minimal DataFrame-like abstraction for `gguppy`
//!
//! - Provides the [`BasicDataFrame`] and [`BasicSeries`] types, along with associated traits and
//!   macros.
//! - The [`BasicDataFrame`] represents a tabular data structure in columnar format. Designed around
//!   the idea of a [`Vec`] of [`Vec`].
//!
//! - The [`BasicSeries`] represents a single column of homogeneous data within the
//!   [`BasicDataFrame`] and independently as a column type.
//! - The [`BasicNamedArray`] trait allows for easy creation of [`BasicSeries`] with a name and a
//!   vector of any supported type.
//! - The [`BasicTypedArray`] enum encapsulates the different data types stored in a
//!   [`BasicSeries`].
//!
//! - [`BasicTypedArray`] (holds type-specific data) --> [`BasicSeries`] (type-erased) -->
//!   [`BasicDataFrame`]
//!
//! ## Design Philosophy
//!
//! - The [`BasicDataFrame`] does not aim to provide a complete DataFrame-like library; instead, it
//!   offers only the minimal set of functionality required for plotting tabular data in `gguppy`.
//! - A [`Arc<BasicNamedArray>`] allows cheap cloning of series data, selection, and manipulation of
//!   columns without deep copies.
//! - No `#[derive(Clone)]` for [`BasicTypedArray`] nor [`BasicNamedArray`] to prevent accidental
//!   cloning downstream.
//! - No enforcement to verify 'well-shaped' `DataFrame` (e.g. equal column lengths).
//! - No support for non-homogeneous data in a [`BasicSeries`].

use alloc::{
    fmt,
    string::{String, ToString},
    sync::Arc,
    vec,
    vec::Vec,
};
use core::ops::{Add, Sub};

use gguppy_core::data::{ChunkedSlices, DataFrameAdapter, SeriesAdapter, SeriesAdapterError};

/// Error type for [`crate::basicdf`] operations
#[derive(Debug, PartialEq)]
pub enum BasicdfError {
    /// Column not found in a [`BasicDataFrame`].
    ColumnNotFound(String),
    /// Functionality not yet available.
    NotYetImplemented(String),
}

impl core::fmt::Display for BasicdfError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            BasicdfError::NotYetImplemented(desc) => {
                write!(f, "Not yet implemented: {desc}")
            }
            BasicdfError::ColumnNotFound(desc) => write!(f, "Column not found: {desc}",),
        }
    }
}

/// Enum representing the different data types that a [`BasicSeries`] can store.
#[derive(Debug, PartialEq)]
pub enum BasicTypedArray {
    /// A vector of [`usize`]
    Usize(Vec<usize>),
    /// A vector of [`u8`]
    U8(Vec<u8>),
    /// A vector of [`u16`]
    U16(Vec<u16>),
    /// A vector of [`u32`]
    U32(Vec<u32>),
    /// A vector of [`u64`]
    U64(Vec<u64>),
    /// A vector of [`isize`]
    Isize(Vec<isize>),
    /// A vector of [`i8`]
    I8(Vec<i8>),
    /// A vector of [`i16`]
    I16(Vec<i16>),
    /// A vector of [`i32`]
    I32(Vec<i32>),
    /// A vector of [`i64`]
    I64(Vec<i64>),
    /// A vector of [`f32`]
    F32(Vec<f32>),
    /// A vector of [`f64`]
    F64(Vec<f64>),
    /// A vector of [`bool`]
    Bool(Vec<bool>),
    /// A vector of [`String`]
    String(Vec<String>),
    /// A vector of [`char`]
    Char(Vec<char>),
    // TODO: Add categorical type
    // TODO: Add time series type
}

/// Macro to dispatch operations on [`BasicTypedArray`] variants
///
/// Rather than try to guess all possible operations, this macro takes a user-defined macro that
/// defines the operations and then applies that macro to every enum variant.
#[rustfmt::skip]
macro_rules! apply_all_basic_typed_array {
    ($typed_array_expr:expr, $handler:ident) => {
        match $typed_array_expr {
            $crate::basicdf::BasicTypedArray::Usize(v) => $handler!(Usize, v),
            $crate::basicdf::BasicTypedArray::U8(v) => $handler!(U8, v),
            $crate::basicdf::BasicTypedArray::U16(v) => $handler!(U16, v),
            $crate::basicdf::BasicTypedArray::U32(v) => $handler!(U32, v),
            $crate::basicdf::BasicTypedArray::U64(v) => $handler!(U64, v),
            $crate::basicdf::BasicTypedArray::Isize(v) => $handler!(Isize, v),
            $crate::basicdf::BasicTypedArray::I8(v) => $handler!(I8, v),
            $crate::basicdf::BasicTypedArray::I16(v) => $handler!(I16, v),
            $crate::basicdf::BasicTypedArray::I32(v) => $handler!(I32, v),
            $crate::basicdf::BasicTypedArray::I64(v) => $handler!(I64, v),
            $crate::basicdf::BasicTypedArray::F32(v) => $handler!(F32, v),
            $crate::basicdf::BasicTypedArray::F64(v) => $handler!(F64, v),
            $crate::basicdf::BasicTypedArray::Bool(v) => $handler!(Bool, v),
            $crate::basicdf::BasicTypedArray::String(v) => $handler!(String, v),
            $crate::basicdf::BasicTypedArray::Char(v) => $handler!(Char, v),
        }
    };
}

#[rustfmt::skip]
impl BasicTypedArray {
    #[must_use]
    /// Returns the length of the array.
    pub fn len(&self) -> usize {
        macro_rules! variant_len {($variant:ident, $v:ident) => {$v.len()};}
        apply_all_basic_typed_array!(self, variant_len)
    }

    #[must_use]
    /// Returns true for an empty array.
    pub fn is_empty(&self) -> bool {
        macro_rules! variant_is_empty {($variant:ident, $v:ident) => {$v.is_empty()};}
        apply_all_basic_typed_array!(self, variant_is_empty)
    }
}

/// Named array that holds a vector of values of a specific type.
#[derive(Debug, PartialEq)]
pub struct BasicNamedArray {
    /// The values stored in the array, represented as a [`BasicTypedArray`].
    pub values: BasicTypedArray,
    /// The name of the array.
    pub name: String,
}

impl fmt::Display for BasicNamedArray {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}: ", self.name)?;
        write!(f, "{:?}", &self.values)?;
        Ok(())
    }
}

/// Trait for constructing a [`BasicNamedArray`] or [`BasicSeries`]
///
/// Required as Rust currently does not allow specialization of a generic function implementation
/// for a concrete type.
pub trait FromNamedArray<T> {
    /// Create a new [`BasicNamedArray`] or [`BasicSeries`] with the given name and vector of
    /// values.
    fn new(name: &str, v: Vec<T>) -> Self;
}

macro_rules! impl_into_basic_named_array {
    ($type:ty, $dtype:ident) => {
        impl crate::basicdf::FromNamedArray<$type> for crate::basicdf::BasicNamedArray {
            fn new(name: &str, v: Vec<$type>) -> Self {
                Self {
                    values: crate::basicdf::BasicTypedArray::$dtype(v),
                    name: name.to_string(),
                }
            }
        }
        impl crate::basicdf::FromNamedArray<$type> for crate::basicdf::BasicSeries {
            fn new(name: &str, v: Vec<$type>) -> Self {
                Self(alloc::sync::Arc::new(crate::basicdf::BasicNamedArray::new(
                    name, v,
                )))
            }
        }
    };
}

impl_into_basic_named_array!(usize, Usize);
impl_into_basic_named_array!(u8, U8);
impl_into_basic_named_array!(u16, U16);
impl_into_basic_named_array!(u32, U32);
impl_into_basic_named_array!(u64, U64);
impl_into_basic_named_array!(isize, Isize);
impl_into_basic_named_array!(i8, I8);
impl_into_basic_named_array!(i16, I16);
impl_into_basic_named_array!(i32, I32);
impl_into_basic_named_array!(i64, I64);
impl_into_basic_named_array!(f32, F32);
impl_into_basic_named_array!(f64, F64);
impl_into_basic_named_array!(bool, Bool);
impl_into_basic_named_array!(char, Char);
impl FromNamedArray<&str> for BasicNamedArray {
    fn new(name: &str, v: Vec<&str>) -> Self {
        Self {
            values: BasicTypedArray::String(v.iter().map(ToString::to_string).collect()),
            name: name.to_string(),
        }
    }
}
impl FromNamedArray<&str> for BasicSeries {
    fn new(name: &str, v: Vec<&str>) -> Self {
        Self(Arc::new(BasicNamedArray::new(name, v)))
    }
}
impl FromNamedArray<String> for BasicNamedArray {
    fn new(name: &str, v: Vec<String>) -> Self {
        Self {
            values: BasicTypedArray::String(v),
            name: name.to_string(),
        }
    }
}
impl FromNamedArray<String> for BasicSeries {
    fn new(name: &str, v: Vec<String>) -> Self {
        Self(Arc::new(BasicNamedArray::new(name, v)))
    }
}

/// A series represents a single column of data which can exist independently of a
/// [`BasicDataFrame`].
///
/// A new-type wrapper around `Arc<BasicNamedArray>` to satisfy orphan rules that prohibit using
/// `pub type BasicSeries = Arc<BasicNamedArray>` with `impl SeriesAdapter for BasicSeries`.
#[derive(Clone, Debug, PartialEq)]
pub struct BasicSeries(pub Arc<BasicNamedArray>);

impl From<BasicNamedArray> for BasicSeries {
    fn from(array: BasicNamedArray) -> Self {
        BasicSeries(Arc::new(array))
    }
}

impl core::ops::Deref for BasicSeries {
    type Target = BasicNamedArray;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl SeriesAdapter<'_> for BasicSeries {
    type LibError = BasicdfError;

    fn name(&self) -> &str {
        &self.0.name
    }

    fn len(&self) -> usize {
        self.0.values.len()
    }

    fn is_empty(&self) -> bool {
        self.0.values.is_empty()
    }

    /// Returns a chunked slice view of the underlying data
    ///
    /// Currently, [`BasicSeries`] returns a single chunk because it stores data as a single
    /// contiguous vector.
    fn as_chunked_slices(&self) -> Result<ChunkedSlices<'_>, SeriesAdapterError> {
        macro_rules! variant_as_slice {
            ($variant:ident, $v:ident) => {
                gguppy_core::data::ChunkedSlices::$variant(vec![$v.as_slice()])
            };
        }
        Ok(apply_all_basic_typed_array!(
            &self.0.values,
            variant_as_slice
        ))
    }
}

impl Add for BasicSeries {
    type Output = Result<Self, BasicdfError>;

    fn add(self, rhs: Self) -> Self::Output {
        // TODO: Match other enum variants and use a macro for Add and Sub
        match (&self.0.values, &rhs.0.values) {
            (BasicTypedArray::I32(v1), BasicTypedArray::I32(v2)) => {
                let result: Vec<i32> = v1.iter().zip(v2.iter()).map(|(a, b)| a + b).collect();
                Ok(BasicSeries(Arc::new(BasicNamedArray::new(
                    "unnamed", result,
                ))))
            }
            (BasicTypedArray::F64(v1), BasicTypedArray::F64(v2)) => {
                let result: Vec<f64> = v1.iter().zip(v2.iter()).map(|(a, b)| a + b).collect();
                Ok(BasicSeries(Arc::new(BasicNamedArray::new(
                    "unnamed", result,
                ))))
            }
            _ => Err(BasicdfError::NotYetImplemented(
                "Addition for this type is not implemented".to_string(),
            )),
        }
    }
}

impl Sub for BasicSeries {
    type Output = Result<Self, BasicdfError>;

    fn sub(self, rhs: Self) -> Self::Output {
        // TODO: Match other enum variants and use a macro for Add and Sub
        match (&self.0.values, &rhs.0.values) {
            (BasicTypedArray::I32(v1), BasicTypedArray::I32(v2)) => {
                let result: Vec<i32> = v1.iter().zip(v2.iter()).map(|(a, b)| a - b).collect();
                Ok(BasicSeries(Arc::new(BasicNamedArray::new(
                    "unnamed", result,
                ))))
            }
            (BasicTypedArray::F64(v1), BasicTypedArray::F64(v2)) => {
                let result: Vec<f64> = v1.iter().zip(v2.iter()).map(|(a, b)| a - b).collect();
                Ok(BasicSeries(Arc::new(BasicNamedArray::new(
                    "unnamed", result,
                ))))
            }
            _ => Err(BasicdfError::NotYetImplemented(
                "Subtraction for this type is not implemented".to_string(),
            )),
        }
    }
}

/// A minimal DataFrame-like structure
///
/// The [`BasicDataFrame`] contains columns of type [`BasicSeries`], i.e. [`Arc`] of
/// [`BasicNamedArray`].
#[derive(Clone, Debug, PartialEq)]
pub struct BasicDataFrame {
    /// A vector of [`BasicSeries`] representing the columns of the `DataFrame`.
    pub columns: Vec<BasicSeries>,
    // TODO: Add metadata
    // pub meta: String,
}

impl BasicDataFrame {
    /// Create a new [`BasicDataFrame`] with the given columns.
    #[must_use]
    pub fn new(columns: Vec<BasicSeries>) -> Self {
        Self { columns }
    }
}

impl DataFrameAdapter<'_> for BasicDataFrame {
    type DataFrame = BasicDataFrame;
    type Series = BasicSeries;
    type LibError = BasicdfError;

    fn column_names(&self) -> Vec<String> {
        self.columns.iter().map(|col| col.0.name.clone()).collect()
    }

    fn col(&self, name: &str) -> Result<Self::Series, Self::LibError> {
        self.columns
            .iter()
            .find(|col| col.0.name == name)
            .cloned()
            .ok_or_else(|| BasicdfError::ColumnNotFound(name.to_string()))
    }

    fn select(&self, names: Vec<&str>) -> Result<Self::DataFrame, Self::LibError> {
        let selected_columns: Vec<BasicSeries> = names
            .iter()
            .map(|&name| {
                self.columns
                    .iter()
                    .find(|col| col.0.name == name)
                    .cloned()
                    .ok_or_else(|| BasicdfError::ColumnNotFound(name.to_string()))
            })
            .collect::<Result<Vec<_>, _>>()?;
        Ok(BasicDataFrame::new(selected_columns))
    }

    fn shape(&self) -> (usize, usize) {
        let ncols = self.columns.len();
        let nrows = self
            .columns
            .iter()
            .map(|col| col.0.values.len())
            .max()
            .unwrap_or(0);
        (nrows, ncols)
    }
}

impl fmt::Display for BasicDataFrame {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.columns.is_empty() {
            return Ok(());
        }
        // TODO: Make this nicer with appropriate column widths etc.
        let max_len = self
            .columns
            .iter()
            .map(|col| col.0.values.len())
            .max()
            .unwrap_or(0);
        let disp_rows = 10;

        for row in 0..max_len.min(disp_rows) {
            for (i, series) in self.columns.iter().enumerate() {
                if i > 0 {
                    write!(f, "\t")?;
                }
                macro_rules! variant_to_string {
                    (String, $v:ident) => {
                        $v.get(row).cloned()
                    };
                    ($variant:ident, $v:ident) => {
                        $v.get(row).map(ToString::to_string)
                    };
                }
                let value = apply_all_basic_typed_array!(&series.0.values, variant_to_string);
                match value {
                    Some(val) => write!(f, "{val}")?,
                    None => write!(f, "")?,
                }
            }
            writeln!(f)?;
        }

        Ok(())
    }
}

/// Create a new [`basicdf::BasicDataFrame`](BasicDataFrame) from A vector of
/// [`basicdf::BasicSeries`](BasicSeries)
#[macro_export]
macro_rules! basic_df {
    ($($col_name:expr => $slice:expr), + $(,)?) => {
        {
            $crate::basicdf::BasicDataFrame::new(vec![
                    $($crate::basicdf::BasicSeries::new($col_name, $slice),)+
                    ]
            )
        }
    }
}

// TODO: Create tribble-like proc macro for row-wise creation
// https://stackoverflow.com/questions/34304593/counting-length-of-repetition-in-macro
// https://docs.rs/nalgebra-macros/latest/src/nalgebra_macros/lib.rs.html

#[cfg(test)]
mod test {
    //! Since [`crate::basicdf`] uses macros for pattern matching variants, tests that pass on one
    //! variant type should (in theory) pass for all variant types.

    use super::*;

    #[test]
    fn basicdf_error_display() {
        let error = BasicdfError::ColumnNotFound("test_column".to_string());
        assert_eq!(error.to_string(), "Column not found: test_column");

        let error = BasicdfError::NotYetImplemented("test_functionality".to_string());
        assert_eq!(error.to_string(), "Not yet implemented: test_functionality");
    }

    #[test]
    fn basic_typed_array_len() {
        let array = BasicTypedArray::Usize(vec![1, 2, 3]);
        assert_eq!(array.len(), 3);
        assert!(!array.is_empty());
    }

    #[test]
    fn basic_typed_array_empty() {
        assert!(BasicTypedArray::Usize(vec![]).is_empty());
    }

    #[test]
    fn basic_named_array_new() {
        let mut named_array: BasicNamedArray;

        named_array = BasicNamedArray::new("test", vec![1usize, 2, 3]);
        assert_eq!(named_array.name, "test");
        assert_eq!(named_array.values, BasicTypedArray::Usize(vec![1, 2, 3]));

        named_array = BasicNamedArray::new(
            "test",
            vec!["a".to_string(), "b".to_string(), "c".to_string()],
        );
        assert_eq!(
            named_array.values,
            BasicTypedArray::String(vec!["a".to_string(), "b".to_string(), "c".to_string()])
        );

        named_array = BasicNamedArray::new("test", vec!["a", "b", "c"]);
        assert_eq!(
            named_array.values,
            BasicTypedArray::String(vec!["a".to_string(), "b".to_string(), "c".to_string()])
        );
    }

    #[test]
    fn basic_named_array_display() {
        let named_array = BasicNamedArray::new("test", vec![1usize, 2, 3]);
        assert_eq!(named_array.to_string(), "test: Usize([1, 2, 3])");
    }

    #[test]
    fn basic_series_new() {
        let mut series: BasicSeries;

        series = BasicSeries::new("test", vec![1usize, 2, 3]);
        assert_eq!(series.name(), "test");
        assert_eq!(series.len(), 3);
        assert!(!series.is_empty());

        series = BasicSeries::new(
            "test",
            vec!["a".to_string(), "b".to_string(), "c".to_string()],
        );
        assert_eq!(series.name(), "test");
        assert_eq!(series.len(), 3);
        assert!(!series.is_empty());

        series = BasicSeries::new("test", vec!["a", "b", "c"]);
        assert_eq!(series.name(), "test");
        assert_eq!(series.len(), 3);
        assert!(!series.is_empty());
    }

    #[test]
    fn basic_series_empty() {
        assert!(<BasicSeries as FromNamedArray::<usize>>::new("", vec![]).is_empty());
    }

    #[test]
    fn basic_series_from_basic_named_array() {
        let named_array = BasicNamedArray::new("test", vec![1usize, 2, 3]);
        let series: BasicSeries = named_array.into();
        assert_eq!(series.name(), "test");
        assert_eq!(series.len(), 3);
        assert_eq!(series.0.values, BasicTypedArray::Usize(vec![1, 2, 3]));
    }

    #[test]
    fn series_adapter_name() {
        let series = BasicSeries::new("test", vec![1usize, 2, 3]);
        assert_eq!(series.name(), "test");
    }

    #[test]
    fn series_adapter_len() {
        let series = BasicSeries::new("test", vec![1usize, 2, 3]);
        assert_eq!(<BasicSeries as SeriesAdapter>::len(&series), 3);
        assert!(!<BasicSeries as SeriesAdapter>::is_empty(&series));
    }

    #[test]
    fn series_adapter_empty() {
        let series = BasicSeries::new("test", vec![0u8; 0]);
        assert_eq!(<BasicSeries as SeriesAdapter>::len(&series), 0);
        assert!(<BasicSeries as SeriesAdapter>::is_empty(&series));
    }

    #[test]
    fn series_adapter_as_chunked_slice() {
        let series = BasicSeries::new("test", vec![1usize, 2, 3]);
        let chunked_slices = series.as_chunked_slices().unwrap();
        assert_eq!(chunked_slices, ChunkedSlices::Usize(vec![&[1, 2, 3]]));
    }

    #[test]
    fn series_adapter_add() {
        let series1 = BasicSeries::new("test1", vec![1i32, 2, 3]);
        let series2 = BasicSeries::new("test2", vec![4i32, 5, 6]);

        let result = series1 + series2;
        assert!(result.is_ok());
        let result_series = result.unwrap();
        assert_eq!(result_series.name(), "unnamed");
        assert_eq!(result_series.len(), 3);
        assert_eq!(result_series.0.values, BasicTypedArray::I32(vec![5, 7, 9]));
    }

    #[test]
    fn series_adapter_sub() {
        let series1 = BasicSeries::new("test1", vec![4i32, 5, 6]);
        let series2 = BasicSeries::new("test2", vec![1i32, 2, 3]);

        let result = series1 - series2;
        assert!(result.is_ok());
        let result_series = result.unwrap();
        assert_eq!(result_series.name(), "unnamed");
        assert_eq!(result_series.len(), 3);
        assert_eq!(result_series.0.values, BasicTypedArray::I32(vec![3, 3, 3]));
    }

    #[test]
    fn basicdf_new() {
        let series1 = BasicSeries::new("col1", vec![1usize, 2, 3]);
        let series2 = BasicSeries::new("col2", vec![4usize, 5, 6]);
        let df = BasicDataFrame::new(vec![series1, series2]);

        assert_eq!(df.columns.len(), 2);
        assert_eq!(df.columns[0].name(), "col1");
        assert_eq!(df.columns[1].name(), "col2");
        assert_eq!(df.shape(), (3, 2));
    }

    #[test]
    fn basic_df_macro() {
        let df = basic_df!(
            "col1" => vec![1usize, 2, 3],
            "col2" => vec![4usize, 5, 6],
        );

        assert_eq!(df.columns.len(), 2);
        assert_eq!(df.columns[0].name(), "col1");
        assert_eq!(df.columns[1].name(), "col2");
        assert_eq!(df.shape(), (3, 2));
    }

    #[test]
    fn basicdf_display() {
        let df = basic_df!(
            "col1" => vec![1usize, 2, 3],
            "col2" => vec![4usize, 5, 6],
        );
        let expected_output = "1\t4\n2\t5\n3\t6\n";

        let output = df.to_string();
        assert_eq!(output, expected_output);
    }

    #[test]
    fn dataframe_adapter_column_names() {
        let df = basic_df![
            "alpha" => vec![1, 2, 3],
            "beta" => vec![4, 5, 6],
            "gamma" => vec![7, 8, 9]
        ];

        let names = df.column_names();
        assert_eq!(names.len(), 3);

        // Test contents
        assert!(names.contains(&"alpha".to_string()));
        assert!(names.contains(&"beta".to_string()));
        assert!(names.contains(&"gamma".to_string()));

        // Test ordering
        assert_eq!(
            names,
            vec!["alpha".to_string(), "beta".to_string(), "gamma".to_string()]
        );
    }

    #[test]
    fn dataframe_adapter_col() {
        let df = basic_df![
            "numbers" => vec![10, 20, 30],
            "letters" => vec!["x", "y", "z"]
        ];

        // Test successful column retrieval
        let numbers_col = df.col("numbers").unwrap();
        assert_eq!(numbers_col.name(), "numbers");
        assert_eq!(numbers_col.len(), 3);

        let letters_col = df.col("letters").unwrap();
        assert_eq!(letters_col.name(), "letters");
        assert_eq!(letters_col.len(), 3);

        // Test error case
        let result = df.col("nonexistent");
        assert!(result.is_err());
        if let Err(BasicdfError::ColumnNotFound(name)) = result {
            assert_eq!(name, "nonexistent");
        } else {
            panic!("Expected ColumnNotFound error");
        }
    }

    #[test]
    fn dataframe_adapter_select() {
        let df = basic_df![
            "a" => vec![1, 2, 3],
            "b" => vec![4, 5, 6],
            "c" => vec![7, 8, 9],
            "d" => vec!["x", "y", "z"]
        ];

        // Test successful selection
        let selected = df.select(vec!["a", "c"]).unwrap();
        assert_eq!(selected.shape(), (3, 2));
        assert_eq!(
            selected.column_names(),
            vec!["a".to_string(), "c".to_string()]
        );

        // Test single column selection
        let single = df.select(vec!["d"]).unwrap();
        assert_eq!(single.shape(), (3, 1));
        assert_eq!(single.column_names(), vec!["d".to_string()]);

        // Test empty selection
        let empty = df.select(vec![]).unwrap();
        assert_eq!(empty.shape(), (0, 0));

        // Test error case
        let result = df.select(vec!["a", "nonexistent"]);
        assert!(result.is_err());
        if let Err(BasicdfError::ColumnNotFound(name)) = result {
            assert_eq!(name, "nonexistent");
        } else {
            panic!("Expected ColumnNotFound error");
        }
    }

    #[test]
    fn dataframe_adapter_shape() {
        // Test regular DataFrame
        let df = basic_df![
            "col1" => vec![1, 2, 3, 4, 5],
            "col2" => vec!["a", "b", "c", "d", "e"]
        ];
        assert_eq!(df.shape(), (5, 2));

        // Test empty DataFrame
        let empty_df = BasicDataFrame::new(vec![]);
        assert_eq!(empty_df.shape(), (0, 0));

        // Test DataFrame with empty columns
        let empty_cols_df = basic_df!["empty" => vec![0i32; 0]];
        assert_eq!(empty_cols_df.shape(), (0, 1));

        // Test uneven column lengths (design philosophy: no enforcement)
        let uneven = BasicDataFrame::new(vec![
            BasicSeries(Arc::new(BasicNamedArray::new("short", vec![1, 2]))),
            BasicSeries(Arc::new(BasicNamedArray::new("long", vec![1, 2, 3, 4, 5]))),
        ]);
        assert_eq!(uneven.shape(), (5, 2)); // Takes max length
    }

    #[test]
    fn basic_df_macro_edge_cases() {
        // Test macro with different syntax variations
        let df1 = basic_df!["single" => vec![42]];
        assert_eq!(df1.columns.len(), 1);
        assert_eq!(df1.col("single").unwrap().len(), 1);

        // Test trailing comma
        let df2 = basic_df![
            "a" => vec![1, 2],
            "b" => vec![3, 4],
        ];
        assert_eq!(df2.columns.len(), 2);

        // Test mixed types
        let df3 = basic_df![
            "integers" => vec![1, 2, 3],
            "floats" => vec![1.0f32, 2.0, 3.0],
            "bools" => vec![true, false, true],
            "strings" => vec!["x", "y", "z"]
        ];
        assert_eq!(df3.columns.len(), 4);
        assert_eq!(df3.shape(), (3, 4));
    }

    #[test]
    fn basic_series_clone_and_equality() {
        let series1 = BasicSeries(Arc::new(BasicNamedArray::new("test", vec![1, 2, 3])));
        let series2 = series1.clone();

        // Test that cloned series are equal
        assert_eq!(series1, series2);

        // Test that they share the same underlying data (Arc)
        assert!(Arc::ptr_eq(&series1.0, &series2.0));

        // Test inequality
        let series3 = BasicSeries(Arc::new(BasicNamedArray::new("test", vec![1, 2, 4])));
        assert_ne!(series1, series3);

        let series4 = BasicSeries(Arc::new(BasicNamedArray::new("different", vec![1, 2, 3])));
        assert_ne!(series1, series4);
    }

    #[test]
    fn basic_dataframe_clone_and_equality() {
        let df1 = basic_df!["col1" => vec![1, 2], "col2" => vec![3, 4]];
        let df2 = df1.clone();

        assert_eq!(df1, df2);

        let df3 = basic_df!["col1" => vec![1, 2], "col2" => vec![3, 5]];
        assert_ne!(df1, df3);
    }

    #[test]
    fn large_dataframe_performance() {
        // Test with larger data to ensure no performance issues in tests
        let large_vec: Vec<i32> = (0..1000).collect();
        let df = basic_df!["large_col" => large_vec];

        assert_eq!(df.shape(), (1000, 1));
        assert_eq!(df.column_names(), vec!["large_col".to_string()]);

        let col = df.col("large_col").unwrap();
        assert_eq!(col.len(), 1000);
    }
}