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

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

use crate::{
    model::settings::Setting,
    operation::{GiteratedObject, GiteratedObjectValue, GiteratedOperation},
};

pub mod instance;
pub mod repository;
pub mod user;

// #[derive(Serialize, Deserialize)]
// pub struct GetRequest<V: GiteratedObjectValue> {
//     value_name: String,
//     _marker: PhantomData<V>,
// }

// impl<O: GiteratedObject, V: GiteratedObjectValue<Object = O> + Send> GiteratedOperation<O>
//     for GetRequest<V>
// {
//     type Success = V;

//     type Failure = GetValueError;
// }

// #[derive(Error, Debug, Serialize, Deserialize)]
// pub enum GetValueError {}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetSetting<S: Setting + std::fmt::Debug + Clone> {
    pub setting_name: String,
    pub _marker: PhantomData<S>,
}

impl<O: GiteratedObject, S: Setting + Send + DeserializeOwned + Debug + Clone> GiteratedOperation<O>
    for GetSetting<S>
{
    fn operation_name() -> &'static str {
        "get_setting"
    }

    type Success = S;

    type Failure = GetSettingError;
}

#[derive(Error, Debug, Serialize, Deserialize)]
pub enum GetSettingError {}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(bound(deserialize = "S: Setting"))]
pub struct SetSetting<S: Setting> {
    pub setting_name: String,
    pub value: S,
}

impl<O: GiteratedObject, S: Setting + Send> GiteratedOperation<O> for SetSetting<S> {
    fn operation_name() -> &'static str {
        "set_setting"
    }

    type Success = ();

    type Failure = SetSettingError;
}

#[derive(Error, Debug, Serialize, Deserialize)]
pub enum SetSettingError {}

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

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

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

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