sqlite-diff-rs 0.1.2

//! `SQLite` changeset value encoding.
//!
//! **IMPORTANT**: `SQLite` changesets use a DIFFERENT encoding than database records!
//!
//! Changeset value types (used in this module):
//! - 0: Undefined (special marker for unchanged columns in UPDATE)
//! - 1: INTEGER (always 8 bytes, big-endian i64)
//! - 2: FLOAT (8 bytes, big-endian IEEE 754)
//! - 3: TEXT (varint length + UTF-8 bytes)
//! - 4: BLOB (varint length + raw bytes)
//! - 5: NULL (no data follows)
//!
//! This is NOT the same as `SQLite` database record serial types!
//! Database records use types 0-9 plus computed types for variable-length data.

use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::hash::{Hash, Hasher};

use super::varint::encode_varint_simple;

/// A value that can be encoded in `SQLite` changeset format.
#[derive(Debug, Clone)]
pub enum Value<S, B> {
    /// SQL NULL
    Null,
    /// 64-bit signed integer (always encoded as 8 bytes big-endian)
    Integer(i64),
    /// IEEE 754 floating point (8 bytes big-endian)
    Real(f64),
    /// UTF-8 text (varint length + bytes)
    Text(S),
    /// Binary blob (varint length + bytes)
    Blob(B),
}

impl<S: Copy, B: Copy> Copy for Value<S, B> {}

/// Internal type for representing values in changesets, where `None` means "undefined"
/// (unchanged column in UPDATE operations).
pub(crate) type MaybeValue<S, B> = Option<Value<S, B>>;

// Custom PartialEq to handle f64 bit-equality
impl<S: AsRef<str> + PartialEq, B: AsRef<[u8]> + PartialEq> PartialEq for Value<S, B> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Value::Integer(a), Value::Integer(b)) => a == b,
            (Value::Real(a), Value::Real(b)) => a.to_bits() == b.to_bits(),
            (Value::Text(a), Value::Text(b)) => a == b,
            (Value::Blob(a), Value::Blob(b)) => a == b,
            (Value::Null, Value::Null) => true,
            _ => false,
        }
    }
}

impl<S: AsRef<str> + Eq, B: AsRef<[u8]> + Eq> Eq for Value<S, B> {}

impl<S: AsRef<str> + Hash, B: AsRef<[u8]> + Hash> Hash for Value<S, B> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        core::mem::discriminant(self).hash(state);
        match self {
            Value::Integer(v) => v.hash(state),
            Value::Real(v) => v.to_bits().hash(state),
            Value::Text(v) => v.hash(state),
            Value::Blob(v) => v.hash(state),
            Value::Null => {}
        }
    }
}

// From implementations for common types
impl<S: AsRef<str>, B: AsRef<[u8]>> From<i64> for Value<S, B> {
    #[inline]
    fn from(v: i64) -> Self {
        Value::Integer(v)
    }
}

impl<S: AsRef<str>, B: AsRef<[u8]>> From<i32> for Value<S, B> {
    #[inline]
    fn from(v: i32) -> Self {
        Value::Integer(i64::from(v))
    }
}

impl<B: AsRef<[u8]>> From<String> for Value<String, B> {
    #[inline]
    fn from(v: String) -> Self {
        Value::Text(v)
    }
}

impl<B: AsRef<[u8]>> From<&str> for Value<String, B> {
    #[inline]
    fn from(v: &str) -> Self {
        Value::Text(v.to_string())
    }
}

impl<S: AsRef<str>, B: AsRef<[u8]>> From<f64> for Value<S, B> {
    #[inline]
    fn from(v: f64) -> Self {
        Value::Real(v)
    }
}

impl<S: AsRef<str>> From<Vec<u8>> for Value<S, Vec<u8>> {
    fn from(v: Vec<u8>) -> Self {
        Value::Blob(v)
    }
}

impl<S: AsRef<str>> From<&[u8]> for Value<S, Vec<u8>> {
    fn from(v: &[u8]) -> Self {
        Value::Blob(v.to_vec())
    }
}

impl<T: Into<Value<String, Vec<u8>>>> From<Option<T>> for Value<String, Vec<u8>> {
    fn from(opt: Option<T>) -> Self {
        match opt {
            Some(v) => v.into(),
            None => Value::Null,
        }
    }
}

impl<S: AsRef<str>, B: AsRef<[u8]>> Value<S, B> {
    /// Convert to an owned Value by cloning the underlying data.
    pub fn to_owned(&self) -> Value<String, Vec<u8>> {
        match self {
            Value::Null => Value::Null,
            Value::Integer(v) => Value::Integer(*v),
            Value::Real(v) => Value::Real(*v),
            Value::Text(s) => Value::Text(s.as_ref().to_string()),
            Value::Blob(b) => Value::Blob(b.as_ref().to_vec()),
        }
    }

    /// Borrow as a reference Value.
    pub fn as_ref(&self) -> Value<&str, &[u8]> {
        match self {
            Value::Null => Value::Null,
            Value::Integer(v) => Value::Integer(*v),
            Value::Real(v) => Value::Real(*v),
            Value::Text(s) => Value::Text(s.as_ref()),
            Value::Blob(b) => Value::Blob(b.as_ref()),
        }
    }
}

mod display;

/// Encode the "undefined" marker (type 0) into the changeset binary format.
///
/// This is used for unchanged columns in UPDATE operations.
#[inline]
pub(crate) fn encode_undefined(out: &mut Vec<u8>) {
    out.push(0x00);
}

/// Encode a Maybe value (Option<Value>) into the changeset binary format.
///
/// `SQLite` changesets use a DIFFERENT encoding than database records:
/// - Type 0: Undefined (special marker for unchanged columns in UPDATE)
/// - Type 1: INTEGER (always 8 bytes, big-endian i64)
/// - Type 2: FLOAT (8 bytes, big-endian IEEE 754)
/// - Type 3: TEXT (varint length + UTF-8 bytes)
/// - Type 4: BLOB (varint length + raw bytes)
/// - Type 5: NULL (no data follows)
///
/// This is NOT the same as `SQLite` serial types used in database records!
pub(crate) fn encode_value<S: AsRef<str>, B: AsRef<[u8]>>(
    out: &mut Vec<u8>,
    value: Option<&Value<S, B>>,
) {
    match value {
        None => encode_undefined(out),
        Some(v) => encode_defined_value(out, v),
    }
}

/// Encode a defined (non-undefined) value into the changeset binary format.
pub(crate) fn encode_defined_value<S: AsRef<str>, B: AsRef<[u8]>>(
    out: &mut Vec<u8>,
    value: &Value<S, B>,
) {
    match value {
        Value::Null => {
            // NULL is type 5 in changeset format
            out.push(0x05);
        }
        Value::Integer(v) => {
            // INTEGER is type 1, always 8 bytes big-endian
            out.push(0x01);
            out.extend(v.to_be_bytes());
        }
        Value::Real(v) => {
            // SQLite converts NaN to NULL, but preserves Infinity
            if v.is_nan() {
                out.push(0x05); // NULL
            } else {
                // FLOAT is type 2, 8 bytes big-endian IEEE 754
                // SQLite normalizes -0.0 to 0.0
                out.push(0x02);
                let normalized = if *v == 0.0 { 0.0 } else { *v };
                out.extend(normalized.to_be_bytes());
            }
        }
        Value::Text(s) => {
            // TEXT is type 3, varint length + UTF-8 bytes
            let s = s.as_ref();
            out.push(0x03);
            out.extend(encode_varint_simple(s.len() as u64));
            out.extend(s.as_bytes());
        }
        Value::Blob(b) => {
            // BLOB is type 4, varint length + raw bytes
            let b = b.as_ref();
            out.push(0x04);
            out.extend(encode_varint_simple(b.len() as u64));
            out.extend(b);
        }
    }
}

/// Decode a value from changeset binary format.
///
/// `SQLite` changesets use the following type codes:
/// - 0: Undefined (unchanged column in UPDATE)
/// - 1: INTEGER (8 bytes big-endian)
/// - 2: FLOAT (8 bytes big-endian IEEE 754)
/// - 3: TEXT (varint length + UTF-8)
/// - 4: BLOB (varint length + raw bytes)
/// - 5: NULL
///
/// Returns the value (None for Undefined) and number of bytes consumed.
#[must_use]
pub(crate) fn decode_value(data: &[u8]) -> Option<(MaybeValue<String, Vec<u8>>, usize)> {
    use super::varint::decode_varint;

    if data.is_empty() {
        return None;
    }

    let type_code = data[0];
    let data = &data[1..];

    match type_code {
        0 => {
            // Undefined marker
            Some((None, 1))
        }
        1 => {
            // INTEGER: 8 bytes big-endian
            if data.len() < 8 {
                return None;
            }
            let v = i64::from_be_bytes([
                data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
            ]);
            Some((Some(Value::Integer(v)), 9))
        }
        2 => {
            // FLOAT: 8 bytes big-endian IEEE 754
            if data.len() < 8 {
                return None;
            }
            let v = f64::from_be_bytes([
                data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
            ]);
            // SQLite normalizes NaN to NULL and -0.0 to 0.0, so we do the same
            // during decoding to ensure roundtrip consistency
            if v.is_nan() {
                Some((Some(Value::Null), 9))
            } else {
                // Normalize -0.0 to 0.0
                let normalized = if v == 0.0 { 0.0 } else { v };
                Some((Some(Value::Real(normalized)), 9))
            }
        }
        3 => {
            // TEXT: varint length + UTF-8 bytes
            let (len, len_bytes) = decode_varint(data)?;
            let len = usize::try_from(len).ok()?;
            let data = &data[len_bytes..];
            if data.len() < len {
                return None;
            }
            let text = String::from_utf8(data[..len].to_vec()).ok()?;
            Some((Some(Value::Text(text)), 1 + len_bytes + len))
        }
        4 => {
            // BLOB: varint length + raw bytes
            let (len, len_bytes) = decode_varint(data)?;
            let len = usize::try_from(len).ok()?;
            let data = &data[len_bytes..];
            if data.len() < len {
                return None;
            }
            Some((Some(Value::Blob(data[..len].to_vec())), 1 + len_bytes + len))
        }
        5 => {
            // NULL
            Some((Some(Value::Null), 1))
        }
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloc::vec;

    // Type alias for common test usage
    type TestValue = Value<String, Vec<u8>>;

    #[test]
    fn test_encode_decode_null() {
        let mut buf = Vec::new();
        encode_value(&mut buf, Some(&TestValue::Null));
        let (decoded, len) = decode_value(&buf).unwrap();
        assert_eq!(decoded, Some(TestValue::Null));
        assert_eq!(len, buf.len());
    }

    #[test]
    fn test_encode_decode_integers() {
        for v in [
            0,
            1,
            -1,
            127,
            -128,
            32767,
            -32768,
            i64::from(i32::MAX),
            i64::MAX,
        ] {
            let mut buf = Vec::new();
            encode_value(&mut buf, Some(&TestValue::Integer(v)));
            let (decoded, len) = decode_value(&buf).unwrap();
            assert_eq!(decoded, Some(TestValue::Integer(v)), "Failed for {v}");
            assert_eq!(len, buf.len());
            // All integers should be encoded as type 1 + 8 bytes = 9 bytes total
            assert_eq!(buf.len(), 9, "Integer {v} should be 9 bytes");
        }
    }

    #[test]
    fn test_encode_decode_real() {
        let mut buf = Vec::new();
        encode_value(&mut buf, Some(&TestValue::Real(6.14159)));
        let (decoded, len) = decode_value(&buf).unwrap();
        assert_eq!(decoded, Some(TestValue::Real(6.14159)));
        assert_eq!(len, buf.len());
        // Float is type 2 + 8 bytes = 9 bytes total
        assert_eq!(buf.len(), 9);
    }

    #[test]
    fn test_encode_decode_text() {
        let mut buf = Vec::new();
        // Use reference type for encoding
        let ref_value: Value<&str, &[u8]> = Value::Text("hello");
        encode_value(&mut buf, Some(&ref_value));
        let (decoded, len) = decode_value(&buf).unwrap();
        assert_eq!(decoded, Some(TestValue::Text("hello".to_string())));
        assert_eq!(len, buf.len());
        // Text is type 3 + varint(5) + "hello" = 1 + 1 + 5 = 7 bytes
        assert_eq!(buf.len(), 7);
    }

    #[test]
    fn test_encode_decode_blob() {
        let mut buf = Vec::new();
        // Use reference type for encoding
        let data: &[u8] = &[1, 2, 3, 4, 5];
        let ref_value: Value<&str, &[u8]> = Value::Blob(data);
        encode_value(&mut buf, Some(&ref_value));
        let (decoded, len) = decode_value(&buf).unwrap();
        assert_eq!(decoded, Some(TestValue::Blob(vec![1, 2, 3, 4, 5])));
        assert_eq!(len, buf.len());
        // Blob is type 4 + varint(5) + data = 1 + 1 + 5 = 7 bytes
        assert_eq!(buf.len(), 7);
    }

    #[test]
    fn test_encode_decode_undefined() {
        let mut buf = Vec::new();
        encode_value::<String, Vec<u8>>(&mut buf, None);
        let (decoded, len) = decode_value(&buf).unwrap();
        assert_eq!(decoded, None);
        assert_eq!(len, buf.len());
        // Undefined is type 0, just 1 byte
        assert_eq!(buf.len(), 1);
    }

    #[test]
    fn test_changeset_encoding_matches_rusqlite() {
        // Test that our encoding matches what rusqlite produces

        // Integer 1 should be: type 1 + 8 bytes (big-endian)
        let mut buf = Vec::new();
        encode_value(&mut buf, Some(&TestValue::Integer(1)));
        assert_eq!(
            buf,
            vec![0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
        );

        // Integer 100 should be: type 1 + 8 bytes (big-endian)
        let mut buf = Vec::new();
        encode_value(&mut buf, Some(&TestValue::Integer(100)));
        assert_eq!(
            buf,
            vec![0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64]
        );

        // Text "alice" should be: type 3 + varint(5) + "alice"
        // Using reference type here
        let mut buf = Vec::new();
        let ref_value: Value<&str, &[u8]> = Value::Text("alice");
        encode_value(&mut buf, Some(&ref_value));
        assert_eq!(buf, vec![0x03, 0x05, b'a', b'l', b'i', b'c', b'e']);

        // NULL should be type 5
        let mut buf = Vec::new();
        encode_value(&mut buf, Some(&Value::Null::<&str, &[u8]>));
        assert_eq!(buf, vec![0x05]);
    }

    #[test]
    fn test_cross_type_equality() {
        // Test that Value<&str, &[u8]> and Value<String, Vec<u8>> can be compared via conversion
        let owned: Value<String, Vec<u8>> = Value::Text("hello".to_string());
        let borrowed: Value<&str, &[u8]> = Value::Text("hello");
        assert_eq!(owned.as_ref(), borrowed);
        assert_eq!(borrowed.to_owned(), owned);

        let owned_blob: Value<String, Vec<u8>> = Value::Blob(vec![1, 2, 3]);
        let data: &[u8] = &[1, 2, 3];
        let borrowed_blob: Value<&str, &[u8]> = Value::Blob(data);
        assert_eq!(owned_blob.as_ref(), borrowed_blob);
    }

    #[test]
    fn test_to_owned_and_as_ref() {
        let owned: Value<String, Vec<u8>> = Value::Text("hello".to_string());
        let borrowed = owned.as_ref();
        assert_eq!(owned.as_ref(), borrowed);

        let back_to_owned = borrowed.to_owned();
        assert_eq!(owned, back_to_owned);
    }

    #[test]
    fn test_value_from_impls() {
        type V = Value<String, Vec<u8>>;

        let v: V = 42i64.into();
        assert_eq!(v, Value::Integer(42));

        let v: V = 7i32.into();
        assert_eq!(v, Value::Integer(7));

        let v: V = 3.5f64.into();
        assert_eq!(v, Value::Real(3.5));

        let v: V = "hello".into();
        assert_eq!(v, Value::Text("hello".into()));

        let v: V = String::from("world").into();
        assert_eq!(v, Value::Text("world".into()));

        let v: V = vec![1u8, 2, 3].into();
        assert_eq!(v, Value::Blob(vec![1, 2, 3]));

        let slice: &[u8] = &[4, 5, 6];
        let v: V = slice.into();
        assert_eq!(v, Value::Blob(vec![4, 5, 6]));

        let v: V = Some(99i64).into();
        assert_eq!(v, Value::Integer(99));

        let v: V = None::<i64>.into();
        assert_eq!(v, Value::Null);
    }
}