use std::{fmt::Debug, marker::PhantomData};

use serde::{de::DeserializeOwned, Deserialize, Serialize};
use serde_json::Value;

use crate::{error::GetValueError, object::GiteratedObject, operation::GiteratedOperation};

pub trait GiteratedObjectValue: Send + Sync + Serialize + DeserializeOwned {
    type Object: GiteratedObject;

    fn value_name() -> &'static str;
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetValue {
    pub value_name: String,
}

impl<O: GiteratedObject + Send> GiteratedOperation<O> for GetValue {
    fn operation_name() -> &'static str {
        "get_value"
    }
    type Success = Value;
    type Failure = GetValueError;
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetValueTyped<V: GiteratedObjectValue> {
    pub value_name: String,
    pub ty: PhantomData<V>,
}

impl<O: GiteratedObject + Send, V: GiteratedObjectValue<Object = O>> GiteratedOperation<O>
    for GetValueTyped<V>
{
    fn operation_name() -> &'static str {
        "get_value"
    }
    type Success = V;
    type Failure = GetValueError;
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(transparent)]
pub struct AnyValue<O> {
    value: Value,
    #[serde(skip)]
    _marker: PhantomData<O>,
}

impl<O> AnyValue<O> {
    pub unsafe fn from_raw(value: Value) -> Self {
        Self {
            value,
            _marker: Default::default(),
        }
    }

    pub fn into_inner(self) -> Value {
        self.value
    }
}

impl<O: GiteratedObject> GiteratedObjectValue for AnyValue<O> {
    type Object = O;

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