use admin::services::users::{
    AdminSuspensionDto, AdminUserDetail, AdminUserEmailDto, AdminUserSecurityDto,
    AdminUserSessionDto, AdminUserSessionPage, AdminUserSessionRow, AdminUserSpaceDto,
    AdminUserSummary, BulkUserFailure, BulkUsersResp, CreateUserResp, DeleteUserResp,
    RevokeSessionsResp,
};
use export::pagination::Page;

use crate::convert::{opt_ts, ts};
use crate::proto as pb;

pub fn user(value: AdminUserSummary) -> pb::AdminUser {
    pb::AdminUser {
        uid: value.uid.to_string(),
        username: value.username,
        display_name: value.display_name,
        avatar_url: value.avatar_url,
        is_active: value.is_active,
        is_restricted: value.is_restricted,
        prohibit_login: value.prohibit_login,
        bot: value.bot,
        system: value.system,
        suspended: value.suspended,
        created_at: ts(value.created_at),
        last_login_at: opt_ts(value.last_login_at),
    }
}

pub fn user_page(value: Page<AdminUserSummary>) -> pb::AdminUserPage {
    pb::AdminUserPage {
        items: value.items.into_iter().map(user).collect(),
        total: value.total,
        limit: value.limit,
        offset: value.offset,
    }
}

pub fn user_detail(value: AdminUserDetail) -> pb::AdminUserDetail {
    pb::AdminUserDetail {
        user: Some(user(value.user)),
        emails: value.emails.into_iter().map(email).collect(),
        sessions: value.sessions.into_iter().map(session).collect(),
        spaces: value.spaces.into_iter().map(user_space).collect(),
        suspensions: value.suspensions.into_iter().map(suspension).collect(),
    }
}

pub fn email(value: AdminUserEmailDto) -> pb::AdminUserEmail {
    pb::AdminUserEmail {
        id: value.id.to_string(),
        email: value.email,
        is_primary: value.is_primary,
        is_activated: value.is_activated,
        created_at: ts(value.created_at),
    }
}

pub fn session(value: AdminUserSessionDto) -> pb::AdminUserSession {
    pb::AdminUserSession {
        id: value.id.to_string(),
        kind: value.kind,
        last_seen_at: ts(value.last_seen_at),
        created_at: ts(value.created_at),
        expires_at: ts(value.expires_at),
        is_revoked: value.is_revoked,
    }
}

pub fn user_space(value: AdminUserSpaceDto) -> pb::AdminUserSpace {
    pb::AdminUserSpace {
        id: value.id.to_string(),
        name: value.name,
        lower_name: value.lower_name,
        is_active: value.is_active,
    }
}

pub fn suspension(value: AdminSuspensionDto) -> pb::AdminSuspension {
    pb::AdminSuspension {
        id: value.id.to_string(),
        suspension_type: value.suspension_type,
        reason: value.reason,
        starts_at: ts(value.starts_at),
        ends_at: opt_ts(value.ends_at),
        revoked_at: opt_ts(value.revoked_at),
        suspended_by: value.suspended_by.map(|value| value.to_string()),
    }
}

pub fn session_row(value: AdminUserSessionRow) -> pb::AdminUserSessionRow {
    pb::AdminUserSessionRow {
        id: value.id.to_string(),
        kind: value.kind,
        device_id: value.device_id.map(|value| value.to_string()),
        user_agent_hash: value.user_agent_hash,
        client_ip_hash: value.client_ip_hash,
        app_id: value.app_id,
        last_seen_at: ts(value.last_seen_at),
        created_at: ts(value.created_at),
        expires_at: ts(value.expires_at),
        is_revoked: value.is_revoked,
        revoked_at: opt_ts(value.revoked_at),
    }
}

pub fn session_page(value: AdminUserSessionPage) -> pb::AdminUserSessionPage {
    pb::AdminUserSessionPage {
        items: value.items.into_iter().map(session_row).collect(),
        total: value.total,
        limit: value.limit,
        offset: value.offset,
    }
}

pub fn create_resp(value: CreateUserResp) -> pb::CreateUserResp {
    pb::CreateUserResp {
        uid: value.uid.to_string(),
        username: value.username,
        email: value.email,
    }
}

pub fn delete_resp(value: DeleteUserResp) -> pb::DeleteUserResp {
    pb::DeleteUserResp {
        user_id: value.user_id.to_string(),
        anonymized: value.anonymized,
    }
}

pub fn revoke_sessions(value: RevokeSessionsResp) -> pb::RevokeSessionsResp {
    pb::RevokeSessionsResp {
        revoked: value.revoked,
    }
}

pub fn security(value: AdminUserSecurityDto) -> pb::AdminUserSecurity {
    pb::AdminUserSecurity {
        totp_enabled: value.totp_enabled,
        recovery_codes_total: value.recovery_codes_total,
        recovery_codes_used: value.recovery_codes_used,
        active_sessions: value.active_sessions,
        ssh_keys: value.ssh_keys,
        access_keys: value.access_keys,
        passwd_version: value.passwd_version,
        password_last_changed_at: opt_ts(value.password_last_changed_at),
    }
}

pub fn bulk_failure(value: BulkUserFailure) -> pb::BulkUserFailure {
    pb::BulkUserFailure {
        uid: value.uid.to_string(),
        error: value.error,
    }
}

pub fn bulk_resp(value: BulkUsersResp) -> pb::BulkUsersResp {
    pb::BulkUsersResp {
        action: value.action,
        succeeded: value
            .succeeded
            .into_iter()
            .map(|uid| uid.to_string())
            .collect(),
        failed: value.failed.into_iter().map(bulk_failure).collect(),
    }
}