use crate::domain::dto::server::{
    CreateServerRequest, ServerExplorerItemResponse, ServerResponse, ServerRolePermissionResponse,
    ServerTreeResponse, ServerUserPermissionResponse, UpdateServerRequest,
};
use crate::models::{
    category, channel, server, server_item_order, server_role_permission, server_user_permission,
};
use crate::routes::category::mapper::category_model_to_category_response;
use crate::routes::channel::mapper::channel_model_to_channel_response;
use sea_orm::Set;
use std::collections::HashMap;
use uuid::Uuid;

pub fn server_model_to_server_response(model: server::Model) -> ServerResponse {
    ServerResponse {
        id: model.id,
        name: model.name,
        is_default: model.is_default,
        created_at: model.created_at,
        updated_at: model.updated_at,
    }
}

pub fn create_request_to_am(req: CreateServerRequest) -> server::ActiveModel {
    server::ActiveModel {
        id: Set(Uuid::new_v4()),
        name: Set(req.name),
        password: Set(req.password),
        is_default: Set(req.is_default),
        ..Default::default()
    }
}

pub fn update_request_to_am(id: Uuid, req: UpdateServerRequest) -> server::ActiveModel {
    server::ActiveModel {
        id: Set(id),
        name: Set(req.name),
        password: Set(req.password),
        is_default: Set(req.is_default),
        ..Default::default()
    }
}

pub fn server_user_permission_to_response(
    model: server_user_permission::Model,
) -> ServerUserPermissionResponse {
    ServerUserPermissionResponse {
        id: model.id,
        server_id: model.server_id,
        user_id: model.user_id,
        permissions: model.permissions as u64,
    }
}

pub fn server_role_permission_to_response(
    model: server_role_permission::Model,
) -> ServerRolePermissionResponse {
    ServerRolePermissionResponse {
        id: model.id,
        server_id: model.server_id,
        role_id: model.role_id,
        permissions: model.permissions as u64,
    }
}

pub fn build_server_tree(
    orders: Vec<server_item_order::Model>,
    channels: Vec<channel::Model>,
    categories: Vec<category::Model>,
) -> ServerTreeResponse {
    // Map d'accès rapide : resource_id -> order_key
    let order_map: HashMap<Uuid, i64> = orders
        .into_iter()
        .map(|o| (o.resource_id, o.order_key))
        .collect();

    // Regrouper les canaux par catégorie ou orphelins
    let mut category_channels: HashMap<Uuid, Vec<channel::Model>> = HashMap::new();
    let mut orphan_channels: Vec<channel::Model> = Vec::new();

    for chan in channels {
        if let Some(cat_id) = chan.category_id {
            category_channels.entry(cat_id).or_default().push(chan);
        } else {
            orphan_channels.push(chan);
        }
    }

    // Trier les canaux dans chaque catégorie par leur order_key
    for chans in category_channels.values_mut() {
        chans.sort_by_key(|c| order_map.get(&c.id).copied().unwrap_or(i64::MAX));
    }

    // Préparer les éléments racine (catégories & canaux orphelins) avec leur order_key
    let mut root_items: Vec<(ServerExplorerItemResponse, i64)> = Vec::new();

    for cat in categories {
        let cat_id = cat.id;
        let order_key = order_map.get(&cat_id).copied().unwrap_or(i64::MAX);
        let chans = category_channels.remove(&cat_id).unwrap_or_default();

        let cat_response = category_model_to_category_response(cat);
        let chan_responses = chans
            .into_iter()
            .map(channel_model_to_channel_response)
            .collect();

        root_items.push((
            ServerExplorerItemResponse::Category(cat_response, chan_responses),
            order_key,
        ));
    }

    for chan in orphan_channels {
        let order_key = order_map.get(&chan.id).copied().unwrap_or(i64::MAX);
        let chan_response = channel_model_to_channel_response(chan);
        root_items.push((
            ServerExplorerItemResponse::Channel(chan_response),
            order_key,
        ));
    }

    // Tri du niveau racine par order_key
    root_items.sort_by_key(|(_, order_key)| *order_key);

    let items = root_items.into_iter().map(|(item, _)| item).collect();

    ServerTreeResponse { items }
}