use geth_types::{ResourceId, ResourceKind, ResourceName};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceDescriptor {
    pub id: ResourceId,
    pub kind: ResourceKind,
    pub name: ResourceName,
    pub authority: ResourceAuthorityRef,
    pub local_role: LocalRole,
    pub replication: ReplicationPolicy,
    pub retention: RetentionPolicy,
    pub status: ResourceStatus,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", content = "value", rename_all = "kebab-case")]
pub enum ResourceAuthorityRef {
    Local,
    Resource(ResourceId),
    External(String),
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum LocalRole {
    Owner,
    Replica,
    Cache,
    Stub,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ReplicationPolicy {
    LocalOnly,
    Manual,
    Mesh,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RetentionPolicy {
    Keep,
    Cache,
    Ephemeral,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ResourceStatus {
    Active,
    Stub,
    Revoked,
}

impl ResourceDescriptor {
    #[must_use]
    pub fn local(id: ResourceId, kind: ResourceKind, name: ResourceName) -> Self {
        Self {
            id,
            kind,
            name,
            authority: ResourceAuthorityRef::Local,
            local_role: LocalRole::Owner,
            replication: ReplicationPolicy::LocalOnly,
            retention: RetentionPolicy::Keep,
            status: ResourceStatus::Active,
        }
    }
}

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

    #[test]
    fn resource_descriptor_serializes() {
        let descriptor = ResourceDescriptor::local(
            ResourceId::new("resource:notes"),
            ResourceKind::Kv,
            ResourceName::new("notes"),
        );
        let json = serde_json::to_string(&descriptor).expect("json");
        let decoded: ResourceDescriptor = serde_json::from_str(&json).expect("decode");
        assert_eq!(decoded, descriptor);
    }
}