use std::mem::transmute;

use giterated_models::{object::GiteratedObject, operation::GiteratedOperation};

use crate::FFIBox;

use super::AnyObject;

#[derive(Clone, Copy)]
#[repr(C)]
pub struct OperationVTable {
    operation_kind: *const u8,
    operation_kind_len: usize,
    pub serialize: unsafe extern "C" fn(&AnyOperation) -> Result<FFIBox<[u8]>, ()>,
    pub deserialize: unsafe extern "C" fn(&[u8]) -> Result<AnyOperation, ()>,
    pub is_same: unsafe extern "C" fn(AnyObject) -> bool,
    pub serialize_success: unsafe extern "C" fn(()) -> Result<FFIBox<[u8]>, ()>,
    pub serialize_failure: unsafe extern "C" fn(()) -> Result<FFIBox<[u8]>, ()>,
    pub deserialize_success: unsafe extern "C" fn(&[u8]) -> Result<AnySuccess, ()>,
    pub deserialize_failure: unsafe extern "C" fn(&[u8]) -> Result<AnyFailure, ()>,
}

impl OperationVTable {
    pub fn new<O, T: IntoOperationVTable<O>>() -> Self {
        let operation_kind = T::operation_kind().as_ptr();
        let operation_kind_len = T::operation_kind().len();

        Self {
            serialize: T::serialize,
            deserialize: T::deserialize,
            is_same: T::is_same,
            serialize_success: T::serialize_success,
            serialize_failure: T::serialize_failure,
            deserialize_success: T::deserialize_success,
            deserialize_failure: T::deserialize_failure,
            operation_kind,
            operation_kind_len,
        }
    }

    pub fn kind(&self) -> &'static str {
        let slice =
            unsafe { std::slice::from_raw_parts(self.operation_kind, self.operation_kind_len) };

        std::str::from_utf8(slice).unwrap()
    }
}

pub struct AnyOperation {
    /// A pointer to the plugin-local object type. We are not capable of
    /// knowing what this type is, we use the provided vtable.
    inner: FFIBox<()>,
    vtable: OperationVTable,
}

impl AnyOperation {
    pub unsafe fn transmute_owned<T>(&mut self) -> Box<T> {
        Box::from_raw(self.inner.0 as *mut T)
    }

    pub unsafe fn transmute_ref<T>(&self) -> &T {
        let ptr: *const T = transmute(self.inner.0);

        ptr.as_ref().unwrap()
    }

    pub fn vtable(&self) -> OperationVTable {
        self.vtable
    }
}

#[repr(C)]
pub struct AnySuccess {
    inner: FFIBox<()>,
    vtable: OperationVTable,
}

#[repr(C)]
pub struct AnyFailure {
    inner: FFIBox<()>,
    vtable: OperationVTable,
}

pub trait IntoOperationVTable<O> {
    fn operation_kind() -> &'static str;
    unsafe extern "C" fn serialize(this: &AnyOperation) -> Result<FFIBox<[u8]>, ()>;
    unsafe extern "C" fn deserialize(src: &[u8]) -> Result<AnyOperation, ()>;
    unsafe extern "C" fn is_same(this: AnyObject) -> bool;
    unsafe extern "C" fn serialize_success(success: ()) -> Result<FFIBox<[u8]>, ()>;
    unsafe extern "C" fn serialize_failure(failure: ()) -> Result<FFIBox<[u8]>, ()>;
    unsafe extern "C" fn deserialize_success(src: &[u8]) -> Result<AnySuccess, ()>;
    unsafe extern "C" fn deserialize_failure(src: &[u8]) -> Result<AnyFailure, ()>;
}

impl<O, D> IntoOperationVTable<O> for D
where
    D: GiteratedOperation<O>,
    O: GiteratedObject,
{
    unsafe extern "C" fn serialize(this: &AnyOperation) -> Result<FFIBox<[u8]>, ()> {
        todo!()
    }

    unsafe extern "C" fn deserialize(src: &[u8]) -> Result<AnyOperation, ()> {
        let deserialized: D = serde_json::from_slice(src).unwrap();

        Ok(AnyOperation {
            inner: FFIBox::from_box(Box::new(deserialized)).untyped(),
            vtable: OperationVTable::new::<O, D>(),
        })
    }

    unsafe extern "C" fn is_same(this: AnyObject) -> bool {
        todo!()
    }

    unsafe extern "C" fn serialize_success(success: ()) -> Result<FFIBox<[u8]>, ()> {
        todo!()
    }

    unsafe extern "C" fn serialize_failure(failure: ()) -> Result<FFIBox<[u8]>, ()> {
        todo!()
    }

    unsafe extern "C" fn deserialize_success(src: &[u8]) -> Result<AnySuccess, ()> {
        todo!()
    }

    unsafe extern "C" fn deserialize_failure(src: &[u8]) -> Result<AnyFailure, ()> {
        todo!()
    }

    fn operation_kind() -> &'static str {
        todo!()
    }
}