using System.Collections.Concurrent;
using MoonlightServers.Daemon.ServerSystem;

namespace MoonlightServers.Daemon.Services;

public class ServerService : IAsyncDisposable
{
    private readonly ServerFactory ServerFactory;
    private readonly ConcurrentDictionary<string, Server> Servers = new();
    private readonly ILogger<ServerService> Logger;

    public ServerService(ServerFactory serverFactory, ILogger<ServerService> logger)
    {
        ServerFactory = serverFactory;
        Logger = logger;
    }

    public async Task SyncAsync(string uuid)
    {
        if (Servers.TryGetValue(uuid, out var server))
        {
            Logger.LogTrace("Updating existing server {uuid}", uuid);
            
            await server.UpdateAsync();
        }
        else
        {
            Logger.LogTrace("Creating new server instance {uuid}", uuid);
            
            var newServer = await ServerFactory.CreateAsync(uuid);
            await newServer.InitializeAsync();

            Servers[uuid] = newServer;
        }
    }

    public Task<Server?> GetAsync(string uuid)
    {
        var server = Servers.GetValueOrDefault(uuid);
        return Task.FromResult(server);
    }

    public async Task DeleteAsync(string uuid)
    {
        Logger.LogTrace("Deleting server {uuid}", uuid);
        
        var server = Servers.GetValueOrDefault(uuid);
        
        if(server == null)
            return;

        // Trigger internal deletion mechanism
        await server.DeleteAsync();

        // Dispose any left over resources
        await server.DisposeAsync();

        // Remove server from cache
        Servers.TryRemove(uuid, out _);
    }

    public async ValueTask DisposeAsync()
    {
        foreach (var server in Servers)
            await server.Value.DisposeAsync();
    }
}