options/registry/mode_defaults.c

Go to the documentation of this file.

 
#include <ascii-chat/options/registry/mode_defaults.h>
#include <ascii-chat/options/registry/common.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/platform/system.h>
#include <string.h>
#include <stdio.h>
 
// ============================================================================
// Mode Descriptors - Names, Descriptions, and Groups
// ============================================================================
// Note: mode_descriptor_t is defined in mode_defaults.h (not here)
 
static const mode_descriptor_t g_mode_descriptors[] = {
    {MODE_SERVER, "server", "Multi-client video broadcast server", "server-like"},
    {MODE_DISCOVERY_SERVICE, "discovery-service", "Session discovery and registration service", "server-like"},
    {MODE_CLIENT, "client", "Connect to a server and send/receive streams", "client-like"},
    {MODE_MIRROR, "mirror", "Local webcam preview without networking", "client-like"},
    {MODE_DISCOVERY, "discovery", "Participant with dynamic session discovery", "client-like"},
    {MODE_INVALID, NULL, NULL, NULL}};
 
const mode_descriptor_t *get_mode_descriptor(asciichat_mode_t mode) {
  for (size_t i = 0; g_mode_descriptors[i].name; i++) {
    if (g_mode_descriptors[i].mode == mode) {
      return &g_mode_descriptors[i];
    }
  }
  return NULL;
}
 
const mode_descriptor_t *get_modes_by_group(const char *group, size_t *out_count) {
  if (!group || !out_count) {
    return NULL;
  }
 
  // Count matching modes
  size_t count = 0;
  for (size_t i = 0; g_mode_descriptors[i].name; i++) {
    if (strcmp(g_mode_descriptors[i].group, group) == 0) {
      count++;
    }
  }
 
  if (count == 0) {
    *out_count = 0;
    return NULL;
  }
 
  // Allocate result array
  mode_descriptor_t *result = SAFE_MALLOC((count + 1) * sizeof(mode_descriptor_t), mode_descriptor_t *);
  size_t idx = 0;
 
  // Fill result array
  for (size_t i = 0; g_mode_descriptors[i].name && idx < count; i++) {
    if (strcmp(g_mode_descriptors[i].group, group) == 0) {
      result[idx++] = g_mode_descriptors[i];
    }
  }
 
  // Add terminator
  result[idx].mode = MODE_INVALID;
  result[idx].name = NULL;
  result[idx].description = NULL;
  result[idx].group = NULL;
 
  *out_count = count;
  return result;
}
 
// ============================================================================
// Mode-Aware Default: log-file
// ============================================================================
 
const void *get_default_log_file(asciichat_mode_t mode) {
  (void)mode; // Unused
  // Return empty string - let options_get_log_filepath() handle the defaults
  return "";
}
 
// ============================================================================
// Mode-Aware Default: port
// ============================================================================
 
static const int g_port_server = OPT_PORT_INT_DEFAULT;                 // 27224
static const int g_port_client = OPT_PORT_INT_DEFAULT;                 // 27224
static const int g_port_discovery_service = OPT_ACDS_PORT_INT_DEFAULT; // 27225
static const int g_port_discovery = OPT_PORT_INT_DEFAULT;              // 27224 (connects via discovery)
 
const void *get_default_port(asciichat_mode_t mode) {
  switch (mode) {
  case MODE_SERVER:
    return &g_port_server;
  case MODE_CLIENT:
    return &g_port_client;
  case MODE_DISCOVERY_SERVICE:
    return &g_port_discovery_service;
  case MODE_DISCOVERY:
    return &g_port_discovery;
  case MODE_MIRROR:
  case MODE_INVALID:
  default:
    // Fallback
    return &g_port_server;
  }
}
 
// ============================================================================
// Mode-Aware Default: websocket-port
// ============================================================================
 
static const int g_websocket_port_server = OPT_WEBSOCKET_PORT_SERVER_DEFAULT;          // 27226
static const int g_websocket_port_discovery_service = OPT_WEBSOCKET_PORT_ACDS_DEFAULT; // 27227
 
const void *get_default_websocket_port(asciichat_mode_t mode) {
  switch (mode) {
  case MODE_SERVER:
    return &g_websocket_port_server;
  case MODE_DISCOVERY_SERVICE:
    return &g_websocket_port_discovery_service;
  case MODE_CLIENT:
  case MODE_MIRROR:
  case MODE_DISCOVERY:
  case MODE_INVALID:
  default:
    // Fallback (should not be used for client/mirror/discovery)
    return &g_websocket_port_server;
  }
}
 
// ============================================================================
// Mode-Aware Default Application
// ============================================================================
 
void apply_mode_specific_defaults(options_t *opts) {
  if (!opts) {
    return;
  }
 
  // Apply port default based on mode
  const int *mode_port = (const int *)get_default_port(opts->detected_mode);
  if (mode_port) {
    // Only update if still at a generic default (27224 or 27225)
    if (opts->port == OPT_PORT_INT_DEFAULT || opts->port == OPT_ACDS_PORT_INT_DEFAULT) {
      opts->port = *mode_port;
    }
  }
 
  // Apply websocket-port default based on mode
  const int *mode_websocket_port = (const int *)get_default_websocket_port(opts->detected_mode);
  if (mode_websocket_port) {
    // Only update if still at a generic default (27226 or 27227)
    if (opts->websocket_port == OPT_WEBSOCKET_PORT_SERVER_DEFAULT ||
        opts->websocket_port == OPT_WEBSOCKET_PORT_ACDS_DEFAULT) {
      opts->websocket_port = *mode_websocket_port;
    }
  }
 
  // If TLS cert+key are provided and websocket-port was not explicitly set,
  // default to 443 (standard HTTPS/WSS port) instead of the mode default.
  if (opts->websocket_tls_cert[0] != '\0' && opts->websocket_tls_key[0] != '\0') {
    if (opts->websocket_port == OPT_WEBSOCKET_PORT_SERVER_DEFAULT ||
        opts->websocket_port == OPT_WEBSOCKET_PORT_ACDS_DEFAULT) {
      opts->websocket_port = 443;
    }
  }
}