Core Components and Layers

public interface IWebSocketService
{
    // Events
    event AsyncEventHandler<string> OnClientConnected;
    event AsyncEventHandler<string> OnClientDisconnected;
    event AsyncEventHandler<WebSocketMessageReceivedEventArgs<PrintJobRequest>> OnPrintJobReceived;
    event AsyncEventHandler<WebSocketMessageReceivedEventArgs<PrintTemplate>> OnTemplateUpdateReceived;

    // Methods
    Task StartServerAsync(int port);
    Task StopServerAsync();
    Task SendPrintJobResultToAllClientsAsync(PrintJobResult result);
    Task SendPrintJobResultToClientAsync(string clientId, PrintJobResult result);
    Task SendScaleDataToAllClientsAsync(ScaleData scaleData);
    Task SendTemplateUpdateResultAsync(string clientId, TemplateUpdateResult result);

    // Properties
    bool IsRunning { get; }
    int CurrentClientCount { get; }
}

public interface IPrintService
{
    Task<PrintJobResult> ProcessPrintJobAsync(PrintJobRequest request);
    Task ConfigurePrinterAsync(PrinterSettings settings);
    Task<PrinterSettings> GetPrinterSettingsAsync(string printerId);
    Task<List<PrinterSettings>> GetAllPrinterSettingsAsync();
    Task DeletePrinterSettingsAsync(string printerId);
}

public interface ITicketRenderer
{
    Task<TicketContent> RenderTicketAsync(PrintJobRequest request, object documentData);
}

public interface IEscPosGenerator
{
    Task<byte[]> GenerateEscPosCommandsAsync(TicketContent content, PrinterSettings settings);
}

public interface ISettingsRepository
{
    Task SavePrinterSettingsAsync(PrinterSettings settings);
    Task<PrinterSettings> GetPrinterSettingsAsync(string printerId);
    Task<List<PrinterSettings>> GetAllPrinterSettingsAsync();
    Task<bool> DeletePrinterSettingsAsync(string printerId);
}

public interface ITemplateRepository
{
    Task<PrintTemplate> GetTemplateByTypeAsync(string documentType);
    Task SaveTemplateAsync(PrintTemplate template);
    Task<List<PrintTemplate>> GetAllTemplatesAsync();
    Task DeleteTemplateAsync(string templateId);
    Task EnsureDefaultTemplatesAsync();
    
    // Dot matrix support
    Task<DotMatrixTemplate?> GetDotMatrixTemplateByTypeAsync(string documentType);
    Task SaveDotMatrixTemplateAsync(DotMatrixTemplate template);
}

public interface IScaleService
{
    event EventHandler<ScaleDataEventArgs> OnWeightChanged;
    
    Task InitializeAsync();
    ScaleStatus GetStatus(string scaleId);
    List<ScaleStatusInfo> GetAllStatuses();
    void StartListening(string scaleId);
    void StopListening(string scaleId);
    Task ReloadScalesAsync();
    ScaleData? GetLastScaleReading();
}

public class PrintJobRequest
{
    public string JobId { get; set; }
    public string PrinterId { get; set; }
    public string DocumentType { get; set; }
    public object Document { get; set; }
    public int PaperWidth { get; set; }
    public string Encoding { get; set; }
}

public class PrintJobResult
{
    public string JobId { get; set; }
    public string Status { get; set; } // "DONE" or "ERROR"
    public string? ErrorMessage { get; set; }
}

public class PrinterSettings
{
    public string PrinterId { get; set; }
    public string Name { get; set; }
    public string ConnectionType { get; set; } // "TCP", "USB", "IPP"
    public string? IpAddress { get; set; }
    public int Port { get; set; }
    public string? LocalPrinterName { get; set; }
    public string? Uri { get; set; }
    public int PaperWidthMm { get; set; }
    public string CharacterSet { get; set; }
    public List<string>? CopyToPrinterIds { get; set; }
}

public class PrintTemplate
{
    public string TemplateId { get; set; }
    public string DocumentType { get; set; }
    public string Version { get; set; }
    public List<TemplateSection> Sections { get; set; }
}

public class TicketContent
{
    public List<RenderedSection> Sections { get; set; }
    public int PaperWidth { get; set; }
    public string Encoding { get; set; }
}

public class WebSocketServerService : IWebSocketService
{
    private HttpListener? _httpListener;
    private ConcurrentDictionary<string, WebSocket> _connectedClients;
    private ConcurrentQueue<(string ClientId, string Message)> _messageQueue;
    private ConcurrentDictionary<string, string> _clientScaleSubscriptions;
    
    // Constructor injects dependencies
    public WebSocketServerService(
        ILoggingService logger, 
        IPrintService printService, 
        IScaleService scaleService)
    {
        // Subscribe to scale events
        _scaleService.OnWeightChanged += ScaleService_OnWeightChanged;
    }
}

public PrintService(
    ILoggingService logger,
    ISettingsRepository settingsRepository,
    ITicketRenderer ticketRenderer,
    ITemplateRepository templateRepository,
    IEscPosGenerator escPosGenerator,
    TcpIpPrinterClient tcpIpPrinterClient,
    DotMatrixRendererService dotMatrixRenderer,
    EscPGeneratorService escPGenerator,
    LocalRawPrinterClient localRawPrinterClient,
    IppPrinterClient ippPrinterClient)

// Core services
services.AddSingleton<ILoggingService, Logger>();
services.AddSingleton<ISettingsRepository, SettingsRepository>();
services.AddSingleton<ITemplateRepository, TemplateRepository>();
services.AddSingleton<ITicketRenderer, TicketRendererService>();
services.AddSingleton<IEscPosGenerator, EscPosGeneratorService>();
services.AddSingleton<IPrintService, PrintService>();

// Printer clients
services.AddSingleton<TcpIpPrinterClient>();
services.AddSingleton<LocalRawPrinterClient>();
services.AddSingleton<IppPrinterClient>();

// Dot matrix support
services.AddSingleton<DotMatrixRendererService>();
services.AddSingleton<EscPGeneratorService>();

// Scale services
services.AddSingleton<IScaleRepository, JsonScaleRepository>();
services.AddSingleton<IScaleService, SerialScaleService>();

#if WINDOWS
services.AddSingleton<IWorkerServiceManager, WindowsWorkerServiceManager>();
services.AddSingleton<ITrayAppService, WindowsTrayAppService>();
services.AddSingleton<IPlatformService, WindowsPlatformService>();
services.AddSingleton<IWebSocketService, WebSocketServerService>();
#endif

#if ANDROID
services.AddSingleton<IPlatformService, AndroidPlatformService>();
services.AddSingleton<IWebSocketService, AndroidWebSocketService>();
#endif