agent-workspace-contract 0.1.2

use super::*;

// Product response DTOs. Provider references, credential hashes and provider
// revisions intentionally remain absent even though the durable records above
// retain them for control-plane use.

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceGrantResource {
    pub id: String,
    pub space_id: String,
    pub principal: PrincipalRef,
    pub capabilities: BTreeSet<SpaceCapability>,
    pub path_prefixes: Vec<String>,
    pub expires_at_ms: Option<u64>,
    pub active: bool,
    pub version: u64,
}

impl From<SpaceGrant> for SpaceGrantResource {
    fn from(record: SpaceGrant) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            principal: record.principal,
            capabilities: record.capabilities,
            path_prefixes: record.path_prefixes,
            expires_at_ms: record.expires_at_ms,
            active: record.active,
            version: record.version,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceCollaborationSessionResource {
    pub id: String,
    pub space_id: String,
    pub principal: PrincipalRef,
    pub delegation_id: Option<String>,
    pub requested_mode: SpaceAccessMode,
    pub effective_mode: SpaceAccessMode,
    pub lifecycle: SpaceSessionLifecycle,
    pub last_heartbeat_at_ms: u64,
    pub expires_at_ms: u64,
    pub version: u64,
}

impl From<SpaceCollaborationSession> for SpaceCollaborationSessionResource {
    fn from(record: SpaceCollaborationSession) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            principal: record.principal,
            delegation_id: record.delegation_id,
            requested_mode: record.requested_mode,
            effective_mode: record.effective_mode,
            lifecycle: record.lifecycle,
            last_heartbeat_at_ms: record.last_heartbeat_at_ms,
            expires_at_ms: record.expires_at_ms,
            version: record.version,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceWriteLeaseResource {
    pub id: String,
    pub space_id: String,
    pub session_id: String,
    pub fencing_token: u64,
    pub version: u64,
    pub acquired_at_ms: u64,
    pub expires_at_ms: u64,
    pub active: bool,
}

impl From<SpaceWriteLease> for SpaceWriteLeaseResource {
    fn from(record: SpaceWriteLease) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            session_id: record.session_id,
            fencing_token: record.fencing_token,
            version: record.version,
            acquired_at_ms: record.acquired_at_ms,
            expires_at_ms: record.expires_at_ms,
            active: record.active,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct DelegationResource {
    pub id: String,
    pub grantor_user_id: String,
    pub delegate_agent_id: String,
    pub computer_ids: BTreeSet<String>,
    pub space_ids: BTreeSet<String>,
    pub capabilities: BTreeSet<SpaceCapability>,
    pub path_prefixes: Vec<String>,
    pub purpose: String,
    pub expires_at_ms: u64,
    pub revoked_at_ms: Option<u64>,
}

impl From<DelegationRecord> for DelegationResource {
    fn from(record: DelegationRecord) -> Self {
        Self {
            id: record.id,
            grantor_user_id: record.grantor_user_id,
            delegate_agent_id: record.delegate_agent_id,
            computer_ids: record.computer_ids,
            space_ids: record.space_ids,
            capabilities: record.capabilities,
            path_prefixes: record.path_prefixes,
            purpose: record.purpose,
            expires_at_ms: record.expires_at_ms,
            revoked_at_ms: record.revoked_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ComputerResource {
    pub id: String,
    pub lifecycle: ComputerLifecycle,
    pub capabilities: ProviderCapabilities,
    pub created_by: PrincipalRef,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl From<ComputerRecord> for ComputerResource {
    fn from(record: ComputerRecord) -> Self {
        Self {
            id: record.id,
            lifecycle: record.lifecycle,
            capabilities: record.capabilities,
            created_by: record.created_by,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceResource {
    pub id: String,
    pub persistence: SpacePersistence,
    pub lifecycle: SpaceLifecycle,
    pub capabilities: ProviderCapabilities,
    pub source_snapshot_id: Option<String>,
    pub revision: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl From<SpaceRecord> for SpaceResource {
    fn from(record: SpaceRecord) -> Self {
        Self {
            id: record.id,
            persistence: record.persistence,
            lifecycle: record.lifecycle,
            capabilities: record.capabilities,
            source_snapshot_id: record.source_snapshot_id,
            revision: record.revision,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SandboxResource {
    pub id: String,
    pub placement: SandboxPlacement,
    pub lifecycle: SandboxLifecycle,
    pub owner: PrincipalRef,
    pub capabilities: ProviderCapabilities,
    pub mounts: Vec<SandboxMountRecord>,
    pub expires_at_ms: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl From<SandboxRecord> for SandboxResource {
    fn from(record: SandboxRecord) -> Self {
        Self {
            id: record.id,
            placement: record.placement,
            lifecycle: record.lifecycle,
            owner: record.owner,
            capabilities: record.capabilities,
            mounts: record.mounts,
            expires_at_ms: record.expires_at_ms,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SnapshotResource {
    pub id: String,
    pub source: SnapshotSourceRecord,
    pub created_by: PrincipalRef,
    pub lifecycle: SnapshotLifecycle,
    pub digest: Option<String>,
    pub size_bytes: Option<u64>,
    pub created_at_ms: u64,
}

impl From<SnapshotRecord> for SnapshotResource {
    fn from(record: SnapshotRecord) -> Self {
        Self {
            id: record.id,
            source: record.source,
            created_by: record.created_by,
            lifecycle: record.lifecycle,
            digest: record.digest,
            size_bytes: record.size_bytes,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct TemplateVersionResource {
    pub template_id: String,
    pub version: String,
    pub provider: String,
    pub created_by: PrincipalRef,
    pub target: TemplateTarget,
    pub base_snapshot_id: Option<String>,
    pub resource_profile: BTreeMap<String, String>,
    pub parameter_schema: BTreeMap<String, String>,
    pub state: TemplateVersionState,
    pub created_at_ms: u64,
}

impl From<TemplateVersionRecord> for TemplateVersionResource {
    fn from(record: TemplateVersionRecord) -> Self {
        Self {
            template_id: record.template_id,
            version: record.version,
            provider: record.provider,
            created_by: record.created_by,
            target: record.target,
            base_snapshot_id: record.base_snapshot_id,
            resource_profile: record.resource_profile,
            parameter_schema: record.parameter_schema,
            state: record.state,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceChangeSetResource {
    pub id: String,
    pub source_space_id: String,
    pub target_space_id: String,
    pub base_revision: u64,
    pub created_by_session_id: String,
    pub lifecycle: ChangeSetLifecycle,
    pub created_at_ms: u64,
}

impl From<SpaceChangeSetRecord> for SpaceChangeSetResource {
    fn from(record: SpaceChangeSetRecord) -> Self {
        Self {
            id: record.id,
            source_space_id: record.source_space_id,
            target_space_id: record.target_space_id,
            base_revision: record.base_revision,
            created_by_session_id: record.created_by_session_id,
            lifecycle: record.lifecycle,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceAccessTicketResource {
    pub id: String,
    pub space_id: String,
    pub session_id: String,
    pub mode: SpaceAccessMode,
    pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
    pub fencing_token: Option<u64>,
    pub expires_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct IssuedSpaceAccessTicketResource {
    pub ticket: SpaceAccessTicketResource,
    pub token: String,
}

impl From<IssuedSpaceAccessTicket> for IssuedSpaceAccessTicketResource {
    fn from(issued: IssuedSpaceAccessTicket) -> Self {
        Self {
            ticket: SpaceAccessTicketResource {
                id: issued.ticket.id,
                space_id: issued.ticket.space_id,
                session_id: issued.ticket.session_id,
                mode: issued.ticket.mode,
                capability_paths: issued.ticket.capability_paths,
                fencing_token: issued.ticket.fencing_token,
                expires_at_ms: issued.ticket.expires_at_ms,
            },
            token: issued.token,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceFileContent {
    #[serde(with = "super::base64_bytes")]
    pub bytes: Vec<u8>,
}

impl From<ProviderFileContent> for SpaceFileContent {
    fn from(content: ProviderFileContent) -> Self {
        Self {
            bytes: content.bytes,
        }
    }
}