splash.c

Go to the documentation of this file.

 
#include <ascii-chat/ui/splash.h>
#include <ascii-chat/ui/terminal_screen.h>
#include <ascii-chat/log/interactive_grep.h>
#include <ascii-chat/session/display.h>
#include <ascii-chat/session/session_log_buffer.h>
#include <ascii-chat/util/display.h>
#include <ascii-chat/util/ip.h>
#include <ascii-chat/util/string.h>
#include <ascii-chat/platform/terminal.h>
#include <ascii-chat/platform/keyboard.h>
#include <ascii-chat/platform/system.h>
#include <ascii-chat/platform/abstraction.h>
#include <ascii-chat/video/image.h>
#include <ascii-chat/video/ansi_fast.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/log/logging.h>
#include <ascii-chat/common.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdatomic.h>
#include <time.h>
 
// ============================================================================
// ASCII Art and Constants
// ============================================================================
 
#define ASCII_LOGO_LINES 7
#define ASCII_LOGO_WIDTH 36
 
// Global update notification (set via splash_set_update_notification)
static char g_update_notification[1024] = {0};
static mutex_t g_update_notification_mutex;
 
static const rgb_pixel_t g_rainbow_colors[] = {
    {255, 0, 0},   // Red
    {255, 165, 0}, // Orange
    {255, 255, 0}, // Yellow
    {0, 255, 0},   // Green
    {0, 255, 255}, // Cyan
    {0, 0, 255},   // Blue
    {255, 0, 255}  // Magenta
};
#define RAINBOW_COLOR_COUNT 7
 
static struct {
  _Atomic(bool) is_running;       // true while animation should continue
  _Atomic(bool) should_stop;      // set to true when first frame ready
  int frame;                      // current animation frame
  asciichat_thread_t anim_thread; // animation thread handle
} g_splash_state = {.is_running = false, .should_stop = false, .frame = 0};
 
// ============================================================================
// Helper Functions - TTY Detection
// ============================================================================
 
// ============================================================================
// Helper Functions - Rainbow Rendering
// ============================================================================
 
static rgb_pixel_t interpolate_color(rgb_pixel_t color1, rgb_pixel_t color2, double t) {
  rgb_pixel_t result;
  result.r = (uint8_t)(color1.r * (1.0 - t) + color2.r * t);
  result.g = (uint8_t)(color1.g * (1.0 - t) + color2.g * t);
  result.b = (uint8_t)(color1.b * (1.0 - t) + color2.b * t);
  return result;
}
 
static rgb_pixel_t get_rainbow_color_rgb(double position) {
  // Normalize position to 0-1 range
  double norm_pos = position - (long)position;
  if (norm_pos < 0) {
    norm_pos += 1.0;
  }
 
  // Scale position to color range
  double color_pos = norm_pos * (RAINBOW_COLOR_COUNT - 1);
  int color_idx = (int)color_pos;
  double blend = color_pos - color_idx;
 
  // Wrap around at the end
  if (color_idx >= RAINBOW_COLOR_COUNT - 1) {
    color_idx = RAINBOW_COLOR_COUNT - 1;
    blend = 0;
  }
 
  int next_idx = (color_idx + 1) % RAINBOW_COLOR_COUNT;
 
  return interpolate_color(g_rainbow_colors[color_idx], g_rainbow_colors[next_idx], blend);
}
 
// ============================================================================
// Header Rendering (callback for terminal_screen)
// ============================================================================
 
typedef struct {
  int frame;                      // Current animation frame number
  bool use_colors;                // Whether to use rainbow colors
  char update_notification[1024]; // Update notification message (empty if no update)
} splash_header_ctx_t;
 
static void build_connection_target(char *buffer, size_t buffer_size) {
  if (!buffer || buffer_size == 0) {
    return;
  }
  buffer[0] = '\0';
 
  // Mirror mode - no network connection
  asciichat_mode_t mode = GET_OPTION(detected_mode);
  if (mode == MODE_MIRROR) {
    const char *media_url = GET_OPTION(media_url);
    const char *media_file = GET_OPTION(media_file);
 
    if (media_url && media_url[0] != '\0') {
      snprintf(buffer, buffer_size, "Loading from URL...");
    } else if (media_file && media_file[0] != '\0') {
      snprintf(buffer, buffer_size, "Loading from file...");
    } else {
      snprintf(buffer, buffer_size, "Initializing...");
    }
    return;
  }
 
  // Check if we have a session string (discovery mode)
  const char *session = GET_OPTION(session_string);
  if (session && session[0] != '\0') {
    snprintf(buffer, buffer_size, "Connecting to session: %s", session);
    return;
  }
 
  // Check if we have an address (client mode)
  const char *addr = GET_OPTION(address);
 
  if (addr && addr[0] != '\0') {
    // Use IP utility to classify the connection type
    const char *ip_type = get_ip_type_string(addr);
 
    if (strcmp(ip_type, "Localhost") == 0) {
      snprintf(buffer, buffer_size, "Connecting to localhost...");
    } else if (strcmp(ip_type, "LAN") == 0) {
      snprintf(buffer, buffer_size, "Connecting to %s (LAN)", addr);
    } else if (strcmp(ip_type, "Internet") == 0) {
      snprintf(buffer, buffer_size, "Connecting to %s (Internet)", addr);
    } else if (strcmp(addr, "localhost") == 0) {
      // Hostname "localhost" not detected by IP util
      snprintf(buffer, buffer_size, "Connecting to localhost...");
    } else {
      // Unknown or hostname
      snprintf(buffer, buffer_size, "Connecting to %s", addr);
    }
    return;
  }
 
  // Fallback if no connection info available
  snprintf(buffer, buffer_size, "Initializing...");
}
 
static void render_splash_header(terminal_size_t term_size, void *user_data) {
  const splash_header_ctx_t *ctx = (const splash_header_ctx_t *)user_data;
  if (!ctx) {
    return;
  }
 
  // ASCII logo lines (same as help output)
  const char *ascii_logo[4] = {
      "  __ _ ___  ___(_|_)       ___| |__   __ _| |_ ", " / _` / __|/ __| | |_____ / __| '_ \\ / _` | __| ",
      "| (_| \\__ \\ (__| | |_____| (__| | | | (_| | |_ ", " \\__,_|___/\\___|_|_|      \\___|_| |_|\\__,_|\\__| "};
  const char *tagline = "Video chat in your terminal";
  const int logo_width = 52;
  const double rainbow_speed = 0.01; // Characters per frame of wave speed
 
  // Calculate rainbow offset for this frame (smooth continuous wave)
  double offset = ctx->frame * rainbow_speed;
 
  // Line 1: Top border
  printf("\033[1;36m━");
  for (int i = 1; i < term_size.cols - 1; i++) {
    printf("━");
  }
  printf("\033[0m\n");
 
  // Lines 2-5: ASCII logo (centered, truncated if too long)
  for (int logo_line = 0; logo_line < 4; logo_line++) {
    // Build plain text line first (for width calculation)
    char plain_line[512];
    int horiz_pad = (term_size.cols - logo_width) / 2;
    if (horiz_pad < 0) {
      horiz_pad = 0;
    }
 
    int pos = 0;
    for (int j = 0; j < horiz_pad && pos < (int)sizeof(plain_line) - 1; j++) {
      plain_line[pos++] = ' ';
    }
    snprintf(plain_line + pos, sizeof(plain_line) - pos, "%s", ascii_logo[logo_line]);
 
    // Check visible width and truncate if needed
    int visible_width = display_width(plain_line);
    if (visible_width < 0) {
      visible_width = (int)strlen(plain_line);
    }
    if (term_size.cols > 0 && visible_width >= term_size.cols) {
      plain_line[term_size.cols - 1] = '\0';
    }
 
    // Print with rainbow colors
    int char_idx = 0;
    for (int i = 0; plain_line[i] != '\0'; i++) {
      char ch = plain_line[i];
      if (ch == ' ') {
        printf(" ");
      } else if (ctx->use_colors) {
        double char_pos = (ctx->frame * 52 + char_idx + offset) / 30.0;
        rgb_pixel_t color = get_rainbow_color_rgb(char_pos);
        printf("\x1b[38;2;%u;%u;%um%c\x1b[0m", color.r, color.g, color.b, ch);
        char_idx++;
      } else {
        printf("%c", ch);
        char_idx++;
      }
    }
    printf("\n");
  }
 
  // Line 6: Tagline (centered, truncated if too long)
  char plain_tagline[512];
  int tagline_len = (int)strlen(tagline);
  int tagline_pad = (term_size.cols - tagline_len) / 2;
  if (tagline_pad < 0) {
    tagline_pad = 0;
  }
 
  int tpos = 0;
  for (int j = 0; j < tagline_pad && tpos < (int)sizeof(plain_tagline) - 1; j++) {
    plain_tagline[tpos++] = ' ';
  }
  snprintf(plain_tagline + tpos, sizeof(plain_tagline) - tpos, "%s", tagline);
 
  // Check visible width and truncate if needed
  int tagline_visible_width = display_width(plain_tagline);
  if (tagline_visible_width < 0) {
    tagline_visible_width = (int)strlen(plain_tagline);
  }
  if (term_size.cols > 0 && tagline_visible_width >= term_size.cols) {
    plain_tagline[term_size.cols - 1] = '\0';
  }
 
  printf("%s\n", plain_tagline);
 
  // Line 7: Update notification (if available)
  if (ctx->update_notification[0] != '\0') {
    char plain_update[1024];
    int update_len = (int)strlen(ctx->update_notification);
    int update_pad = (term_size.cols - update_len) / 2;
    if (update_pad < 0) {
      update_pad = 0;
    }
 
    int upos = 0;
    for (int j = 0; j < update_pad && upos < (int)sizeof(plain_update) - 1; j++) {
      plain_update[upos++] = ' ';
    }
    snprintf(plain_update + upos, sizeof(plain_update) - upos, "%s", ctx->update_notification);
 
    // Check visible width and truncate if needed
    int update_visible_width = display_width(plain_update);
    if (update_visible_width < 0) {
      update_visible_width = (int)strlen(plain_update);
    }
    if (term_size.cols > 0 && update_visible_width >= term_size.cols) {
      plain_update[term_size.cols - 1] = '\0';
    }
 
    // Print in yellow/warning color
    printf("%s\n", colored_string(LOG_COLOR_WARN, plain_update));
  }
 
  // Line 8 (or 7 if no update): Connection target (centered, truncated if too long)
  char connection_target[512];
  build_connection_target(connection_target, sizeof(connection_target));
 
  char plain_connection[512];
  int connection_len = (int)strlen(connection_target);
  int connection_pad = (term_size.cols - connection_len) / 2;
  if (connection_pad < 0) {
    connection_pad = 0;
  }
 
  int cpos = 0;
  for (int j = 0; j < connection_pad && cpos < (int)sizeof(plain_connection) - 1; j++) {
    plain_connection[cpos++] = ' ';
  }
  snprintf(plain_connection + cpos, sizeof(plain_connection) - cpos, "%s", connection_target);
 
  // Check visible width and truncate if needed
  int connection_visible_width = display_width(plain_connection);
  if (connection_visible_width < 0) {
    connection_visible_width = (int)strlen(plain_connection);
  }
  if (term_size.cols > 0 && connection_visible_width >= term_size.cols) {
    plain_connection[term_size.cols - 1] = '\0';
  }
 
  printf("%s\n", plain_connection);
 
  // Line 9 (or 8 if no update): Bottom border
  printf("\033[1;36m━");
  for (int i = 1; i < term_size.cols - 1; i++) {
    printf("━");
  }
  printf("\033[0m\n");
}
 
// ============================================================================
// Public API
// ============================================================================
 
bool splash_should_display(bool is_intro) {
  // Check option flags (display splash if enabled, regardless of TTY for testing)
  if (is_intro) {
    // Allow splash in snapshot mode if loading from URL/file (has loading time)
    // Skip splash only for quick webcam snapshots
    bool is_snapshot = GET_OPTION(snapshot_mode);
    bool has_media = (GET_OPTION(media_url) && strlen(GET_OPTION(media_url)) > 0) ||
                     (GET_OPTION(media_file) && strlen(GET_OPTION(media_file)) > 0);
 
    // Show splash if:
    // 1. Not in snapshot mode, OR
    // 2. In snapshot mode but loading from URL/file (needs splash during load)
    return GET_OPTION(splash) && (!is_snapshot || has_media);
  } else {
    return GET_OPTION(status_screen);
  }
}
 
static void *splash_animation_thread(void *arg) {
  (void)arg;
 
  // Check if colors should be used (TTY check)
  bool use_colors = terminal_should_color_output(STDOUT_FILENO);
 
  // Initialize keyboard for interactive grep (if terminal is interactive)
  bool keyboard_enabled = false;
  if (terminal_is_interactive()) {
    if (keyboard_init() == ASCIICHAT_OK) {
      keyboard_enabled = true;
    }
  }
 
  // Animate with rainbow wave effect
  int frame = 0;
  const int anim_speed = 100; // milliseconds per frame
 
  while (!atomic_load(&g_splash_state.should_stop) && !shutdown_is_requested()) {
    // Poll keyboard for interactive grep and Escape to cancel
    if (keyboard_enabled) {
      keyboard_key_t key = keyboard_read_nonblocking();
      if (key == KEY_ESCAPE) {
        // Escape key: cancel grep if active, otherwise cancel splash
        if (interactive_grep_is_active()) {
          interactive_grep_exit_mode(false); // Cancel grep without applying
        } else {
          atomic_store(&g_splash_state.should_stop, true); // Exit splash screen
        }
      } else if (key != KEY_NONE && interactive_grep_should_handle(key)) {
        interactive_grep_handle_key(key);
        // Continue to render immediately with grep active
      }
    }
    // Set up splash header context for this frame
    splash_header_ctx_t header_ctx = {
        .frame = frame,
        .use_colors = use_colors,
    };
 
    // Copy update notification from global state (thread-safe)
    static bool mutex_initialized = false;
    if (!mutex_initialized) {
      mutex_init(&g_update_notification_mutex);
      mutex_initialized = true;
    }
    mutex_lock(&g_update_notification_mutex);
    SAFE_STRNCPY(header_ctx.update_notification, g_update_notification, sizeof(header_ctx.update_notification));
    mutex_unlock(&g_update_notification_mutex);
 
    // Calculate header lines: 8 base lines + 1 if update notification present
    int header_lines = 8;
    if (header_ctx.update_notification[0] != '\0') {
      header_lines = 9;
    }
 
    // Configure terminal screen with splash header callback
    terminal_screen_config_t screen_config = {
        .fixed_header_lines = header_lines,
        .render_header = render_splash_header,
        .user_data = &header_ctx,
        .show_logs = true, // Show live log feed below splash
    };
 
    // Render the screen (header + logs) only in interactive mode
    // In non-interactive mode, logs flow to stdout/stderr normally
    if (terminal_is_interactive()) {
      terminal_screen_render(&screen_config);
    }
 
    // Move to next frame
    frame++;
 
    // Sleep to control animation speed (unless grep needs immediate rerender)
    if (!interactive_grep_needs_rerender()) {
      platform_sleep_ms(anim_speed);
    }
  }
 
  // Cleanup keyboard
  if (keyboard_enabled) {
    keyboard_destroy();
  }
 
  atomic_store(&g_splash_state.is_running, false);
  return NULL;
}
 
int splash_intro_start(session_display_ctx_t *ctx) {
  (void)ctx; // Parameter not used currently
 
  // Pre-checks
  if (!splash_should_display(true)) {
    return 0; // ASCIICHAT_OK equivalent
  }
 
  // Don't initialize log buffer in non-interactive mode - logs go directly to stdout/stderr
  if (!terminal_is_interactive()) {
    return 0;
  }
 
  // Check terminal size
  int width = GET_OPTION(width);
  int height = GET_OPTION(height);
  if (width < 50 || height < 20) {
    return 0;
  }
 
  // Initialize log buffer for capturing logs during animation
  if (!session_log_buffer_init()) {
    log_warn("Failed to initialize splash log buffer");
    return 0;
  }
 
  // Clear screen
  terminal_clear_screen();
  fflush(stdout);
 
  // Set running flag
  atomic_store(&g_splash_state.is_running, true);
  atomic_store(&g_splash_state.should_stop, false);
  g_splash_state.frame = 0;
 
  // Start animation thread
  if (asciichat_thread_create(&g_splash_state.anim_thread, splash_animation_thread, NULL) != ASCIICHAT_OK) {
    log_warn("Failed to create splash animation thread");
    return 0;
  }
 
  return 0; // ASCIICHAT_OK
}
 
int splash_intro_done(void) {
  // Signal animation thread to stop
  atomic_store(&g_splash_state.should_stop, true);
 
  // Wait for animation thread to finish
  if (atomic_load(&g_splash_state.is_running)) {
    asciichat_thread_join(&g_splash_state.anim_thread, NULL);
  }
 
  atomic_store(&g_splash_state.is_running, false);
 
  // Don't clear screen here - first frame will do it
  // Clearing here can cause a brief scroll artifact during transition
 
  // NOTE: Do NOT cleanup session_log_buffer here - it may be used by status screen
  // Status screen will call session_log_buffer_destroy() when appropriate
 
  return 0; // ASCIICHAT_OK
}
 
int splash_display_status(int mode) {
  // Pre-checks
  if (!splash_should_display(false)) {
    return 0;
  }
 
  // Check mode validity
  if (mode != 0 && mode != 3) { // MODE_SERVER=0, MODE_DISCOVERY_SERVICE=3
    log_error("Status screen only for server/discovery modes");
    return 1; // ERROR
  }
 
  // Check terminal size
  int width = GET_OPTION(width);
  int height = GET_OPTION(height);
  if (width < 50 || height < 15) {
    log_debug("Terminal too small for status screen");
    return 0;
  }
 
  // Get terminal capabilities for UTF-8
  bool has_utf8 = (GET_OPTION(force_utf8) >= 0);
  (void)has_utf8; // Suppress unused warning
 
  // Build and display status box
  terminal_clear_screen();
 
  char buffer[4096] = {0};
  snprintf(buffer, sizeof(buffer), "\n");
 
  if (mode == 0) {
    // Server mode
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Server Status\n");
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Address: %s:%d\n", GET_OPTION(address),
             GET_OPTION(port));
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Max clients: %d\n", GET_OPTION(max_clients));
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Encryption: %s\n",
             GET_OPTION(no_encrypt) ? "Disabled" : "Enabled");
  } else if (mode == 3) {
    // Discovery service mode
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Discovery Service\n");
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Address: %s:%d\n", GET_OPTION(address),
             GET_OPTION(discovery_port));
  }
 
  // Add update notification if available
  static bool mutex_initialized_for_status = false;
  if (!mutex_initialized_for_status) {
    mutex_init(&g_update_notification_mutex);
    mutex_initialized_for_status = true;
  }
  mutex_lock(&g_update_notification_mutex);
  if (g_update_notification[0] != '\0') {
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "\n  %s\n",
             colored_string(LOG_COLOR_WARN, g_update_notification));
  }
  mutex_unlock(&g_update_notification_mutex);
 
  snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "\n");
 
  printf("%s", buffer);
  fflush(stdout);
 
  return 0; // ASCIICHAT_OK
}
 
void splash_set_update_notification(const char *notification) {
  static bool mutex_initialized = false;
  if (!mutex_initialized) {
    mutex_init(&g_update_notification_mutex);
    mutex_initialized = true;
  }
 
  mutex_lock(&g_update_notification_mutex);
 
  if (!notification || notification[0] == '\0') {
    g_update_notification[0] = '\0';
    log_debug("Cleared update notification for splash/status screens");
  } else {
    SAFE_STRNCPY(g_update_notification, notification, sizeof(g_update_notification));
    log_debug("Set update notification for splash/status screens: %s", notification);
  }
 
  mutex_unlock(&g_update_notification_mutex);
}