use crate::repositories::Repositories;
use crate::services::category::CategoryService;
use crate::services::channel::ChannelService;
use crate::services::emoji::EmojiService;
use crate::services::message::MessageService;
use crate::services::message_reaction::MessageReactionService;
use crate::services::permission::PermissionService;
use crate::services::permission_sync::PermissionSyncService;
use crate::services::role::RoleService;
use crate::services::server::ServerService;
use crate::services::server_order::ServerOrderService;
use crate::services::user::UserService;
use event_bus::EventBus;
use std::sync::{Arc, OnceLock};

pub mod category;
pub mod channel;
pub mod emoji;
pub mod message;
pub mod message_reaction;
mod permission;
pub mod permission_sync;
pub mod realtime_registry;
pub mod role;
pub mod server;
mod server_order;
pub mod user;

#[derive(Debug, Clone)]
pub struct ServicesContext {
    pub repositories: Arc<Repositories>,
    pub event_bus: Arc<EventBus>,
    pub services: OnceLock<Services>,
}

#[derive(Debug, Clone)]
pub struct Services {
    pub realtime_registry: Arc<realtime_registry::RealtimeRegistry>,
    pub permission_sync: Arc<PermissionSyncService>,
    pub server_order: Arc<ServerOrderService>,
    pub channel: Arc<ChannelService>,
    pub server: Arc<ServerService>,
    pub category: Arc<CategoryService>,
    pub message: Arc<MessageService>,
    pub message_reaction: Arc<MessageReactionService>,
    pub user: Arc<UserService>,
    pub role: Arc<RoleService>,
    pub permission: Arc<PermissionService>,
    pub emoji: Arc<EmojiService>,
}

impl Services {
    pub fn new(repositories: Arc<Repositories>, event_bus: Arc<EventBus>) -> Self {
        let service_context = Arc::new(ServicesContext {
            repositories,
            event_bus,
            services: OnceLock::new(),
        });
        let permission_sync = Arc::new(PermissionSyncService::new(service_context.clone()));
        let realtime_registry = Arc::new(realtime_registry::RealtimeRegistry::default());
        let server_order = Arc::new(ServerOrderService::new(service_context.clone()));
        let channel = Arc::new(ChannelService::new(service_context.clone()));
        let server = Arc::new(ServerService::new(service_context.clone()));
        let category = Arc::new(CategoryService::new(service_context.clone()));
        let message = Arc::new(MessageService::new(service_context.clone()));
        let message_reaction = Arc::new(MessageReactionService::new(service_context.clone()));
        let user = Arc::new(UserService::new(service_context.clone()));
        let role = Arc::new(RoleService::new(service_context.clone()));
        let permission = Arc::new(PermissionService::new(service_context.clone()));
        let emoji = Arc::new(EmojiService::new(service_context.clone()));

        let services = Self {
            realtime_registry,
            permission_sync,
            server_order,
            channel,
            server,
            category,
            message,
            message_reaction,
            user,
            role,
            permission,
            emoji,
        };
        let _ = service_context.services.set(services.clone());
        services
    }
}