use crate::domain::dto::channel::{
    ChannelPermissionsResponse, ChannelQueryParams, ChannelResponse, ChannelRolePermissionResponse,
    ChannelUserPermissionResponse, CreateChannelRequest, UpdateChannelRequest,
};
use crate::models::{channel, channel_role_permission, channel_user_permission};
use crate::repositories::types::ChannelFilter;
use sea_orm::Set;
use uuid::Uuid;

pub fn channel_model_to_channel_response(model: channel::Model) -> ChannelResponse {
    channel_model_to_channel_response_with_permission(model, None)
}

pub fn channel_model_to_channel_response_with_permission(
    model: channel::Model,
    permission: Option<u64>,
) -> ChannelResponse {
    ChannelResponse {
        id: model.id,
        server_id: model.server_id,
        category_id: model.category_id,
        channel_type: model.channel_type,
        name: model.name,
        created_at: model.created_at,
        updated_at: model.updated_at,
        permission,
    }
}

pub fn create_request_to_am(req: CreateChannelRequest) -> channel::ActiveModel {
    channel::ActiveModel {
        id: Set(Uuid::new_v4()),
        server_id: Set(req.server_id),
        category_id: Set(req.category_id),
        channel_type: Set(req.channel_type),
        name: Set(req.name),
        ..Default::default()
    }
}

pub fn update_request_to_am(id: Uuid, req: UpdateChannelRequest) -> channel::ActiveModel {
    channel::ActiveModel {
        id: Set(id),
        server_id: Set(req.server_id),
        category_id: Set(req.category_id),
        channel_type: Set(req.channel_type),
        name: Set(req.name),
        ..Default::default()
    }
}

pub fn channel_user_permission_to_response(
    model: channel_user_permission::Model,
) -> ChannelUserPermissionResponse {
    ChannelUserPermissionResponse {
        id: model.id,
        channel_id: model.channel_id,
        user_id: model.user_id,
        permissions: model.permissions as u64,
    }
}

pub fn channel_role_permission_to_response(
    model: channel_role_permission::Model,
) -> ChannelRolePermissionResponse {
    ChannelRolePermissionResponse {
        id: model.id,
        channel_id: model.channel_id,
        role_id: model.role_id,
        permissions: model.permissions as u64,
    }
}

pub fn channel_permissions_to_response(
    users: Vec<channel_user_permission::Model>,
    roles: Vec<channel_role_permission::Model>,
) -> ChannelPermissionsResponse {
    ChannelPermissionsResponse {
        users: users.into_iter().map(channel_user_permission_to_response).collect(),
        roles: roles.into_iter().map(channel_role_permission_to_response).collect(),
    }
}

pub fn query_params_to_channel_filter(params: ChannelQueryParams) -> ChannelFilter {
    ChannelFilter {
        server_id: params.server_id,
    }
}