models.rs

use crate::consts::SYSTEM_PROMPT_MAX_LEN;
use crate::ApiError;
use serde::{Deserialize, Serialize};
use services::file::ports::FileData;
use services::UserId;
use utoipa::ToSchema;

/// User response DTO
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UserResponse {
    pub id: UserId,
    pub email: String,
    pub name: Option<String>,
    pub avatar_url: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

/// Linked OAuth account response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct LinkedAccountResponse {
    pub provider: String,
    pub linked_at: String,
}

/// User profile response with linked accounts
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UserProfileResponse {
    pub user: UserResponse,
    pub linked_accounts: Vec<LinkedAccountResponse>,
}

/// Response for successful authentication
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct AuthResponse {
    pub token: String,
    pub expires_at: String,
}

impl From<services::user::ports::User> for UserResponse {
    fn from(user: services::user::ports::User) -> Self {
        Self {
            id: user.id,
            email: user.email,
            name: user.name,
            avatar_url: user.avatar_url,
            created_at: user.created_at.to_rfc3339(),
            updated_at: user.updated_at.to_rfc3339(),
        }
    }
}

impl From<services::user::ports::LinkedOAuthAccount> for LinkedAccountResponse {
    fn from(account: services::user::ports::LinkedOAuthAccount) -> Self {
        let provider = match account.provider {
            services::user::ports::OAuthProvider::Google => "google",
            services::user::ports::OAuthProvider::Github => "github",
            services::user::ports::OAuthProvider::Near => "near",
        };
        Self {
            provider: provider.to_string(),
            linked_at: account.linked_at.to_rfc3339(),
        }
    }
}

impl From<services::user::ports::UserProfile> for UserProfileResponse {
    fn from(profile: services::user::ports::UserProfile) -> Self {
        Self {
            user: profile.user.into(),
            linked_accounts: profile
                .linked_accounts
                .into_iter()
                .map(Into::into)
                .collect(),
        }
    }
}

/// Cloud-API gateway attestation (forwarded from dependency)
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ApiGatewayAttestation {
    /// Intel TDX quote in hex format
    pub intel_quote: String,
    /// Event log
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_log: Option<serde_json::Value>,
    /// Request nonce
    pub request_nonce: String,
    /// Attestation info
    #[serde(skip_serializing_if = "Option::is_none")]
    pub info: Option<serde_json::Value>,
}

/// Model attestation from VLLM inference providers
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ModelAttestation {
    /// Cryptographic signing address (ECDSA or Ed25519)
    pub signing_address: String,

    /// Base64-encoded Intel TDX quote from model host
    pub intel_quote: String,

    /// JSON string containing NVIDIA GPU attestation
    pub nvidia_payload: String,

    /// TDX event log
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_log: Option<serde_json::Value>,

    /// Additional TDX/tappd info
    #[serde(skip_serializing_if = "Option::is_none")]
    pub info: Option<serde_json::Value>,
}

/// Complete attestation report combining all layers
///
/// This report proves the entire trust chain:
/// 1. This chat-api service runs in a TEE (your_gateway_attestation)
/// 2. The cloud-api dependency runs in a TEE (cloud_api_gateway_attestation)  
/// 3. The model inference providers run on trusted hardware (model_attestations)
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct CombinedAttestationReport {
    /// This chat-api's own CPU attestation (proves this service runs in a TEE)
    pub chat_api_gateway_attestation: ApiGatewayAttestation,

    /// Cloud-API's gateway attestation (the intermediate service we depend on)
    pub cloud_api_gateway_attestation: ApiGatewayAttestation,

    /// Model provider attestations (can be multiple when routing to different models)
    pub model_attestations: Option<Vec<ModelAttestation>>,
}

/// Attestation report structure from proxy_service
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AttestationReport {
    pub gateway_attestation: ApiGatewayAttestation,
    pub model_attestations: Option<Vec<ModelAttestation>>,
}

/// Appearance preference
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub enum Appearance {
    Light,
    Dark,
    System,
}

impl From<services::user::ports::Appearance> for Appearance {
    fn from(appearance: services::user::ports::Appearance) -> Self {
        match appearance {
            services::user::ports::Appearance::Light => Appearance::Light,
            services::user::ports::Appearance::Dark => Appearance::Dark,
            services::user::ports::Appearance::System => Appearance::System,
        }
    }
}

impl From<Appearance> for services::user::ports::Appearance {
    fn from(appearance: Appearance) -> Self {
        match appearance {
            Appearance::Light => services::user::ports::Appearance::Light,
            Appearance::Dark => services::user::ports::Appearance::Dark,
            Appearance::System => services::user::ports::Appearance::System,
        }
    }
}

/// User settings content for API responses
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UserSettingsContent {
    /// Notification preference
    pub notification: bool,
    /// System prompt
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_prompt: Option<String>,
    /// Web search preference
    pub web_search: bool,
    /// Appearance preference
    pub appearance: Appearance,
}

impl From<services::user::ports::UserSettingsContent> for UserSettingsContent {
    fn from(content: services::user::ports::UserSettingsContent) -> Self {
        Self {
            notification: content.notification,
            system_prompt: content.system_prompt,
            web_search: content.web_search,
            appearance: content.appearance.into(),
        }
    }
}

/// User settings update request
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpdateUserSettingsRequest {
    /// Notification preference
    pub notification: bool,
    /// System prompt
    pub system_prompt: Option<String>,
    /// Web search preference
    pub web_search: bool,
    /// Appearance preference
    pub appearance: Appearance,
}

impl UpdateUserSettingsRequest {
    pub fn validate(&self) -> Result<(), ApiError> {
        if let Some(ref system_prompt) = self.system_prompt {
            if system_prompt.len() > SYSTEM_PROMPT_MAX_LEN {
                return Err(ApiError::bad_request("System prompt exceeds max length"));
            }
        }

        Ok(())
    }
}

/// User settings update request (partial update)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpdateUserSettingsPartiallyRequest {
    /// Notification preference
    pub notification: Option<bool>,
    /// System prompt
    pub system_prompt: Option<String>,
    /// Web search preference
    pub web_search: Option<bool>,
    /// Appearance preference
    pub appearance: Option<Appearance>,
}

impl UpdateUserSettingsPartiallyRequest {
    pub fn validate(&self) -> Result<(), ApiError> {
        if let Some(ref system_prompt) = self.system_prompt {
            if system_prompt.len() > SYSTEM_PROMPT_MAX_LEN {
                return Err(ApiError::bad_request("System prompt exceeds max length"));
            }
        }

        Ok(())
    }
}

/// User settings response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UserSettingsResponse {
    /// User ID
    pub user_id: UserId,
    /// Settings content (serialized as "settings")
    #[serde(rename = "settings")]
    pub content: UserSettingsContent,
}

/// Model settings content for API responses
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct ModelSettings {
    /// Whether models are public (visible/usable in responses)
    pub public: bool,
    /// Optional system-level system prompt for this model
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_prompt: Option<String>,
}

impl From<services::model::ports::ModelSettings> for ModelSettings {
    fn from(content: services::model::ports::ModelSettings) -> Self {
        Self {
            public: content.public,
            system_prompt: content.system_prompt,
        }
    }
}

impl From<ModelSettings> for services::model::ports::ModelSettings {
    fn from(content: ModelSettings) -> Self {
        Self {
            public: content.public,
            system_prompt: content.system_prompt,
        }
    }
}

/// Partial model settings for API requests
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct PartialModelSettings {
    /// Whether models are public (visible/usable in responses)
    pub public: Option<bool>,
    /// Optional system-level system prompt for this model
    pub system_prompt: Option<String>,
}

impl From<services::model::ports::PartialModelSettings> for PartialModelSettings {
    fn from(content: services::model::ports::PartialModelSettings) -> Self {
        Self {
            public: content.public,
            system_prompt: content.system_prompt,
        }
    }
}

impl From<PartialModelSettings> for services::model::ports::PartialModelSettings {
    fn from(content: PartialModelSettings) -> Self {
        Self {
            public: content.public,
            system_prompt: content.system_prompt,
        }
    }
}

/// Complete model response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct ModelResponse {
    /// External model identifier (e.g. "gpt-4.1")
    pub model_id: String,
    /// Settings stored for this model
    pub settings: ModelSettings,
}

impl From<services::model::ports::Model> for ModelResponse {
    fn from(model: services::model::ports::Model) -> Self {
        Self {
            model_id: model.model_id,
            settings: model.settings.into(),
        }
    }
}

/// Model upsert request
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpsertModelsRequest {
    pub settings: ModelSettings,
}

/// Model settings update request (partial update)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpdateModelRequest {
    pub settings: Option<PartialModelSettings>,
}

/// Batch model upsert request
///
/// Maps model_id to partial settings to update.
/// Example: { "gpt-4": { "public": true }, "gpt-3.5": { "public": false, "system_prompt": "..." } }
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct BatchUpsertModelsRequest {
    #[serde(flatten)]
    pub models: std::collections::HashMap<String, PartialModelSettings>,
}

/// Model list response with pagination
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct ModelListResponse {
    /// List of models
    pub models: Vec<ModelResponse>,
    /// Maximum number of items returned
    pub limit: i64,
    /// Number of items skipped
    pub offset: i64,
    /// Total number of models
    pub total: i64,
}

/// Paginated user list response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UserListResponse {
    /// List of users
    pub users: Vec<UserResponse>,
    /// Maximum number of items returned
    pub limit: i64,
    /// Number of items skipped
    pub offset: i64,
    /// Total number of users
    pub total: u64,
}

/// System configs response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct SystemConfigsResponse {
    /// Default model identifier to use when not specified
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_model: Option<String>,
}

impl From<services::system_configs::ports::SystemConfigs> for SystemConfigsResponse {
    fn from(config: services::system_configs::ports::SystemConfigs) -> Self {
        Self {
            default_model: config.default_model,
        }
    }
}

/// System configs upsert request (full replace)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpsertSystemConfigsRequest {
    /// Default model identifier to use when not specified
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_model: Option<String>,
}

impl From<UpsertSystemConfigsRequest> for services::system_configs::ports::SystemConfigs {
    fn from(req: UpsertSystemConfigsRequest) -> Self {
        services::system_configs::ports::SystemConfigs {
            default_model: req.default_model,
        }
    }
}

/// System configs update request (partial)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct UpdateSystemConfigsRequest {
    /// Default model identifier to use when not specified
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_model: Option<String>,
}

impl From<UpdateSystemConfigsRequest> for services::system_configs::ports::PartialSystemConfigs {
    fn from(req: UpdateSystemConfigsRequest) -> Self {
        services::system_configs::ports::PartialSystemConfigs {
            default_model: req.default_model,
        }
    }
}

/// File list response with pagination
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct FileListResponse {
    /// Always "list"
    pub object: String,
    /// List of files (without `object` field per item)
    pub data: Vec<FileGetResponse>,
    /// First file ID in the list
    #[serde(skip_serializing_if = "Option::is_none")]
    pub first_id: Option<String>,
    /// Last file ID in the list
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_id: Option<String>,
    /// Whether there are more files available
    pub has_more: bool,
}

/// File get response with `object` field
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct FileGetResponse {
    /// Always "file"
    pub object: String,
    #[serde(flatten)]
    pub file: FileData,
}

impl From<FileData> for FileGetResponse {
    fn from(file: FileData) -> Self {
        Self {
            object: "file".to_string(),
            file,
        }
    }
}