use std::string::String as StdString;
use std::mem;

#[derive(Copy, Clone)]
#[repr(C)]
pub enum ValueType {
    Nil = 0,
    Int = 1,
    String = 2,
}

#[repr(C)]
pub struct Value {
    tag: ValueType,
    value: ValueVariant,
}

#[repr(C)]
pub union ValueVariant {
    nil: Nil,
    int: i64,
    string: String,
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct Nil {}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct String {
    ptr: *mut u8,
    length: usize,
    capacity: usize,
}

impl From<::Value> for Value {
    fn from(value: ::Value) -> Self {
        match value {
            ::Value::Nil => Value { tag: ValueType::Nil, value: ValueVariant { nil: Nil {} } },
            ::Value::Int(n) => Value { tag: ValueType::Int, value: ValueVariant { int: n } },
            ::Value::String(s) => {
                let length = s.len();
                let capacity = s.capacity();
                let ptr = s.as_ptr() as *mut u8;
                mem::forget(s);

                Value {
                    tag: ValueType::String,
                    value: ValueVariant {
                        string: String {
                            ptr,
                            length,
                            capacity,
                        }
                    }
                }
            },
        }
    }
}

unsafe extern fn rust_butterfly_value_free(value: Value) {
    match value.tag {
        ValueType::Nil => {},
        ValueType::Int => {},
        ValueType::String => {
            let string = value.value.string;
            StdString::from_raw_parts(string.ptr, string.length, string.capacity);
        }
    }
}

// unsafe extern fn rust_butterfly_value_call(name: *const u8, args: *const Value) -> Value {

// }

// pub extern fn rust_butterfly_call()