surrealdb_types/traits/

surreal_value.rs

use std::borrow::Cow;
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
use std::hash::Hash;
use std::marker::PhantomData;
use std::rc::Rc;
use std::sync::Arc;

use castaway::{cast, match_type};
use rust_decimal::Decimal;
use serde::Serialize;
use serde::de::DeserializeOwned;

use crate as surrealdb_types;
use crate::error::{ConversionError, LengthMismatchError, OutOfRangeError, SerializationError};
use crate::traits::ser::Serializer;
use crate::{
	Array, Bytes, Datetime, Duration, Error, File, Geometry, Kind, Number, Object, Range, RecordId,
	Set, SurrealNone, SurrealNull, Table, Uuid, Value, kind,
};

/// Trait for converting between SurrealDB values and Rust types
///
/// This trait provides a type-safe way to convert between SurrealDB `Value` types
/// and Rust types. It defines four main operations:
/// - `kind_of()`: Returns the `Kind` that represents this type
/// - `is_value()`: Checks if a `Value` can be converted to this type
/// - `into_value()`: Converts this type into a `Value`
/// - `from_value()`: Attempts to convert a `Value` into this type
pub trait SurrealValue {
	/// Returns the kind that represents this type
	fn kind_of() -> Kind;
	/// Checks if the given value can be converted to this type
	fn is_value(value: &Value) -> bool {
		value.is_kind(&Self::kind_of())
	}
	/// Converts this type into a SurrealDB value
	fn into_value(self) -> Value;
	/// Attempts to convert a SurrealDB value into this type
	fn from_value(value: Value) -> Result<Self, Error>
	where
		Self: Sized;
}

impl<T: SurrealValue> SurrealValue for Box<T> {
	fn kind_of() -> Kind {
		T::kind_of()
	}

	fn is_value(value: &Value) -> bool {
		T::is_value(value)
	}

	fn into_value(self) -> Value {
		T::into_value(*self)
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		T::from_value(value).map(Box::new)
	}
}

impl<T: SurrealValue + Clone> SurrealValue for Arc<T> {
	fn kind_of() -> Kind {
		T::kind_of()
	}

	fn is_value(value: &Value) -> bool {
		T::is_value(value)
	}

	fn into_value(self) -> Value {
		T::into_value(self.as_ref().clone())
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		T::from_value(value).map(Arc::new)
	}
}

impl<T: SurrealValue + Clone> SurrealValue for Rc<T> {
	fn kind_of() -> Kind {
		T::kind_of()
	}

	fn is_value(value: &Value) -> bool {
		T::is_value(value)
	}

	fn into_value(self) -> Value {
		T::into_value(self.as_ref().clone())
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		T::from_value(value).map(Rc::new)
	}
}

macro_rules! impl_surreal_value {
	// Generic types
    (
        <$($generic:ident),*> $type:ty as $kind:expr,
        $($is_fnc:ident<$($is_generic:ident),*>)? ($value_is:ident) => $is:expr,
        $($from_fnc:ident<$($from_generic:ident),*>)? ($self:ident) => $into:expr,
        $($into_fnc:ident<$($into_generic:ident),*>)? ($value_into:ident) => $from:expr
		$(, as_ty => $as_fnc:ident<$($as_generic:ident),*> ($self_as:ident) => $as_expr:expr)?
		$(, is_ty_and => $is_and_fnc:ident<$($is_and_generic:ident),*> ($self_is_and:ident, $is_and_callback:ident) => $is_and:expr)?
    ) => {
        impl<$($generic: SurrealValue),*> SurrealValue for $type {
            fn kind_of() -> Kind {
                $kind
            }

            fn is_value($value_is: &Value) -> bool {
                $is
            }

            fn into_value($self) -> Value {
                $into
            }

            fn from_value($value_into: Value) -> Result<Self, Error> {
                $from
            }
        }

        $(
            impl Value {
                /// Checks if this value can be converted to the given type
                ///
                /// Returns `true` if the value can be converted to the type, `false` otherwise.
                pub fn $is_fnc<$($is_generic: SurrealValue),*>(&self) -> bool {
                    <$type>::is_value(self)
                }
            }
        )?

        $(
            impl Value {
                /// Converts the given value into a `Value`
                pub fn $from_fnc<$($from_generic: SurrealValue),*>(value: $type) -> Value {
                    <$type>::into_value(value)
                }
            }
        )?

        $(
            impl Value {
                /// Attempts to convert a SurrealDB value into the given type
                ///
                /// Returns `Ok(T)` if the conversion is successful, `Err(Error)` otherwise.
                pub fn $into_fnc<$($into_generic: SurrealValue),*>(self) -> Result<$type, Error> {
                    <$type>::from_value(self)
                }
            }
        )?

		$(
			impl Value {
				/// Returns a reference to the inner value if it matches the expected type.
				///
				/// Returns `Some(&T)` if the value is of the expected type, `None` otherwise.
				pub fn $as_fnc<$($as_generic: SurrealValue),*>(&$self_as) -> Option<&$type> {
					$as_expr
				}
			}
        )?

		$(
			impl Value {
				/// Checks if this value can be converted to the given type
				///
				/// Returns `true` if the value can be converted to the type, `false` otherwise.
				pub fn $is_and_fnc<$($is_and_generic: SurrealValue),*>(&$self_is_and, $is_and_callback: impl FnOnce(&$type) -> bool) -> bool {
					$is_and
				}
			}
		)?
    };

	// Concrete types
    (
        $type:ty as $kind:expr,
        $($is_fnc:ident),* ($value_is:ident) => $is:expr,
        $($from_fnc:ident),* ($self:ident) => $into:expr,
        $($into_fnc:ident),* ($value_into:ident) => $from:expr
		$(, as_ty => $($as_fnc:ident),+ ($self_as:ident) => $as_expr:expr)?
		$(, is_ty_and => $($is_and_fnc:ident),+($self_is_and:ident, $is_and_callback:ident) => $is_and:expr)?
    ) => {
        impl SurrealValue for $type {
            fn kind_of() -> Kind {
                $kind
            }

            fn is_value($value_is: &Value) -> bool {
                $is
            }

            fn into_value($self) -> Value {
                $into
            }

            fn from_value($value_into: Value) -> Result<Self, Error> {
                $from
            }
        }

        $(
            impl Value {
                /// Checks if this value can be converted to the given type
                ///
                /// Returns `true` if the value can be converted to the type, `false` otherwise.
                pub fn $is_fnc(&self) -> bool {
                    <$type>::is_value(self)
                }
            }
        )*

        $(
            impl Value {
                /// Converts the given value into a `Value`
                pub fn $from_fnc(value: $type) -> Value {
                    <$type>::into_value(value)
                }
            }
        )*

        $(
            impl Value {
                /// Attempts to convert a SurrealDB value into the given type
                ///
                /// Returns `Ok(T)` if the conversion is successful, `Err(Error)` otherwise.
                pub fn $into_fnc(self) -> Result<$type, Error> {
                    <$type>::from_value(self)
                }
            }
        )*

		$(
			impl Value {
				$(
					/// Returns a reference to the inner value if it matches the expected type.
					///
					/// Returns `Some(&T)` if the value is of the expected type, `None` otherwise.
					pub fn $as_fnc(&$self_as) -> Option<&$type> {
						$as_expr
					}
				)+
			}
		)?

		$(
			impl Value {
				$(
					/// Checks if this value can be converted to the given type
					///
					/// Returns `true` if the value can be converted to the type, `false` otherwise.
					pub fn $is_and_fnc(&$self_is_and, $is_and_callback: impl FnOnce(&$type) -> bool) -> bool {
						$is_and
					}
				)+
			}
		)?
    };
}

// Concrete type implementations using the macro
impl_surreal_value!(
	Value as kind!(any),
	(_value) => true,
	(self) => self,
	(value) => Ok(value)
);

impl_surreal_value!(
	() as kind!(none),
	(value) => matches!(value, Value::None),
	(self) => Value::None,
	(value) => {
		if value == Value::None {
			Ok(())
		} else {
			Err(ConversionError::from_value(Self::kind_of(), &value).into())
		}
	}
);

impl_surreal_value!(
	SurrealNone as kind!(none),
	is_none(value) => matches!(value, Value::None),
	(self) => Value::None,
	(value) => {
		if value == Value::None {
			Ok(SurrealNone)
		} else {
			Err(ConversionError::from_value(Self::kind_of(), &value).into())
		}
	}
);

impl_surreal_value!(
	SurrealNull as kind!(null),
	is_null(value) => matches!(value, Value::Null),
	(self) => Value::Null,
	(value) => {
		if value == Value::Null {
			Ok(SurrealNull)
		} else {
			Err(ConversionError::from_value(Self::kind_of(), &value).into())
		}
	}
);

impl_surreal_value!(
	bool as kind!(bool),
	is_bool(value) => matches!(value, Value::Bool(_)),
	from_bool(self) => Value::Bool(self),
	into_bool(value) => {
		let Value::Bool(b) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(b)
	},
	as_ty => as_bool(self) => {
		if let Value::Bool(b) = self {
			Some(b)
		} else {
			None
		}
	}
);

// Manual impls for true & false

impl Value {
	/// Checks if this value is specifically `true`
	///
	/// Returns `true` if the value is `Value::Bool(true)`, `false` otherwise.
	pub fn is_true(&self) -> bool {
		matches!(self, Value::Bool(true))
	}

	/// Checks if this value is specifically `false`
	///
	/// Returns `true` if the value is `Value::Bool(false)`, `false` otherwise.
	pub fn is_false(&self) -> bool {
		matches!(self, Value::Bool(false))
	}
}

impl_surreal_value!(
	Number as kind!(number),
	is_number(value) => matches!(value, Value::Number(_)),
	from_number(self) => Value::Number(self),
	into_number(value) => {
		let Value::Number(n) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(n)
	},
	as_ty => as_number(self) => {
		if let Value::Number(n) = self {
			Some(n)
		} else {
			None
		}
	},
	is_ty_and => is_number_and(self, callback) => {
		if let Value::Number(n) = self {
			callback(n)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	i64 as kind!(int),
	is_int, is_i64(value) => matches!(value, Value::Number(Number::Int(_))),
	from_int, from_i64(self) => Value::Number(Number::Int(self)),
	into_int, into_i64(value) => {
		let Value::Number(Number::Int(n)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(n)
	},
	as_ty => as_int, as_i64(self) => {
		if let Value::Number(Number::Int(n)) = self {
			Some(n)
		} else {
			None
		}
	},
	is_ty_and => is_int_and, is_i64_and(self, callback) => {
		if let Value::Number(Number::Int(n)) = self {
			callback(n)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	f64 as kind!(float),
	is_float, is_f64(value) => matches!(value, Value::Number(Number::Float(_))),
	from_float, from_f64(self) => Value::Number(Number::Float(self)),
	into_float, into_f64(value) => {
		let Value::Number(Number::Float(n)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(n)
	},
	as_ty => as_float, as_f64(self) => {
		if let Value::Number(Number::Float(n)) = self {
			Some(n)
		} else {
			None
		}
	},
	is_ty_and => is_float_and, is_f64_and(self, callback) => {
		if let Value::Number(Number::Float(n)) = self {
			callback(n)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Decimal as kind!(decimal),
	is_decimal(value) => matches!(value, Value::Number(Number::Decimal(_))),
	from_decimal(self) => Value::Number(Number::Decimal(self)),
	into_decimal(value) => {
		let Value::Number(Number::Decimal(n)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(n)
	},
	as_ty => as_decimal(self) => {
		if let Value::Number(Number::Decimal(n)) = self {
			Some(n)
		} else {
			None
		}
	},
	is_ty_and => is_decimal_and(self, callback) => {
		if let Value::Number(Number::Decimal(n)) = self {
			callback(n)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	String as kind!(string),
	is_string(value) => matches!(value, Value::String(_)),
	from_string(self) => Value::String(self),
	into_string(value) => {
		let Value::String(s) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(s)
	},
	as_ty => as_string(self) => {
		if let Value::String(s) = self {
			Some(s)
		} else {
			None
		}
	},
	is_ty_and => is_string_and(self, callback) => {
		if let Value::String(s) = self {
			callback(s)
		} else {
			false
		}
	}
);

impl<T: ToOwned + ?Sized> SurrealValue for Cow<'_, T>
where
	T::Owned: SurrealValue,
{
	fn kind_of() -> Kind {
		<T::Owned>::kind_of()
	}

	fn is_value(value: &Value) -> bool {
		<T::Owned>::is_value(value)
	}

	fn into_value(self) -> Value {
		<T::Owned>::into_value(self.into_owned())
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		<T::Owned>::from_value(value).map(Cow::Owned)
	}
}

impl SurrealValue for &str {
	fn kind_of() -> Kind {
		kind!(string)
	}

	fn is_value(value: &Value) -> bool {
		matches!(value, Value::String(_))
	}

	fn into_value(self) -> Value {
		Value::String(self.to_string())
	}

	fn from_value(_: Value) -> Result<Self, Error> {
		Err(Error::serialization(
			"Cannot convert to &str because the value would be dropped and the reference would dangle. Use String or Cow<'_, str> instead".to_owned(),
			SerializationError::Deserialization,
		))
	}
}

impl_surreal_value!(
	Duration as kind!(duration),
	is_duration(value) => matches!(value, Value::Duration(_)),
	from_duration(self) => Value::Duration(self),
	into_duration(value) => {
		let Value::Duration(d) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(d)
	},
	as_ty => as_duration(self) => {
		if let Value::Duration(d) = self {
			Some(d)
		} else {
			None
		}
	},
	is_ty_and => is_duration_and(self, callback) => {
		if let Value::Duration(d) = self {
			callback(d)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	std::time::Duration as kind!(duration),
	(value) => matches!(value, Value::Duration(_)),
	(self) => Value::Duration(Duration(self)),
	(value) => {
		let Value::Duration(Duration(d)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(d)
	}
);

impl_surreal_value!(
	Datetime as kind!(datetime),
	is_datetime(value) => matches!(value, Value::Datetime(_)),
	from_datetime(self) => Value::Datetime(self),
	into_datetime(value) => {
		let Value::Datetime(d) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(d)
	},
	as_ty => as_datetime(self) => {
		if let Value::Datetime(d) = self {
			Some(d)
		} else {
			None
		}
	},
	is_ty_and => is_datetime_and(self, callback) => {
		if let Value::Datetime(d) = self {
			callback(d)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	chrono::DateTime<chrono::Utc> as kind!(datetime),
	(value) => matches!(value, Value::Datetime(_)),
	(self) => Value::Datetime(Datetime(self)),
	(value) => {
		let Value::Datetime(Datetime(d)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(d)
	}
);

impl_surreal_value!(
	chrono::NaiveDate as kind!(datetime),
	(value) => matches!(value, Value::Datetime(_)),
	(self) => Value::Datetime(Datetime(chrono::DateTime::from_naive_utc_and_offset(self.and_time(chrono::NaiveTime::MIN), chrono::Utc))),
	(value) => {
		let Value::Datetime(Datetime(d)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(d.date_naive())
	}
);

impl_surreal_value!(
	Uuid as kind!(uuid),
	is_uuid(value) => matches!(value, Value::Uuid(_)),
	from_uuid(self) => Value::Uuid(self),
	into_uuid(value) => {
		let Value::Uuid(u) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(u)
	},
	as_ty => as_uuid(self) => {
		if let Value::Uuid(u) = self {
			Some(u)
		} else {
			None
		}
	},
	is_ty_and => is_uuid_and(self, callback) => {
		if let Value::Uuid(u) = self {
			callback(u)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	uuid::Uuid as kind!(uuid),
	(value) => matches!(value, Value::Uuid(_)),
	(self) => Value::Uuid(Uuid(self)),
	(value) => {
		let Value::Uuid(Uuid(u)) = value else {
			return Err(ConversionError::from_value(<Uuid>::kind_of(), &value).into());
		};
		Ok(u)
	}
);

impl_surreal_value!(
	Array as kind!(array),
	is_array(value) => matches!(value, Value::Array(_)),
	from_array(self) => Value::Array(self),
	into_array(value) => {
		let Value::Array(a) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(a)
	},
	as_ty => as_array(self) => {
		if let Value::Array(a) = self {
			Some(a)
		} else {
			None
		}
	},
	is_ty_and => is_array_and(self, callback) => {
		if let Value::Array(a) = self {
			callback(a)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Set as kind!(set),
	is_set(value) => matches!(value, Value::Set(_)),
	from_set(self) => Value::Set(self),
	into_set(value) => {
		let Value::Set(s) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(s)
	},
	as_ty => as_set(self) => {
		if let Value::Set(s) = self {
			Some(s)
		} else {
			None
		}
	},
	is_ty_and => is_set_and(self, callback) => {
		if let Value::Set(s) = self {
			callback(s)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Object as kind!(object),
	is_object(value) => matches!(value, Value::Object(_)),
	from_object(self) => Value::Object(self),
	into_object(value) => {
		let Value::Object(o) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(o)
	},
	as_ty => as_object(self) => {
		if let Value::Object(o) = self {
			Some(o)
		} else {
			None
		}
	},
	is_ty_and => is_object_and(self, callback) => {
		if let Value::Object(o) = self {
			callback(o)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Geometry as kind!(geometry),
	is_geometry(value) => matches!(value, Value::Geometry(_)),
	from_geometry(self) => Value::Geometry(self),
	into_geometry(value) => {
		let Value::Geometry(g) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(g)
	},
	as_ty => as_geometry(self) => {
		if let Value::Geometry(g) = self {
			Some(g)
		} else {
			None
		}
	},
	is_ty_and => is_geometry_and(self, callback) => {
		if let Value::Geometry(g) = self {
			callback(g)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Bytes as kind!(bytes),
	is_bytes(value) => matches!(value, Value::Bytes(_)),
	from_bytes(self) => Value::Bytes(self),
	into_bytes(value) => {
		let Value::Bytes(b) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(b)
	},
	as_ty => as_bytes(self) => {
		if let Value::Bytes(b) = self {
			Some(b)
		} else {
			None
		}
	},
	is_ty_and => is_bytes_and(self, callback) => {
		if let Value::Bytes(b) = self {
			callback(b)
		} else {
			false
		}
	}
);

// NOTE: Vec<u8> is intentionally NOT implemented to force explicit usage of Bytes.
// This prevents ambiguity: should Vec<u8> be bytes or an array of numbers?
// Users should explicitly use:
//   - Bytes(vec) for binary data
//   - Vec<i64> or similar for arrays of numbers

impl_surreal_value!(
	bytes::Bytes as kind!(bytes),
	(value) => matches!(value, Value::Bytes(_)),
	(self) => Value::Bytes(Bytes(self)),
	(value) => {
		let Value::Bytes(Bytes(b)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(b)
	}
);

impl_surreal_value!(
	Table as kind!(table),
	is_table(value) => {
		matches!(value, Value::Table(_))
	},
	from_table(self) => Value::Table(self),
	into_table(value) => {
		match value {
			Value::Table(t) => Ok(t),
			_ => Err(ConversionError::from_value(Self::kind_of(), &value).into()),
		}
	},
	as_ty => as_table(self) => {
		if let Value::Table(t) = self {
			Some(t)
		} else {
			None
		}
	},
	is_ty_and => is_table_and(self, callback) => {
		if let Value::Table(t) = self {
			callback(t)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	RecordId as kind!(record),
	is_record(value) => {
		match value {
			Value::RecordId(_) => true,
			Value::String(s) => Self::parse_simple(s).is_ok(),
			Value::Object(o) => {
				o.get("id").is_some()
			}
			_ => false,
		}
	},
	from_record(self) => Value::RecordId(self),
	into_record(value) => {
		match value {
			Value::RecordId(r) => Ok(r),
			Value::String(s) => Self::parse_simple(&s).map_err(|e| Error::internal(e.to_string())),
			Value::Object(o) => {
				let v = o.get("id").ok_or_else(|| Error::internal("Invalid record id".to_string()))?;
				v.clone().into_record()
			}
			Value::Array(a) => {
				let first = a.first().ok_or_else(|| Error::internal("Invalid record id: array is empty".to_string()))?;
				first.clone().into_record()
			}
			_ => Err(ConversionError::from_value(Self::kind_of(), &value).into()),
		}
	},
	as_ty => as_record(self) => {
		if let Value::RecordId(r) = self {
			Some(r)
		} else {
			None
		}
	},
	is_ty_and => is_record_and(self, callback) => {
		if let Value::RecordId(r) = self {
			callback(r)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	File as kind!(file),
	is_file(value) => matches!(value, Value::File(_)),
	from_file(self) => Value::File(self),
	into_file(value) => {
		let Value::File(f) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(f)
	},
	as_ty => as_file(self) => {
		if let Value::File(f) = self {
			Some(f)
		} else {
			None
		}
	},
	is_ty_and => is_file_and(self, callback) => {
		if let Value::File(f) = self {
			callback(f)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	Range as kind!(range),
	is_range(value) => matches!(value, Value::Range(_)),
	from_range(self) => Value::Range(Box::new(self)),
	into_range(value) => {
		let Value::Range(r) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(*r)
	},
	as_ty => as_range(self) => {
		if let Value::Range(r) = self {
			Some(r)
		} else {
			None
		}
	},
	is_ty_and => is_range_and(self, callback) => {
		if let Value::Range(r) = self {
			callback(r)
		} else {
			false
		}
	}
);

// Generic implementations using the macro
impl_surreal_value!(
	<T> Vec<T> as kind!(array<(T::kind_of())>),
	is_vec<T>(value) => {
		if let Value::Array(Array(a)) = value {
			a.iter().all(T::is_value)
		} else {
			false
		}
	},
	from_vec<T>(self) => Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect())),
	into_vec<T>(value) => {
		let Value::Array(Array(a)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		a
			.into_iter()
			.map(|v| T::from_value(v))
			.collect::<Result<Vec<T>, Error>>()
			.map_err(|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)))
	}
);

impl_surreal_value!(
	<T> Option<T> as kind!(none | (T::kind_of())),
	is_option<T>(value) => matches!(value, Value::None) || T::is_value(value),
	from_option<T>(self) => self.map(T::into_value).unwrap_or(Value::None),
	into_option<T>(value) => match value{
		Value::None => Ok(None),
		x => T::from_value(x).map(Some).map_err(|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e))),
	}
);

impl_surreal_value!(
	<V> BTreeMap<String, V> as kind!(object),
	(value) => {
		if let Value::Object(Object(o)) = value {
			o.iter().all(|(_, v)| V::is_value(v))
		} else {
			false
		}
	},
	from_btreemap<V>(self) => Value::Object(Object(self.into_iter().map(|(k, v)| (k, v.into_value())).collect())),
	into_btreemap<V>(value) => {
		let Value::Object(Object(o)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		o
			.into_iter()
			.map(|(k, v)| V::from_value(v).map(|v| (k, v)))
			.collect::<Result<BTreeMap<String, V>, Error>>()
			.map_err(|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)))
	}
);

impl_surreal_value!(
	<V> HashMap<String, V> as kind!(object),
	(value) => {
		if let Value::Object(Object(o)) = value {
			o.iter().all(|(_, v)| V::is_value(v))
		} else {
			false
		}
	},
	from_hashmap<V>(self) => Value::Object(Object(self.into_iter().map(|(k, v)| (k, v.into_value())).collect())),
	into_hashmap<V>(value) => {
		let Value::Object(Object(o)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		o
			.into_iter()
			.map(|(k, v)| V::from_value(v).map(|v| (k, v)))
			.collect::<Result<HashMap<String, V>, Error>>()
			.map_err(|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)))
	}
);

// Geometry implementations
impl_surreal_value!(
	geo::Point as kind!(geometry<point>),
	is_point(value) => matches!(value, Value::Geometry(Geometry::Point(_))),
	from_point(self) => Value::Geometry(Geometry::Point(self)),
	into_point(value) => {
		let Value::Geometry(Geometry::Point(p)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(p)
	},
	as_ty => as_point(self) => {
		if let Value::Geometry(Geometry::Point(p)) = self {
			Some(p)
		} else {
			None
		}
	},
	is_ty_and => is_point_and(self, callback) => {
		if let Value::Geometry(Geometry::Point(p)) = self {
			callback(p)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	geo::LineString as kind!(geometry<line>),
	is_line(value) => matches!(value, Value::Geometry(Geometry::Line(_))),
	from_line(self) => Value::Geometry(Geometry::Line(self)),
	into_line(value) => {
		let Value::Geometry(Geometry::Line(l)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(l)
	},
	as_ty => as_line(self) => {
		if let Value::Geometry(Geometry::Line(l)) = self {
			Some(l)
		} else {
			None
		}
	},
	is_ty_and => is_line_and(self, callback) => {
		if let Value::Geometry(Geometry::Line(l)) = self {
			callback(l)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	geo::Polygon as kind!(geometry<polygon>),
	is_polygon(value) => matches!(value, Value::Geometry(Geometry::Polygon(_))),
	from_polygon(self) => Value::Geometry(Geometry::Polygon(self)),
	into_polygon(value) => {
		let Value::Geometry(Geometry::Polygon(p)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(p)
	},
	as_ty => as_polygon(self) => {
		if let Value::Geometry(Geometry::Polygon(p)) = self {
			Some(p)
		} else {
			None
		}
	},
	is_ty_and => is_polygon_and(self, callback) => {
		if let Value::Geometry(Geometry::Polygon(p)) = self {
			callback(p)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	geo::MultiPoint as kind!(geometry<multipoint>),
	is_multipoint(value) => matches!(value, Value::Geometry(Geometry::MultiPoint(_))),
	from_multipoint(self) => Value::Geometry(Geometry::MultiPoint(self)),
	into_multipoint(value) => {
		let Value::Geometry(Geometry::MultiPoint(m)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(m)
	},
	as_ty => as_multipoint(self) => {
		if let Value::Geometry(Geometry::MultiPoint(m)) = self {
			Some(m)
		} else {
			None
		}
	},
	is_ty_and => is_multipoint_and(self, callback) => {
		if let Value::Geometry(Geometry::MultiPoint(m)) = self {
			callback(m)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	geo::MultiLineString as kind!(geometry<multiline>),
	is_multiline(value) => matches!(value, Value::Geometry(Geometry::MultiLine(_))),
	from_multiline(self) => Value::Geometry(Geometry::MultiLine(self)),
	into_multiline(value) => {
		let Value::Geometry(Geometry::MultiLine(m)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(m)
	},
	as_ty => as_multiline(self) => {
		if let Value::Geometry(Geometry::MultiLine(m)) = self {
			Some(m)
		} else {
			None
		}
	},
	is_ty_and => is_multiline_and(self, callback) => {
		if let Value::Geometry(Geometry::MultiLine(m)) = self {
			callback(m)
		} else {
			false
		}
	}
);

impl_surreal_value!(
	geo::MultiPolygon as kind!(geometry<multipolygon>),
	is_multipolygon(value) => matches!(value, Value::Geometry(Geometry::MultiPolygon(_))),
	from_multipolygon(self) => Value::Geometry(Geometry::MultiPolygon(self)),
	into_multipolygon(value) => {
		let Value::Geometry(Geometry::MultiPolygon(m)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		Ok(m)
	},
	as_ty => as_multipolygon(self) => {
		if let Value::Geometry(Geometry::MultiPolygon(m)) = self {
			Some(m)
		} else {
			None
		}
	},
	is_ty_and => is_multipolygon_and(self, callback) => {
		if let Value::Geometry(Geometry::MultiPolygon(m)) = self {
			callback(m)
		} else {
			false
		}
	}
);

// Tuple implementations
macro_rules! impl_tuples {
    ($($n:expr => ($($t:ident),+)),+ $(,)?) => {
        $(
            impl<$($t: SurrealValue),+> SurrealValue for ($($t,)+) {
                fn kind_of() -> Kind {
					kind!([$(($t::kind_of())),+])
                }

                fn is_value(value: &Value) -> bool {
                    if let Value::Array(Array(a)) = value {
                        a.len() == $n && {
                            let mut iter = a.iter();
                            $(
                                iter.next().map_or(false, |v| $t::is_value(v))
                            )&&*
                        }
                    } else {
                        false
                    }
                }

                fn into_value(self) -> Value {
                    #[allow(non_snake_case)]
                    let ($($t,)+) = self;
                    Value::Array(Array(vec![$($t.into_value()),+]))
                }

                fn from_value(value: Value) -> Result<Self, Error> {
                    let Value::Array(Array(mut a)) = value else {
                        return Err(ConversionError::from_value(Self::kind_of(), &value).into());
                    };

                    if a.len() != $n {
                        return Err(LengthMismatchError::new($n, a.len(), std::any::type_name::<Self>()).into());
                    }

                    $(#[allow(non_snake_case)] let $t = $t::from_value(a.remove(0)).map_err(|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)))?;)+
                    Ok(($($t,)+))
                }
            }
        )+
    }
}

impl_tuples! {
	1 => (A),
	2 => (A, B),
	3 => (A, B, C),
	4 => (A, B, C, D),
	5 => (A, B, C, D, E),
	6 => (A, B, C, D, E, F),
	7 => (A, B, C, D, E, F, G),
	8 => (A, B, C, D, E, F, G, H),
	9 => (A, B, C, D, E, F, G, H, I),
	10 => (A, B, C, D, E, F, G, H, I, J)
}

/// Non-standard numeric implementations, such as u8, u16, u32, u64, i8, i16, i32, isize, f32
macro_rules! impl_numeric {
	// Integer types that need checked conversion from i64
	(int: $($k:ty => ($is_fn:ident, $from_fn:ident, $into_fn:ident, $is_and_fn:ident, $as_fn:ident)),+ $(,)?) => {
		$(
			impl SurrealValue for $k {
				fn kind_of() -> Kind {
					kind!(number)
				}

				fn is_value(value: &Value) -> bool {
					matches!(value, Value::Number(_))
				}

				fn into_value(self) -> Value {
					Value::Number(Number::Int(self as i64))
				}

				fn from_value(value: Value) -> Result<Self, Error> {
					let Value::Number(Number::Int(n)) = value else {
						return Err(ConversionError::from_value(Self::kind_of(), &value).into());
					};
					<$k>::try_from(n)
						.map_err(|_| OutOfRangeError::new(n, std::any::type_name::<$k>()).into())
				}
			}

			impl Value {
				/// Checks if this value can be converted to the given type
				pub fn $is_fn(&self) -> bool {
					<$k>::is_value(self)
				}

				/// Converts the given value into a `Value`
				pub fn $from_fn(value: $k) -> Value {
					<$k>::into_value(value)
				}

				/// Attempts to convert a SurrealDB value into the given type
				pub fn $into_fn(self) -> Result<$k, Error> {
					<$k>::from_value(self)
				}

				/// Checks if this value matches the type and passes the callback check
				pub fn $is_and_fn(&self, callback: impl FnOnce(&$k) -> bool) -> bool {
					if let Value::Number(Number::Int(n)) = self {
						if let Ok(v) = <$k>::try_from(*n) {
							return callback(&v);
						}
					}
					false
				}

				/// Returns a reference-like value if it matches the expected type
				/// Note: For integer types, this returns `None` since the value needs conversion
				pub fn $as_fn(&self) -> Option<$k> {
					if let Value::Number(Number::Int(n)) = self {
						<$k>::try_from(*n).ok()
					} else {
						None
					}
				}
			}
		)+
	};

	// Float types
	(float: $($k:ty => ($is_fn:ident, $from_fn:ident, $into_fn:ident, $is_and_fn:ident, $as_fn:ident)),+ $(,)?) => {
		$(
			impl SurrealValue for $k {
				fn kind_of() -> Kind {
					kind!(number)
				}

				fn is_value(value: &Value) -> bool {
					matches!(value, Value::Number(_))
				}

				fn into_value(self) -> Value {
					Value::Number(Number::Float(self as f64))
				}

				fn from_value(value: Value) -> Result<Self, Error> {
					let Value::Number(Number::Float(n)) = value else {
						return Err(ConversionError::from_value(Self::kind_of(), &value).into());
					};
					Ok(n as $k)
				}
			}

			impl Value {
				/// Checks if this value can be converted to the given type
				pub fn $is_fn(&self) -> bool {
					<$k>::is_value(self)
				}

				/// Converts the given value into a `Value`
				pub fn $from_fn(value: $k) -> Value {
					<$k>::into_value(value)
				}

				/// Attempts to convert a SurrealDB value into the given type
				pub fn $into_fn(self) -> Result<$k, Error> {
					<$k>::from_value(self)
				}

				/// Checks if this value matches the type and passes the callback check
				pub fn $is_and_fn(&self, callback: impl FnOnce(&$k) -> bool) -> bool {
					if let Value::Number(Number::Float(n)) = self {
						let v = *n as $k;
						callback(&v)
					} else {
						false
					}
				}

				/// Returns the converted value if it matches the expected type
				/// Note: For float types, this returns a converted value, not a reference
				pub fn $as_fn(&self) -> Option<$k> {
					if let Value::Number(Number::Float(n)) = self {
						Some(*n as $k)
					} else {
						None
					}
				}
			}
		)+
	};
}

// Non-primary integer types with conversion
impl_numeric! {
	int:
		i8 => (is_i8, from_i8, into_i8, is_i8_and, as_i8),
		i16 => (is_i16, from_i16, into_i16, is_i16_and, as_i16),
		i32 => (is_i32, from_i32, into_i32, is_i32_and, as_i32),
		// i64 is implemented with the impl_surreal_value! macro
		isize => (is_isize, from_isize, into_isize, is_isize_and, as_isize),
		u8 => (is_u8, from_u8, into_u8, is_u8_and, as_u8),
		u16 => (is_u16, from_u16, into_u16, is_u16_and, as_u16),
		u32 => (is_u32, from_u32, into_u32, is_u32_and, as_u32),
		u64 => (is_u64, from_u64, into_u64, is_u64_and, as_u64),
		usize => (is_usize, from_usize, into_usize, is_usize_and, as_usize),
}

// Non-primary float types with conversion
impl_numeric! {
	float:
		f32 => (is_f32, from_f32, into_f32, is_f32_and, as_f32),
		// f64 is implemented with the impl_surreal_value! macro
}

impl SurrealValue for serde_json::Value {
	fn kind_of() -> Kind {
		kind!(any)
	}

	fn is_value(_value: &Value) -> bool {
		true
	}

	fn into_value(self) -> Value {
		match self {
			serde_json::Value::Null => Value::Null,
			serde_json::Value::Bool(b) => Value::Bool(b),
			serde_json::Value::Number(n) => {
				if let Some(i) = n.as_i64() {
					Value::Number(Number::Int(i))
				} else if let Some(f) = n.as_f64() {
					Value::Number(Number::Float(f))
				} else {
					// If we can't extract as i64 or f64, try parsing as decimal
					Value::String(n.to_string())
				}
			}
			serde_json::Value::String(s) => Value::String(s),
			serde_json::Value::Object(o) => {
				let mut obj = Object::new();
				for (k, v) in o {
					obj.insert(k, serde_json::Value::into_value(v));
				}
				Value::Object(obj)
			}
			serde_json::Value::Array(a) => {
				Value::Array(Array(a.into_iter().map(serde_json::Value::into_value).collect()))
			}
		}
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		Ok(value.into_json_value())
	}
}

macro_rules! impl_slice {
	($($n:expr),+ $(,)?) => {
		$(
			impl<T: SurrealValue> SurrealValue for [T; $n] {
				fn kind_of() -> Kind {
					kind!(array<(T::kind_of()), $n>)
				}

	fn is_value(value: &Value) -> bool {
		matches!(value, Value::Array(_))
				}

				fn into_value(self) -> Value {
					Value::Array(Array(self.into_iter().map(T::into_value).collect()))
				}

				fn from_value(value: Value) -> Result<Self, Error> {
					let Value::Array(Array(a)) = value else {
						return Err(ConversionError::from_value(Self::kind_of(), &value).into());
					};
					if a.len() != $n {
						return Err(LengthMismatchError::new($n, a.len(), std::any::type_name::<Self>()).into());
					}
					let mut result = Vec::with_capacity($n);
					for v in a {
						result.push(T::from_value(v)?);
					}
					result.try_into()
						.map_err(|v: Vec<_>| Error::internal(format!("Failed to convert vec of length {} to array of size {}", v.len(), $n)))
				}
			}
		)+
	}
}

impl_slice!(
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
	27, 28, 29, 30, 31, 32
);

impl SurrealValue for http::HeaderMap {
	fn kind_of() -> Kind {
		kind!(object)
	}

	fn is_value(value: &Value) -> bool {
		matches!(value, Value::Object(_))
	}

	fn into_value(self) -> Value {
		let mut next_key = None;
		let mut next_value = Value::None;
		let mut first_value = true;
		let mut res = BTreeMap::new();

		// Header map can contain multiple values for each header.
		// This is handled by returning the key name first and then return multiple
		// values with key name = None.
		for (k, v) in self {
			let v = match v.to_str() {
				Ok(v) => Value::String(v.to_owned()),
				Err(_) => continue,
			};

			if let Some(k) = k {
				let k = k.as_str().to_owned();
				// new key, if we had accumulated a key insert it first and then update
				// accumulated state.
				if let Some(k) = next_key.take() {
					let v = std::mem::replace(&mut next_value, Value::None);
					res.insert(k, v);
				}
				next_key = Some(k);
				next_value = v;
				first_value = true;
			} else if first_value {
				// no new key, but this is directly after the first value, turn the header value
				// into an array of values.
				first_value = false;
				next_value = Value::Array(vec![next_value, v].into())
			} else {
				// Since it is not a new key and a new value it must be atleast a third header
				// value and `next_value` is already updated to an array.
				if let Value::Array(ref mut array) = next_value {
					array.push(v);
				}
			}
		}

		// Insert final key if there is one.
		if let Some(x) = next_key {
			let v = std::mem::replace(&mut next_value, Value::None);
			res.insert(x, v);
		}

		Value::Object(Object::from(res))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		// For each kv pair in the object:
		//  - If the value is an array, insert each value into the header map.
		//  - Otherwise, insert the value into the header map.
		let Value::Object(Object(o)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		let mut res = http::HeaderMap::new();
		for (k, v) in o {
			let k = k.parse::<http::HeaderName>().map_err(|e| Error::internal(e.to_string()))?;
			match v {
				Value::Array(Array(a)) => {
					for v in a {
						let v = v
							.into_string()
							.map_err(|e| Error::internal(e.to_string()))?
							.parse::<http::HeaderValue>()
							.map_err(|e: http::header::InvalidHeaderValue| {
								Error::internal(e.to_string())
							})?;
						res.insert(k.clone(), v);
					}
				}
				Value::String(v) => {
					res.insert(
						k,
						v.parse::<http::HeaderValue>().map_err(
							|e: http::header::InvalidHeaderValue| Error::internal(e.to_string()),
						)?,
					);
				}
				unexpected => {
					return Err(ConversionError::from_value(Self::kind_of(), &unexpected).into());
				}
			}
		}
		Ok(res)
	}
}

impl SurrealValue for http::StatusCode {
	fn kind_of() -> Kind {
		kind!(number)
	}

	fn is_value(value: &Value) -> bool {
		matches!(value, Value::Number(_))
	}

	fn into_value(self) -> Value {
		Value::Number(Number::Int(self.as_u16() as i64))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Number(Number::Int(n)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};
		http::StatusCode::from_u16(n as u16)
			.map_err(|_| Error::internal("Failed to convert status code".to_string()))
	}
}

impl<T: SurrealValue> SurrealValue for LinkedList<T> {
	fn kind_of() -> Kind {
		kind!(array<(T::kind_of())>)
	}

	fn is_value(value: &Value) -> bool {
		{
			if let Value::Array(Array(a)) = value {
				a.iter().all(T::is_value)
			} else {
				false
			}
		}
	}

	fn into_value(self) -> Value {
		Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect()))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Array(Array(a)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};

		a.into_iter().map(|v| T::from_value(v)).collect::<Result<LinkedList<T>, Error>>().map_err(
			|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)),
		)
	}
}

impl<T: SurrealValue + Hash + Eq> SurrealValue for HashSet<T> {
	fn kind_of() -> Kind {
		kind!(array<(T::kind_of())>)
	}

	fn is_value(value: &Value) -> bool {
		{
			if let Value::Array(Array(a)) = value {
				a.iter().all(T::is_value)
			} else {
				false
			}
		}
	}

	fn into_value(self) -> Value {
		Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect()))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Array(Array(a)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};

		a.into_iter().map(|v| T::from_value(v)).collect::<Result<HashSet<T>, Error>>().map_err(
			|e| Error::internal(format!("Failed to convert to {}: {}", Self::kind_of(), e)),
		)
	}
}

impl<T: SurrealValue + Ord> SurrealValue for BTreeSet<T> {
	fn kind_of() -> Kind {
		kind!(array<(T::kind_of())>)
	}

	fn is_value(value: &Value) -> bool {
		if let Value::Array(Array(array)) = value {
			array.iter().all(T::is_value)
		} else {
			false
		}
	}

	fn into_value(self) -> Value {
		Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect()))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Array(Array(array)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};

		array.into_iter().map(|v| T::from_value(v)).collect::<Result<BTreeSet<T>, Error>>().map_err(
			|error| {
				Error::serialization(
					format!("Failed to convert to {}: {error}", Self::kind_of()),
					SerializationError::Deserialization,
				)
			},
		)
	}
}

impl<T: SurrealValue> SurrealValue for VecDeque<T> {
	fn kind_of() -> Kind {
		kind!(array<(T::kind_of())>)
	}

	fn is_value(value: &Value) -> bool {
		if let Value::Array(Array(array)) = value {
			array.iter().all(T::is_value)
		} else {
			false
		}
	}

	fn into_value(self) -> Value {
		Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect()))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Array(Array(array)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};

		array.into_iter().map(|v| T::from_value(v)).collect::<Result<VecDeque<T>, Error>>().map_err(
			|error| {
				Error::serialization(
					format!("Failed to convert to {}: {error}", Self::kind_of()),
					SerializationError::Deserialization,
				)
			},
		)
	}
}

impl<T: SurrealValue + Ord> SurrealValue for BinaryHeap<T> {
	fn kind_of() -> Kind {
		kind!(array<(T::kind_of())>)
	}

	fn is_value(value: &Value) -> bool {
		if let Value::Array(Array(array)) = value {
			array.iter().all(T::is_value)
		} else {
			false
		}
	}

	fn into_value(self) -> Value {
		Value::Array(Array(self.into_iter().map(SurrealValue::into_value).collect()))
	}

	fn from_value(value: Value) -> Result<Self, Error> {
		let Value::Array(Array(array)) = value else {
			return Err(ConversionError::from_value(Self::kind_of(), &value).into());
		};

		array
			.into_iter()
			.map(|v| T::from_value(v))
			.collect::<Result<BinaryHeap<T>, Error>>()
			.map_err(|error| {
				Error::serialization(
					format!("Failed to convert to {}: {error}", Self::kind_of()),
					SerializationError::Deserialization,
				)
			})
	}
}

/// A wrapper struct that allows bridging between SurrealValue and types that implement Serialize
/// and Deserialize
///
/// # A note on parity with `SurrealValue`
/// Serializing and Deserializing a type does *not* behave the same as `SurrealValue` in some cases.
/// Notably:
/// - Enum variants behave differently
/// - The only primitives taken advantage of are String, Number, Bool, Bytes, Object, and Array
///
/// As such, it's best to use SurrealValue directly where possible. This is intended for types where
/// an implementation of SurrealValue isn't available or practical
pub struct SerdeWrapper<T: Serialize + DeserializeOwned + 'static>(pub T);

impl<T: Serialize + DeserializeOwned + 'static> SurrealValue for SerdeWrapper<T> {
	fn kind_of() -> Kind {
		Kind::Any
	}

	fn into_value(self) -> Value {
		match_type!(self.0, {
			uuid::Uuid as uuid => Value::Uuid(Uuid::from(uuid)),
			chrono::DateTime<chrono::Utc> as datetime => Value::Datetime(Datetime::from(datetime)),
			std::time::Duration as duration => Value::Duration(Duration::from(duration)),
			Vec<uuid::Uuid> as uuids => Value::Array(Array(
				uuids.into_iter().map(|uuid| Value::Uuid(Uuid::from(uuid))).collect(),
			)),
			Vec<chrono::DateTime<chrono::Utc>> as datetimes => Value::Array(Array(
				datetimes
					.into_iter()
					.map(|datetime| Value::Datetime(Datetime::from(datetime)))
					.collect(),
			)),
			Vec<std::time::Duration> as durations => Value::Array(Array(
				durations
					.into_iter()
					.map(|duration| Value::Duration(Duration::from(duration)))
					.collect(),
			)),
			Option<uuid::Uuid> as uuid => uuid.map(|uuid| Value::Uuid(Uuid::from(uuid))).unwrap_or(Value::None),
			Option<chrono::DateTime<chrono::Utc>> as datetime => datetime
				.map(|datetime| Value::Datetime(Datetime::from(datetime)))
				.unwrap_or(Value::None),
			Option<std::time::Duration> as duration => duration
				.map(|duration| Value::Duration(Duration::from(duration)))
				.unwrap_or(Value::None),
			BTreeMap<String, uuid::Uuid> as map => Value::Object(Object(
				map
					.into_iter()
					.map(|(key, uuid)| (key, Value::Uuid(Uuid::from(uuid))))
					.collect(),
			)),
			BTreeMap<String, chrono::DateTime<chrono::Utc>> as map => Value::Object(Object(
				map
					.into_iter()
					.map(|(key, datetime)| (key, Value::Datetime(Datetime::from(datetime))))
					.collect(),
			)),
		BTreeMap<String, std::time::Duration> as map => Value::Object(Object(
			map
				.into_iter()
				.map(|(key, duration)| (key, Value::Duration(Duration::from(duration))))
				.collect(),
		)),
		HashMap<String, uuid::Uuid> as map => Value::Object(Object(
			map
				.into_iter()
				.map(|(key, uuid)| (key, Value::Uuid(Uuid::from(uuid))))
				.collect(),
		)),
		HashMap<String, chrono::DateTime<chrono::Utc>> as map => Value::Object(Object(
			map
				.into_iter()
				.map(|(key, datetime)| (key, Value::Datetime(Datetime::from(datetime))))
				.collect(),
		)),
		HashMap<String, std::time::Duration> as map => Value::Object(Object(
			map
				.into_iter()
				.map(|(key, duration)| (key, Value::Duration(Duration::from(duration))))
				.collect(),
		)),
		value => match value.serialize(Serializer) {
			Ok(value) => value,
			Err(err) => {
				let error = format!("SerdeWrapper serialization to value failed: {err}");
				debug_assert!(false, "{error}");
				tracing::warn!("{error}");
				// TODO: `into_value` should return `Result` so we can propagate
				// this error instead of silently dropping it. For now we return
				// `Value::None` since that's the least harmful fallback.
				Value::None
			}
		},
		})
	}

	fn from_value(value: Value) -> Result<Self, Error>
	where
		Self: Sized,
	{
		let cast_error = |target: &str| {
			Error::serialization(
				format!("failed to cast {target} wrapper type"),
				SerializationError::Deserialization,
			)
		};

		match_type!(PhantomData::<T>, {
			PhantomData<uuid::Uuid> as _ => {
				let uuid = uuid::Uuid::from_value(value)?;
				let typed = cast!(uuid, T).map_err(|_| cast_error("uuid"))?;
				Ok(Self(typed))
			},
			PhantomData<chrono::DateTime<chrono::Utc>> as _ => {
				let datetime = chrono::DateTime::<chrono::Utc>::from_value(value)?;
				let typed = cast!(datetime, T).map_err(|_| cast_error("datetime"))?;
				Ok(Self(typed))
			},
			PhantomData<std::time::Duration> as _ => {
				let duration = std::time::Duration::from_value(value)?;
				let typed = cast!(duration, T).map_err(|_| cast_error("duration"))?;
				Ok(Self(typed))
			},
			PhantomData<Vec<uuid::Uuid>> as _ => {
				let uuids = Vec::<Uuid>::from_value(value)?
					.into_iter()
					.map(Uuid::into_inner)
					.collect::<Vec<_>>();
				let typed = cast!(uuids, T).map_err(|_| cast_error("uuid vec"))?;
				Ok(Self(typed))
			},
			PhantomData<Vec<chrono::DateTime<chrono::Utc>>> as _ => {
				let datetimes = Vec::<Datetime>::from_value(value)?
					.into_iter()
					.map(Datetime::into_inner)
					.collect::<Vec<_>>();
				let typed = cast!(datetimes, T).map_err(|_| cast_error("datetime vec"))?;
				Ok(Self(typed))
			},
			PhantomData<Vec<std::time::Duration>> as _ => {
				let durations = Vec::<Duration>::from_value(value)?
					.into_iter()
					.map(Duration::into_inner)
					.collect::<Vec<_>>();
				let typed = cast!(durations, T).map_err(|_| cast_error("duration vec"))?;
				Ok(Self(typed))
			},
			PhantomData<Option<uuid::Uuid>> as _ => {
				let uuid = Option::<Uuid>::from_value(value)?.map(Uuid::into_inner);
				let typed = cast!(uuid, T).map_err(|_| cast_error("uuid option"))?;
				Ok(Self(typed))
			},
			PhantomData<Option<chrono::DateTime<chrono::Utc>>> as _ => {
				let datetime = Option::<Datetime>::from_value(value)?.map(Datetime::into_inner);
				let typed = cast!(datetime, T).map_err(|_| cast_error("datetime option"))?;
				Ok(Self(typed))
			},
			PhantomData<Option<std::time::Duration>> as _ => {
				let duration = Option::<Duration>::from_value(value)?.map(Duration::into_inner);
				let typed = cast!(duration, T).map_err(|_| cast_error("duration option"))?;
				Ok(Self(typed))
			},
			PhantomData<BTreeMap<String, uuid::Uuid>> as _ => {
				let map = BTreeMap::<String, Uuid>::from_value(value)?
					.into_iter()
					.map(|(key, uuid)| (key, uuid.into_inner()))
					.collect::<BTreeMap<_, _>>();
				let typed = cast!(map, T).map_err(|_| cast_error("uuid map"))?;
				Ok(Self(typed))
			},
			PhantomData<BTreeMap<String, chrono::DateTime<chrono::Utc>>> as _ => {
				let map = BTreeMap::<String, Datetime>::from_value(value)?
					.into_iter()
					.map(|(key, datetime)| (key, datetime.into_inner()))
					.collect::<BTreeMap<_, _>>();
				let typed = cast!(map, T).map_err(|_| cast_error("datetime map"))?;
				Ok(Self(typed))
			},
		PhantomData<BTreeMap<String, std::time::Duration>> as _ => {
			let map = BTreeMap::<String, Duration>::from_value(value)?
				.into_iter()
				.map(|(key, duration)| (key, duration.into_inner()))
				.collect::<BTreeMap<_, _>>();
			let typed = cast!(map, T).map_err(|_| cast_error("duration map"))?;
			Ok(Self(typed))
		},
		PhantomData<HashMap<String, uuid::Uuid>> as _ => {
			let map = HashMap::<String, Uuid>::from_value(value)?
				.into_iter()
				.map(|(key, uuid)| (key, uuid.into_inner()))
				.collect::<HashMap<_, _>>();
			let typed = cast!(map, T).map_err(|_| cast_error("uuid hashmap"))?;
			Ok(Self(typed))
		},
		PhantomData<HashMap<String, chrono::DateTime<chrono::Utc>>> as _ => {
			let map = HashMap::<String, Datetime>::from_value(value)?
				.into_iter()
				.map(|(key, datetime)| (key, datetime.into_inner()))
				.collect::<HashMap<_, _>>();
			let typed = cast!(map, T).map_err(|_| cast_error("datetime hashmap"))?;
			Ok(Self(typed))
		},
		PhantomData<HashMap<String, std::time::Duration>> as _ => {
			let map = HashMap::<String, Duration>::from_value(value)?
				.into_iter()
				.map(|(key, duration)| (key, duration.into_inner()))
				.collect::<HashMap<_, _>>();
			let typed = cast!(map, T).map_err(|_| cast_error("duration hashmap"))?;
			Ok(Self(typed))
		},
		_ => Ok(Self(T::deserialize(value)?)),
		})
	}
}

#[cfg(test)]
mod test {
	use std::fmt::Debug;

	use rstest::rstest;
	use serde::{Deserialize, Serialize};

	use super::*;
	use crate::RecordIdKey;

	#[derive(Serialize, Deserialize, PartialEq, Debug)]
	enum Test {
		A,
		B(u8),
		C {
			hi: String,
		},
	}

	#[derive(Serialize, Deserialize, PartialEq, Debug)]
	struct Test2 {
		is_goober: bool,
		sneaky_and_evil: (),
		also_sneaky_and_evil: Gerald,
	}

	#[derive(Serialize, Deserialize, PartialEq, Debug)]
	struct Gerald;

	#[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
	struct SpecialPayload {
		uuid: Uuid,
		datetime: Datetime,
		duration: Duration,
		record_id: RecordId,
	}

	#[rstest]
	#[case::u8(64_u8)]
	#[case::u16(64_u16)]
	#[case::u32(64_u32)]
	#[case::u64(64_u64)]
	#[case::i8(64_i8)]
	#[case::i16(64_i16)]
	#[case::i32(64_i32)]
	#[case::i64(64_i64)]
	#[case::f32(64.0_f32)]
	#[case::f64(64.0_f64)]
	#[case::bool(true)]
	#[case::zst_unit(())]
	#[case::zst_arr([(); 0])]
	#[case::zst_struct(Gerald)]
	// static strings don't work because Value isn't zero-copy
	//#[case::static_str("woag!")]
	#[case::string("woag!".to_string())]
	#[case::unit_enum(Test::A)]
	#[case::newtype_enum(Test::B(64))]
	#[case::struct_enum(Test::C{hi: "woag!".to_string()})]
	#[case::_struct(Test2 {
		is_goober: true,
		sneaky_and_evil: (),
		also_sneaky_and_evil: Gerald
	})]
	#[allow(non_snake_case)]
	fn wrapper_roundtrip<'a>(#[case] value: impl Serialize + Deserialize<'a> + PartialEq + Debug) {
		let serialized_value = value.serialize(Serializer).expect("this should work!");
		let deserialized_value =
			<_ as Deserialize>::deserialize(serialized_value).expect("this should work!");
		assert_eq!(value, deserialized_value);
	}

	#[test]
	fn wrapper_roundtrip_special_surreal_types_uses_native_variants() {
		let datetime =
			Datetime::from_timestamp(1_706_660_400, 123_000_000).expect("valid datetime");
		let uuid = Uuid::new_v4();
		let duration = Duration::new(42, 7);
		let record_id = RecordId::new("person", RecordIdKey::Uuid(Uuid::new_v4()));

		assert_eq!(SerdeWrapper(datetime).into_value(), datetime.into_value());
		assert_eq!(SerdeWrapper(uuid).into_value(), uuid.into_value());
		assert_eq!(SerdeWrapper(duration).into_value(), duration.into_value());
		assert_eq!(SerdeWrapper(record_id.clone()).into_value(), record_id.clone().into_value());

		assert_eq!(
			SerdeWrapper::<Datetime>::from_value(datetime.into_value())
				.expect("roundtrip Datetime")
				.0,
			datetime
		);
		assert_eq!(
			SerdeWrapper::<Uuid>::from_value(uuid.into_value()).expect("roundtrip Uuid").0,
			uuid
		);
		assert_eq!(
			SerdeWrapper::<Duration>::from_value(duration.into_value())
				.expect("roundtrip Duration")
				.0,
			duration
		);
		assert_eq!(
			SerdeWrapper::<RecordId>::from_value(record_id.clone().into_value())
				.expect("roundtrip RecordId")
				.0,
			record_id
		);
	}

	#[test]
	fn wrapper_roundtrip_nested_payload_keeps_surreal_types() {
		let payload = SpecialPayload {
			uuid: Uuid::new_v4(),
			datetime: Datetime::from_timestamp(1_706_660_400, 0).expect("valid datetime"),
			duration: Duration::new(3600, 500),
			record_id: RecordId::new("person", "alice"),
		};

		let value = SerdeWrapper(payload.clone()).into_value();
		let Value::Object(object) = &value else {
			panic!("payload should serialize to object");
		};
		assert!(matches!(object.get("uuid"), Some(Value::Uuid(_))));
		assert!(matches!(object.get("datetime"), Some(Value::Datetime(_))));
		assert!(matches!(object.get("duration"), Some(Value::Duration(_))));
		assert!(matches!(object.get("record_id"), Some(Value::RecordId(_))));

		let roundtrip = SerdeWrapper::<SpecialPayload>::from_value(value)
			.expect("payload should deserialize from value")
			.0;
		assert_eq!(roundtrip, payload);
	}

	#[test]
	fn deserializing_none_into_non_option_is_an_error_not_a_panic() {
		let result = std::panic::catch_unwind(|| i64::deserialize(Value::None));
		assert!(result.is_ok(), "deserializing Value::None should not panic");
		assert!(result.expect("no panic").is_err());
	}

	#[test]
	fn cow_str_roundtrip() {
		let original: Cow<'_, str> = Cow::Borrowed("hello");
		let value = original.clone().into_value();
		assert!(matches!(value, Value::String(ref s) if s == "hello"));
		let recovered = Cow::<'_, str>::from_value(value).unwrap();
		assert_eq!(recovered, "hello");

		let owned: Cow<'_, str> = Cow::Owned("world".to_string());
		let value = owned.into_value();
		let recovered = Cow::<'_, str>::from_value(value).unwrap();
		assert_eq!(recovered, "world");
	}

	#[test]
	fn cow_str_kind_of() {
		assert_eq!(Cow::<'_, str>::kind_of(), kind!(string));
	}

	#[test]
	fn cow_str_is_value() {
		assert!(Cow::<'_, str>::is_value(&Value::String("test".to_string())));
		assert!(!Cow::<'_, str>::is_value(&Value::Number(Number::Int(42))));
	}

	#[test]
	fn cow_clone_type_roundtrip() {
		let original: Cow<'_, str> = Cow::Owned("hello".to_string());
		let value = original.into_value();
		assert!(matches!(value, Value::String(ref s) if s == "hello"));
		let recovered = Cow::<'_, str>::from_value(value).unwrap();
		assert_eq!(recovered.into_owned(), "hello");

		let original: Cow<'_, i64> = Cow::Owned(42);
		let value = original.into_value();
		let recovered = Cow::<'_, i64>::from_value(value).unwrap();
		assert_eq!(recovered.into_owned(), 42);

		let original: Cow<'_, bool> = Cow::Owned(true);
		let value = original.into_value();
		let recovered = Cow::<'_, bool>::from_value(value).unwrap();
		assert!(recovered.into_owned());
	}

	#[test]
	fn cow_from_value_type_mismatch() {
		let value = Value::Number(Number::Int(42));
		let result = Cow::<'_, str>::from_value(value);
		assert!(result.is_err());
	}
}