amical/apps/desktop/src/main/logger.ts

import dotenv from 'dotenv';
dotenv.config();

import log from 'electron-log';
import { app } from 'electron';
import path from 'node:path';

// Configure electron-log immediately when module is imported
const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;

// Configure main logger - check for LOG_LEVEL override
const envLogLevel = process.env.LOG_LEVEL as 'error' | 'warn' | 'info' | 'debug' | undefined;
const defaultFileLevel: 'debug' | 'info' = isDev ? 'debug' : 'info';
const defaultConsoleLevel: 'debug' | 'warn' = isDev ? 'debug' : 'warn';

log.transports.file.level = envLogLevel || defaultFileLevel;
log.transports.console.level = envLogLevel || defaultConsoleLevel;

// Configure file transport
log.transports.file.maxSize = 10 * 1024 * 1024; // 10MB
log.transports.file.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [{scope}] {text}';

// Set custom log file path
const logPath = isDev
  ? path.join(app.getPath('userData'), 'logs', 'amical-dev.log')
  : path.join(app.getPath('logs'), 'amical.log');

log.transports.file.resolvePathFn = () => logPath;

// Configure console transport for better development experience
if (isDev) {
  log.transports.console.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [{scope}] {text}';
  log.transports.console.useStyles = true;
} else {
  log.transports.console.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [{scope}] {text}';
  log.transports.console.useStyles = false;
}

// Configure remote transport for production error reporting (optional)
if (!isDev) {
  // You can configure remote logging here if needed
  // log.transports.remote.level = 'error';
  // log.transports.remote.url = 'your-logging-service-url';
}

// -----------------------------------------------
// Debug-scope configuration
// -----------------------------------------------
// `LOG_DEBUG_SCOPES` can be a comma-separated list of scope names (main,ai,swift)
// or regex patterns wrapped in slashes (e.g. /ai.*/, /.*/)
const rawDebugScopes = (process.env.LOG_DEBUG_SCOPES ?? '')
  .split(',')
  .map((s) => s.trim())
  .filter(Boolean);

// Utility: escape regex special chars for exact-match tokens
function escapeRegExp(str: string) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

const debugScopePatterns: RegExp[] = rawDebugScopes.map((token) => {
  if (token.startsWith('/') && token.endsWith('/') && token.length > 1) {
    // Regex pattern (strip the leading & trailing slashes)
    const pattern = token.slice(1, -1);
    try {
      return new RegExp(pattern, 'i');
    } catch {
      // Fall through to exact match if regex is invalid
    }
  }
  // Treat as exact scope name
  return new RegExp(`^${escapeRegExp(token)}$`, 'i');
});

export function isScopeDebug(scope: string): boolean {
  return debugScopePatterns.some((re) => re.test(scope));
}

// Set up hooks to handle scope-based debug filtering
if (debugScopePatterns.length > 0) {
  log.hooks.push((message) => {
    // Only filter debug messages
    if (message.level !== 'debug') return message;

    // Check if this scope should have debug enabled
    const scope = message.scope;
    if (scope && isScopeDebug(scope)) {
      return message; // Allow debug messages for this scope
    }

    // Block debug messages for scopes not in the debug list
    return false;
  });
}
// -----------------------------------------------

// Helper to create a scoped logger
log.scope.labelPadding = false;
function createLoggerForScope(scope: string) {
  return log.scope(scope);
}

// Create scoped loggers for different modules
export const logger = {
  main: createLoggerForScope('main'),
  ipc: createLoggerForScope('ipc'),
  renderer: createLoggerForScope('renderer'),
  network: createLoggerForScope('network'),
  audio: createLoggerForScope('audio'),
  ai: createLoggerForScope('ai'),
  swift: createLoggerForScope('swift'),
  ui: createLoggerForScope('ui'),
  db: createLoggerForScope('db'),
};

// Log startup information
logger.main.info('Logger initialized', {
  isDev,
  fileLogLevel: log.transports.file.level,
  consoleLogLevel: log.transports.console.level,
  envLogLevel: envLogLevel || 'not set',
  logPath,
  version: app.getVersion(),
  platform: process.platform,
  arch: process.arch,
});

// Export the main logger instance for direct use
export { log };

// Utility function to create custom scoped loggers
export function createScopedLogger(scope: string) {
  return createLoggerForScope(scope);
}

// Error handling utilities
export function logError(error: Error, context?: string, metadata?: Record<string, any>) {
  const errorInfo = {
    message: error.message,
    stack: error.stack,
    name: error.name,
    context,
    ...metadata,
  };

  logger?.main.error('Error occurred:', errorInfo);
}

export function logPerformance(
  operation: string,
  startTime: number,
  metadata?: Record<string, any>
) {
  const duration = Date.now() - startTime;
  logger?.main.info(`Performance: ${operation}`, {
    duration: `${duration}ms`,
    ...metadata,
  });
}

// Development helpers
export function logDebugInfo(component: string, data: any) {
  if (process.env.NODE_ENV === 'development' || !app.isPackaged) {
    logger?.main.debug(`[${component}]`, data);
  }
}