use admin::services::logs::JobLogDto;
use admin::services::queues::QueueSnapshotDto;
use admin::services::system::{
    AdminEndpointDto, CountsDto, DashboardDto, DatabaseConfigDto, DependenciesDto, DependencyDto,
    EmailConfigDto, FeaturesDto, GitConfigDto, HostEntryDto, ImportConfigDto, ProcessInfoDto,
    RedisConfigDto, SearchConfigDto, SessionConfigDto, StorageConfigDto, SystemConfigDto,
    SystemStatusDto, TrendPointDto,
};

use crate::convert::ts;
use crate::proto as pb;

pub fn status(value: SystemStatusDto) -> pb::SystemStatus {
    pb::SystemStatus {
        process: Some(process(value.process)),
        dependencies: Some(dependencies(value.dependencies)),
        features: Some(features(value.features)),
        counts: Some(counts(value.counts)),
        queues: value.queues.into_iter().map(queue_snapshot).collect(),
        recent_failures: value.recent_failures.into_iter().map(job_log).collect(),
        generated_at: ts(value.generated_at),
    }
}

pub fn config(value: SystemConfigDto) -> pb::SystemConfig {
    pb::SystemConfig {
        version: value.version,
        hosts: value.hosts.into_iter().map(host_entry).collect(),
        admin: Some(admin_endpoint(value.admin)),
        features: Some(features(value.features)),
        search: Some(search_config(value.search)),
        import: Some(import_config(value.import)),
        git: Some(git_config(value.git)),
        storage: Some(storage_config(value.storage)),
        database: Some(database_config(value.database)),
        redis: Some(redis_config(value.redis)),
        session: Some(session_config(value.session)),
        email: Some(email_config(value.email)),
        generated_at: ts(value.generated_at),
    }
}

pub fn dashboard(value: DashboardDto) -> pb::Dashboard {
    pb::Dashboard {
        counts: Some(counts(value.counts)),
        trend: value.trend.into_iter().map(trend_point).collect(),
        active_sessions: value.active_sessions,
        restricted_users: value.restricted_users,
        recent_failures: value.recent_failures.into_iter().map(job_log).collect(),
        queues: value.queues.into_iter().map(queue_snapshot).collect(),
        generated_at: ts(value.generated_at),
    }
}

pub fn process(value: ProcessInfoDto) -> pb::ProcessInfo {
    pb::ProcessInfo {
        version: value.version,
        uptime_secs: value.uptime_secs,
    }
}

pub fn dependency(value: DependencyDto) -> pb::Dependency {
    pb::Dependency {
        ok: value.ok,
        latency_ms: value.latency_ms,
        detail: value.detail,
    }
}

pub fn dependencies(value: DependenciesDto) -> pb::Dependencies {
    pb::Dependencies {
        database: Some(dependency(value.database)),
        redis: Some(dependency(value.redis)),
        storage: Some(dependency(value.storage)),
        search: Some(dependency(value.search)),
    }
}

pub fn features(value: FeaturesDto) -> pb::Features {
    pb::Features {
        search_enabled: value.search_enabled,
        import_enabled: value.import_enabled,
        email_enabled: value.email_enabled,
        email_queue_enabled: value.email_queue_enabled,
    }
}

pub fn counts(value: CountsDto) -> pb::Counts {
    pb::Counts {
        users: value.users,
        active_users: value.active_users,
        spaces: value.spaces,
        active_spaces: value.active_spaces,
        repos: value.repos,
        rooms: value.rooms,
        issues: value.issues,
        messages: value.messages,
    }
}

pub fn queue_snapshot(value: QueueSnapshotDto) -> pb::QueueSnapshot {
    pb::QueueSnapshot {
        name: value.name,
        kind: value.kind,
        enabled: value.enabled,
        depth: value.depth,
        queued: value.queued,
        running: value.running,
        failed: value.failed,
        succeeded: value.succeeded,
        note: value.note,
    }
}

pub fn job_log(value: JobLogDto) -> pb::JobLog {
    pb::JobLog {
        source: value.source,
        id: value.id.to_string(),
        state: value.state,
        error: value.error,
        created_at: ts(value.created_at),
        updated_at: value.updated_at.map(ts),
    }
}

pub fn trend_point(value: TrendPointDto) -> pb::TrendPoint {
    pb::TrendPoint {
        date: value.date,
        users: value.users,
        spaces: value.spaces,
        repos: value.repos,
    }
}

pub fn host_entry(value: HostEntryDto) -> pb::HostEntry {
    pb::HostEntry {
        name: value.name,
        enabled: value.enabled,
        bind_addr: value.bind_addr,
        port: value.port.map(u32::from),
    }
}

pub fn admin_endpoint(value: AdminEndpointDto) -> pb::AdminEndpoint {
    pb::AdminEndpoint {
        enabled: value.enabled,
        bind_addr: value.bind_addr,
        port: u32::from(value.port),
        cors_allow_origins: value.cors_allow_origins,
        cors_allow_credentials: value.cors_allow_credentials,
    }
}

pub fn search_config(value: SearchConfigDto) -> pb::SearchConfig {
    pb::SearchConfig {
        enabled: value.enabled,
        index_prefix: value.index_prefix,
        max_file_bytes: value.max_file_bytes as u64,
        batch_size: value.batch_size as u64,
        poll_interval_secs: value.poll_interval_secs,
    }
}

pub fn import_config(value: ImportConfigDto) -> pb::ImportConfig {
    pb::ImportConfig {
        enabled: value.enabled,
        allowed_hosts: value.allowed_hosts,
        allow_insecure_tls: value.allow_insecure_tls,
        max_concurrent_jobs: value.max_concurrent_jobs as u64,
        max_repo_bytes: value.max_repo_bytes,
        max_attempts: value.max_attempts,
    }
}

pub fn git_config(value: GitConfigDto) -> pb::GitConfig {
    pb::GitConfig {
        repo_root: value.repo_root,
        objects_root: value.objects_root,
        max_blob_size: value.max_blob_size,
        sync_topic: value.sync_topic,
        sync_concurrency: value.sync_concurrency as u64,
        base_url: value.base_url,
        graphql_complexity_limit: value.graphql_complexity_limit,
        graphql_introspection: value.graphql_introspection,
    }
}

pub fn storage_config(value: StorageConfigDto) -> pb::StorageConfig {
    pb::StorageConfig {
        bucket: value.bucket,
        region: value.region,
        path_style: value.path_style,
    }
}

pub fn database_config(value: DatabaseConfigDto) -> pb::DatabaseConfig {
    pb::DatabaseConfig {
        endpoint: value.endpoint,
        host: value.host,
        port: value.port.map(u32::from),
        database: value.database,
        ssl_mode: value.ssl_mode,
        max_connections: value.max_connections,
        min_connections: value.min_connections,
        replica_count: value.replica_count as u64,
    }
}

pub fn redis_config(value: RedisConfigDto) -> pb::RedisConfig {
    pb::RedisConfig {
        endpoint: value.endpoint,
        mode: value.mode,
        database: value.database.map(u32::from),
        pool_size: value.pool_size as u64,
    }
}

pub fn session_config(value: SessionConfigDto) -> pb::SessionConfig {
    pb::SessionConfig {
        mode: value.mode,
        cookie_name: value.cookie_name,
        cookie_domain: value.cookie_domain,
        cookie_secure: value.cookie_secure,
        cookie_same_site: value.cookie_same_site,
        lifespan_secs: value.lifespan_secs,
        table_name: value.table_name,
    }
}

pub fn email_config(value: EmailConfigDto) -> pb::EmailConfig {
    pb::EmailConfig {
        enabled: value.enabled,
        queue_enabled: value.queue_enabled,
        smtp_host: value.smtp_host,
        smtp_port: u32::from(value.smtp_port),
        from_address: value.from_address,
        from_name: value.from_name,
    }
}