mirror/main.c

Go to the documentation of this file.

 
#include "main.h"
#include "session/client_like.h"
#include "session/capture.h"
#include "session/display.h"
#include "session/render.h"
#include "session/keyboard_handler.h"
#include <ascii-chat/log/log.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/platform/abstraction.h>
#include <ascii-chat/util/time.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
 
static inline void js_mirror_log(const char *msg) {
  if (msg) {
    char buffer[512];
    snprintf(buffer, sizeof(buffer), "[MIRROR-START] %s\n", msg);
    write(STDERR_FILENO, buffer, strlen(buffer));
  }
}
 
/* ============================================================================
 * Mode-Specific Keyboard Handler
 * ============================================================================ */
 
static void mirror_keyboard_handler(session_capture_ctx_t *capture, int key, void *user_data) {
  session_display_ctx_t *display = (session_display_ctx_t *)user_data;
  session_handle_keyboard_input(capture, display, (keyboard_key_t)key);
}
 
/* ============================================================================
 * Mode-Specific Main Loop
 * ============================================================================ */
 
static asciichat_error_t mirror_run(session_capture_ctx_t *capture, session_display_ctx_t *display, void *user_data) {
  (void)user_data; // Unused
 
  js_mirror_log("mirror_run: ENTRY");
  log_info("mirror_run: CALLED - capture=%p display=%p", (void *)capture, (void *)display);
 
  // Get the render loop's should_exit callback from session_client_like
  bool (*render_should_exit)(void *) = session_client_like_get_render_should_exit();
  if (!render_should_exit) {
    log_error("mirror_run: render_should_exit callback not initialized");
    return SET_ERRNO(ERROR_INVALID_STATE, "Render should_exit callback not initialized");
  }
 
  log_info("mirror_run: Calling session_render_loop in synchronous mode");
  // Run the unified render loop with keyboard support using synchronous mode
  // Pass capture context directly (not as callbacks) for proper frame capture
  asciichat_error_t result = session_render_loop(capture, // Capture context (synchronous mode)
                                                 display,
                                                 render_should_exit,      // Exit check (checks global + custom)
                                                 NULL,                    // No capture callback (using capture context)
                                                 NULL,                    // No sleep callback (built-in FPS limiting)
                                                 mirror_keyboard_handler, // Keyboard handler
                                                 display); // Pass display as user_data for help screen toggle
  log_info("mirror_run: session_render_loop returned with result=%d", result);
  return result;
}
 
#ifndef NDEBUG
/* ============================================================================
 * Deadlock Test Code
 * ============================================================================ */
 
static mutex_t g_test_mutex_a, g_test_mutex_b, g_test_mutex_c;
 
// 2-way deadlock: Thread A ↔ Thread B
static void *test_thread_a(void *arg) {
  (void)arg;
  log_info("TEST DEADLOCK: Thread A acquiring mutex_a");
  mutex_lock(&g_test_mutex_a);
  log_info("TEST DEADLOCK: Thread A got mutex_a (0x%lx), sleeping 1s", (uintptr_t)&g_test_mutex_a);
  sleep(1);
  log_info("TEST DEADLOCK: Thread A trying to acquire mutex_b (0x%lx) - will deadlock", (uintptr_t)&g_test_mutex_b);
  mutex_lock(&g_test_mutex_b); // Will block forever
  log_info("TEST DEADLOCK: Thread A got both (should never reach)");
  mutex_unlock(&g_test_mutex_b);
  mutex_unlock(&g_test_mutex_a);
  return NULL;
}
 
static void *test_thread_b(void *arg) {
  (void)arg;
  usleep(500000); // Let thread A go first (500ms)
  log_info("TEST DEADLOCK: Thread B acquiring mutex_b");
  mutex_lock(&g_test_mutex_b);
  log_info("TEST DEADLOCK: Thread B got mutex_b (0x%lx), sleeping 500ms", (uintptr_t)&g_test_mutex_b);
  usleep(500000);
  log_info("TEST DEADLOCK: Thread B trying to acquire mutex_a (0x%lx) - will deadlock", (uintptr_t)&g_test_mutex_a);
  mutex_lock(&g_test_mutex_a); // Will block forever
  log_info("TEST DEADLOCK: Thread B got both (should never reach)");
  mutex_unlock(&g_test_mutex_a);
  mutex_unlock(&g_test_mutex_b);
  return NULL;
}
 
// 3-way deadlock: Thread A → B → C → A (only used when ASCII_CHAT_TEST_DEADLOCK_3WAY is set)
static void *test_thread_a_3way(void *arg) {
  (void)arg;
  log_info("TEST DEADLOCK 3-WAY: Thread A acquiring mutex_a");
  mutex_lock(&g_test_mutex_a);
  log_info("TEST DEADLOCK 3-WAY: Thread A got mutex_a (0x%lx)", (uintptr_t)&g_test_mutex_a);
  sleep(1);
  log_info("TEST DEADLOCK 3-WAY: Thread A waiting for mutex_b (0x%lx) - will form cycle", (uintptr_t)&g_test_mutex_b);
  mutex_lock(&g_test_mutex_b);
  mutex_unlock(&g_test_mutex_b);
  mutex_unlock(&g_test_mutex_a);
  return NULL;
}
 
static void *test_thread_b_3way(void *arg) {
  (void)arg;
  usleep(300000); // Let thread A acquire mutex_a first
  log_info("TEST DEADLOCK 3-WAY: Thread B acquiring mutex_b");
  mutex_lock(&g_test_mutex_b);
  log_info("TEST DEADLOCK 3-WAY: Thread B got mutex_b (0x%lx)", (uintptr_t)&g_test_mutex_b);
  usleep(300000);
  log_info("TEST DEADLOCK 3-WAY: Thread B waiting for mutex_c (0x%lx) - will form cycle", (uintptr_t)&g_test_mutex_c);
  mutex_lock(&g_test_mutex_c);
  mutex_unlock(&g_test_mutex_c);
  mutex_unlock(&g_test_mutex_b);
  return NULL;
}
 
static void *test_thread_c_3way(void *arg) {
  (void)arg;
  usleep(600000); // Let A and B start
  log_info("TEST DEADLOCK 3-WAY: Thread C acquiring mutex_c");
  mutex_lock(&g_test_mutex_c);
  log_info("TEST DEADLOCK 3-WAY: Thread C got mutex_c (0x%lx)", (uintptr_t)&g_test_mutex_c);
  usleep(300000);
  log_info("TEST DEADLOCK 3-WAY: Thread C waiting for mutex_a (0x%lx) - CYCLE COMPLETE", (uintptr_t)&g_test_mutex_a);
  mutex_lock(&g_test_mutex_a); // Closes the cycle: C waits for A
  mutex_unlock(&g_test_mutex_a);
  mutex_unlock(&g_test_mutex_c);
  return NULL;
}
#endif // !NDEBUG
 
/* ============================================================================
 * Mirror Mode Entry Point
 * ============================================================================ */
 
int mirror_main(void) {
  log_info("[MIRROR] main ENTRY");
 
  // Configure mode-specific session settings
  session_client_like_config_t config = {
      .run_fn = mirror_run,
      .run_user_data = NULL,
      .kind = SESSION_CLIENT_LIKE_KIND_MIRROR,
      .keyboard_handler = mirror_keyboard_handler,
      .print_newline_on_tty_exit = true, // Mirror prints newline to separate frame from prompt
  };
 
  // Run shared initialization/teardown with mode-specific loop
  asciichat_error_t result = session_client_like_run(&config);
  log_info("mirror_main: session_client_like_run returned with result=%d", result);
 
  if (result != ASCIICHAT_OK) {
    log_error("Mirror mode failed with error code: %d", result);
  }
 
  return (int)result;
}