aurabase 0.1.1

use crate::error::AuraError;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// ---- Generic response wrapper ---------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Meta {
    pub total: Option<u64>,
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuraResponse<T> {
    pub data: Option<T>,
    pub error: Option<AuraError>,
    pub meta: Option<Meta>,
}

// ---- Auth -----------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct User {
    pub id: String,
    pub email: Option<String>,
    pub phone: Option<String>,
    pub role: String,
    pub email_verified: bool,
    pub is_banned: bool,
    pub is_anonymous: bool,
    pub mfa_enabled: bool,
    pub avatar_url: Option<String>,
    pub user_metadata: HashMap<String, serde_json::Value>,
    pub app_metadata: HashMap<String, serde_json::Value>,
    pub created_at: String,
    pub last_sign_in_at: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TokenPair {
    pub access_token: String,
    pub refresh_token: String,
    pub token_type: String,
    pub expires_in: u64,
    pub user: User,
    pub provider_token: Option<String>,
    pub provider_refresh_token: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MfaChallenge {
    pub mfa_required: bool,
    pub mfa_token: String,
    pub mfa_setup_required: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum LoginResponse {
    TokenPair(Box<TokenPair>),
    MfaChallenge(MfaChallenge),
}

impl LoginResponse {
    pub fn is_mfa_challenge(&self) -> bool {
        match self {
            LoginResponse::MfaChallenge(_) => true,
            LoginResponse::TokenPair(_) => false,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum AuthEvent {
    #[serde(rename = "SIGNED_IN")]
    SignedIn,
    #[serde(rename = "SIGNED_OUT")]
    SignedOut,
    #[serde(rename = "TOKEN_REFRESHED")]
    TokenRefreshed,
    #[serde(rename = "MFA_CHALLENGE")]
    MfaChallenge,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthChangePayload {
    pub event: AuthEvent,
    pub user: Option<User>,
    pub access_token: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SignUpRequest {
    pub email: String,
    pub password: String,
    pub captcha_token: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SignInRequest {
    pub email: String,
    pub password: String,
    pub captcha_token: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MagicLinkRequest {
    pub email: String,
    pub redirect_url: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct OAuthSignInOptions {
    pub redirect_to: Option<String>,
    pub scopes: Option<String>,
    pub query_params: Option<HashMap<String, String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PasswordResetRequest {
    pub email: String,
    pub redirect_to: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct UpdateUserRequest {
    pub email: Option<String>,
    pub phone: Option<String>,
    pub password: Option<String>,
    pub current_password: Option<String>,
    pub data: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MfaEnrollResponse {
    pub otpauth_url: String,
    pub secret: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MfaVerifyRequest {
    pub mfa_token: String,
    pub code: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionInfo {
    pub id: String,
    pub device_info: Option<String>,
    pub ip_address: Option<String>,
    pub created_at: String,
    pub expires_at: String,
    pub last_used_at: String,
    pub is_current: bool,
}

// ---- Database / Query -----------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaColumn {
    pub name: String,
    pub data_type: String,
    pub is_nullable: bool,
    pub default_value: Option<String>,
    pub is_primary_key: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaTable {
    pub name: String,
    pub columns: Vec<SchemaColumn>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CountMode {
    Exact,
    Estimated,
}

// ---- Storage --------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageBucket {
    pub id: String,
    pub name: String,
    pub public: bool,
    pub file_size_limit: Option<u64>,
    pub allowed_mime_types: Option<Vec<String>>,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UploadResult {
    pub key: String,
    pub url: String,
    pub size: u64,
    #[serde(alias = "content_type")]
    pub mime_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileEntry {
    #[serde(alias = "key")]
    pub name: String,
    pub id: Option<String>,
    #[serde(alias = "bucket", default)]
    pub bucket_id: String,
    pub size: u64,
    #[serde(alias = "content_type")]
    pub mime_type: String,
    #[serde(alias = "last_modified", default)]
    pub created_at: String,
    #[serde(default)]
    pub updated_at: String,
    pub metadata: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectMeta {
    pub key: String,
    pub bucket: String,
    pub size: u64,
    pub content_type: String,
    pub etag: Option<String>,
    pub last_modified: Option<String>,
    pub metadata: HashMap<String, String>,
}

// ---- Realtime -------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum ServerMessage {
    Subscribed(ServerSubscribedMsg),
    Event(ServerEventMsg),
    Pong,
    Error(ServerErrorMsg),
    TokenRefreshed,
    PresenceState(ServerPresenceStateMsg),
    BroadcastAck(BroadcastAckMessage),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerSubscribedMsg {
    pub channel: String,
    pub subscription_id: Option<String>,
    pub history: Vec<RealtimeEvent>,
    pub ref_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerEventMsg {
    pub id: String,
    pub event: String, // 'insert', 'update', 'delete', 'broadcast', 'presence', 'system'
    pub topic: String,
    pub payload: serde_json::Value,
    pub timestamp: String,
    pub allowed_sub_ids: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerErrorMsg {
    pub message: String,
    /// Canal concerné par l'erreur, tel qu'émis par le serveur (`<project_id>:<nom>`).
    ///
    /// N29 — le serveur distingue depuis B9/N23 une erreur PROPRE À UN CANAL (refus RLS,
    /// write policy, nom de canal invalide…) d'une erreur GLOBALE de connexion (heartbeat,
    /// token expiré, quota de violations) : il ne sérialise le champ que dans le premier cas
    /// (`skip_serializing_if = "Option::is_none"`,
    /// `services/aura-realtime/src/handlers/websocket.rs`). Le SDK ne le déclarait pas et le
    /// perdait donc silencieusement.
    ///
    /// `serde(default)` est indispensable : sans lui, le décodage d'une erreur GLOBALE — qui
    /// n'a pas ce champ — échouerait, et le SDK cesserait de voir les déconnexions.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub channel: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerPresenceStateMsg {
    pub channel: String,
    pub presences: Vec<PresenceInfo>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BroadcastAckMessage {
    pub message_id: String,
    pub ref_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RealtimeEvent {
    pub id: String,
    pub event: String,
    pub topic: String,
    pub payload: serde_json::Value,
    pub timestamp: String,
    pub allowed_sub_ids: Option<Vec<String>>,
    pub ref_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CdcPayload {
    pub schema: String,
    pub table: String,
    #[serde(rename = "type")]
    pub op_type: String, // 'INSERT', 'UPDATE', 'DELETE'
    pub record: HashMap<String, serde_json::Value>,
    pub old_record: Option<HashMap<String, serde_json::Value>>,
    pub _truncated: Option<bool>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
pub enum RealtimeSubscribeStatus {
    Subscribed,
    Closed,
    ChannelError,
    TimedOut,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PostgresChangesFilter {
    pub event: String, // 'INSERT', 'UPDATE', 'DELETE', '*'
    pub schema: Option<String>,
    pub table: Option<String>,
    pub filter: Option<String>,
}

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

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresenceFilter {
    pub event: String, // 'sync', 'join', 'leave'
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ChannelConfig {
    #[serde(default)]
    pub private: bool,
    pub broadcast: Option<BroadcastConfig>,
    pub config: Option<PresenceConfigWrapper>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct BroadcastConfig {
    pub ack: Option<bool>,
    pub self_broadcast: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PresenceConfigWrapper {
    pub presence: Option<PresenceKeyConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PresenceKeyConfig {
    pub key: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BroadcastPayload {
    #[serde(rename = "type")]
    pub msg_type: String, // 'broadcast'
    pub event: String,
    pub payload: serde_json::Value,
    pub ref_id: Option<String>,
}

pub type PresenceState = HashMap<String, Vec<PresenceInfo>>;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresenceInfo {
    pub client_id: String,
    pub user_id: Option<String>,
    pub metadata: HashMap<String, serde_json::Value>,
    pub joined_at: String,
    pub last_seen: String,
}

// ---- AI -------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
    pub role: String, // 'system', 'user', 'assistant'
    pub content: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatResponse {
    pub model: String,
    pub content: String,
    pub input_tokens: Option<u64>,
    pub output_tokens: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbedRequest {
    pub text: String,
    pub namespace: String,
    pub metadata: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbedResponse {
    pub id: String,
    pub dimensions: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RagRequest {
    pub question: String,
    pub namespace: String,
    pub history: Option<Vec<ChatMessage>>,
    pub system: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RagResponse {
    pub answer: String,
    pub sources: Vec<RagSource>,
    pub model: String,
    pub tokens: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RagSource {
    pub id: String,
    pub content: String,
    pub metadata: HashMap<String, serde_json::Value>,
    pub similarity: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RagIngestRequest {
    pub namespace: String,
    pub content: String,
    pub metadata: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RagIngestResponse {
    pub id: String,
    pub chunks: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SemanticSearchResult {
    pub id: String,
    pub content: String,
    pub metadata: HashMap<String, serde_json::Value>,
    pub similarity: f64,
}

// ---- Functions ------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionDef {
    pub id: String,
    pub project_id: String,
    pub name: String,
    pub runtime: String,
    pub code: String,
    pub code_hash: String,
    pub env_vars: HashMap<String, serde_json::Value>,
    pub is_active: bool,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Job {
    pub id: String,
    pub project_id: String,
    pub function_name: String,
    pub status: String, // 'pending', 'running', 'completed', 'failed', 'dead'
    pub payload: serde_json::Value,
    pub attempts: u32,
    pub max_attempts: u32,
    pub error: Option<String>,
    pub scheduled_at: String,
    pub started_at: Option<String>,
    pub created_at: String,
    pub completed_at: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CronJob {
    pub id: String,
    pub project_id: String,
    pub name: String,
    pub schedule: String,
    pub function_name: String,
    pub payload: serde_json::Value,
    pub is_active: bool,
    pub last_run: Option<String>,
    pub next_run: Option<String>,
    pub created_at: String,
}

// ---- Notifications --------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Notification {
    pub id: String,
    pub project_id: String,
    pub channel: String, // 'email', 'sms', 'push', 'webhook'
    pub recipient: String,
    pub subject: Option<String>,
    pub body: String,
    pub status: String, // 'queued', 'processing', 'sent', 'failed', 'delivered', 'expired', 'dead_lettered'
    pub error: Option<String>,
    pub metadata: serde_json::Value,
    pub attempt_count: Option<i32>,
    pub last_attempt_at: Option<String>,
    pub next_attempt_at: Option<String>,
    pub locked_until: Option<String>,
    pub lock_owner: Option<String>,
    pub provider_message_id: Option<String>,
    pub delivered_at: Option<String>,
    pub expires_at: Option<String>,
    pub idempotency_key: Option<String>,
    pub payload_hash: Option<String>,
    pub last_error: Option<String>,
    pub last_error_code: Option<String>,
    pub last_provider_response: Option<String>,
    pub processing_started_at: Option<String>,
    pub completed_at: Option<String>,
    pub updated_at: Option<String>,
    pub sent_at: Option<String>,
    pub created_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationTemplate {
    pub id: String,
    pub project_id: String,
    pub name: String,
    pub channel: String,
    pub subject: Option<String>,
    pub body: String,
    #[serde(default)]
    pub variables: Vec<String>,
    pub created_at: String,
    pub updated_at: String,
}

// ---- Phase 2 additions ----------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentityInfo {
    pub id: String,
    pub provider: String,
    pub provider_id: String,
    pub identity_data: HashMap<String, serde_json::Value>,
    pub auto_linked: bool,
    pub created_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdminUser {
    #[serde(flatten)]
    pub user: User,
    pub is_active: bool,
    pub password_hash: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuditLogEntry {
    pub id: String,
    pub user_id: Option<String>,
    pub action: String,
    pub ip_address: Option<String>,
    pub user_agent: Option<String>,
    pub created_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthSettings {
    pub allow_signup: bool,
    pub email_confirmation_required: bool,
    pub password_min_length: u32,
    pub mfa_enabled: bool,
    pub allow_anonymous_users: bool,
    pub jwt_expiry_seconds: u32,
    pub refresh_token_expiry_days: u32,
    pub site_url: Option<String>,
    pub oauth_providers: HashMap<String, OAuthProviderConfig>,
    pub new_device_alerts_enabled: bool,
    pub webhook_url: Option<String>,
    pub smtp_host: Option<String>,
    pub smtp_port: Option<u16>,
    pub smtp_username: Option<String>,
    pub smtp_password_set: Option<bool>,
    pub smtp_from_email: Option<String>,
    pub smtp_from_name: Option<String>,
    pub oauth_credentials: HashMap<String, HashMap<String, String>>,
    pub captcha_enabled: bool,
    pub captcha_provider: Option<String>,
    pub captcha_site_key: Option<String>,
    pub captcha_secret_key_set: Option<bool>,
    pub password_check_hibp: bool,
    pub sms_provider: Option<String>,
    pub sms_api_key_set: Option<bool>,
    pub sms_from_number: Option<String>,
    pub redirect_urls: Vec<String>,
    pub session_inactivity_timeout_seconds: u32,
    pub hook_send_sms_url: Option<String>,
    pub hook_send_email_url: Option<String>,
    pub hook_mfa_verification_url: Option<String>,
    pub hook_password_verification_url: Option<String>,
    pub auto_link_by_email: bool,
    pub revoke_on_new_device: bool,
    pub enforce_ip_binding: bool,
    pub allowed_email_domains: Vec<String>,
    pub blocked_email_domains: Vec<String>,
    pub updated_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OAuthProviderConfig {
    pub enabled: Option<bool>,
    pub client_id: Option<String>,
    pub client_secret: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmailTemplateUpdate {
    pub subject: Option<String>,
    pub body: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdminCreateUserRequest {
    pub email: String,
    pub password: Option<String>,
    pub role: Option<String>,
    pub email_verified: Option<bool>,
    pub user_metadata: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AdminUpdateUserRequest {
    pub password: Option<String>,
    pub role: Option<String>,
    pub is_active: Option<bool>,
    pub is_banned: Option<bool>,
    pub email_verified: Option<bool>,
    pub user_metadata: Option<HashMap<String, serde_json::Value>>,
    pub app_metadata: Option<HashMap<String, serde_json::Value>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaginatedResponse<T> {
    pub data: Vec<T>,
    pub total: u64,
    pub page: u64,
    pub per_page: u64,
}

// ---- Vérification OTP unifiée ----------------------------------------------

/// Flux de vérification acceptés par [`crate::services::auth::AuthService::verify_otp`].
///
/// Un ENUM plutôt qu'une chaîne `type` : le périmètre est le même que celui des façades
/// `verifyOtp` de JavaScript, Dart et Python — SIX flux, un par endpoint réellement servi par
/// `aura-auth` (`services/aura-auth/src/main.rs`) — mais un type hors contrat ne peut pas
/// franchir la compilation, là où les trois autres SDK doivent le rejeter à l'exécution
/// (`otp_type_unsupported`).
///
/// **F4 — `MagicLink` et `Recovery` ont été AJOUTÉS.** Ce SDK savait ENVOYER les deux liens
/// (`sign_in_with_magic_link`, `reset_password_for_email`) sans offrir aucun moyen de CONSOMMER
/// le jeton qui revient : deux parcours utilisateur qui commençaient sans pouvoir finir. Les
/// endpoints existaient des deux côtés ; seule la façade manquait.
///
/// `invite` et `phone_change` n'existent dans AUCUN SDK : `aura-auth` ne déclare aucun endpoint
/// pour les vérifier. Ils ne sont pas « à faire », ils n'ont pas lieu d'être.
///
/// `token` porte partout la valeur saisie par l'utilisateur ou reçue par courriel — c'est le
/// nom qu'emploient les trois autres SDK, même quand le corps envoyé au backend l'appelle
/// `code` (`/email-otp/verify`, `/sms/verify`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VerifyOtpParams<'a> {
    /// Confirmation d'inscription par lien courriel — `POST /v1/auth/verify-email`.
    Signup { token: &'a str },
    /// Consommation d'un lien magique — `POST /v1/auth/magic-link/verify`.
    MagicLink { token: &'a str },
    /// Code à usage unique envoyé par courriel — `POST /v1/auth/email-otp/verify`.
    Email { email: &'a str, token: &'a str },
    /// Code à usage unique envoyé par SMS — `POST /v1/auth/sms/verify`.
    Sms { phone: &'a str, token: &'a str },
    /// Consommation d'un lien de récupération — `POST /v1/auth/reset-password`.
    ///
    /// `password` est OBLIGATOIRE, et le typage l'impose : le backend fusionne consommation du
    /// jeton et changement de mot de passe en un seul appel (divergence assumée avec
    /// `@supabase/auth-js`, qui ouvre d'abord une session). Les SDK dynamiques doivent rendre
    /// `missing_param` à l'exécution ; ici le cas est inatteignable.
    Recovery { token: &'a str, password: &'a str },
    /// Confirmation d'un changement d'adresse — `POST /v1/auth/user/confirm-email-change`.
    /// Seul flux qui ne délivre PAS de jetons : il renvoie l'utilisateur mis à jour.
    EmailChange { token: &'a str },
}