Observability System

/**
 * Custom hook for Sammy authentication
 */
export const useSammyAuth = ({ isInternal = false }: { isInternal: boolean }) => {
  const [jwtToken, setJwtToken] = useState<string | null>(null);
  const [authError, setAuthError] = useState<string | null>(null);
  const [isRefreshing, setIsRefreshing] = useState<boolean>(false);

  const refreshToken = async () => {
    if (isRefreshing) {
      console.log('[Auth] Token refresh already in progress, skipping...');
      return;
    }

    try {
      setIsRefreshing(true);
      console.log('[Auth] Refreshing JWT token...');

      const tokenData = await fetchJWTToken(isInternal);
      setJwtToken(tokenData.token);
      setAuthError(null);

      console.log('[Auth] JWT token refreshed successfully');
    } catch (error) {
      console.error('[Auth] Failed to refresh JWT token:', error);
      setAuthError('Failed to refresh authentication token');
    } finally {
      setIsRefreshing(false);
    }
  };

  const handleTokenExpired = async () => {
    console.log('[Auth] Token expired, attempting to refresh...');
    await refreshToken();
  };

  useEffect(() => {
    const initializeAuth = async () => {
      try {
        const tokenData = await fetchJWTToken(isInternal);
        setJwtToken(tokenData.token);
        setAuthError(null);
      } catch (error) {
        console.error('Failed to initialize JWT token:', error);
        setAuthError('Failed to authenticate with Sammy Agent');
      }
    };

    initializeAuth();
  }, [isInternal]);

  return {
    jwtToken,
    authError,
    isRefreshing,
    refreshToken,
    handleTokenExpired,
  };
};

/**
 * Create Sammy Provider configuration with full observability
 */
export const createSammyProviderConfig = ({
  jwtToken,
  onTokenExpired,
  captureMethod,
  enableWorkerMode = true,
  enableAudioAggregation = true,
  debugMode = false,
}: SammyProviderConfigParams): SammyAgentConfig => {
  
  // Get base URL from environment [[memory:5135225]]
  const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || 'https://api.sammylabs.com';
  
  // Build observability configuration
  const observabilityConfig: ObservabilityConfig = {
    // Core settings
    enabled: true,
    logToConsole: debugMode || process.env.NODE_ENV === 'development',
    
    // Privacy settings
    includeSystemPrompt: true,   // Include prompts for debugging
    includeAudioData: false,      // Don't include raw audio (large)
    includeImageData: true,       // Include screenshots for visual context
    
    // Worker mode configuration
    useWorker: enableWorkerMode,
    workerConfig: enableWorkerMode
      ? {
          batchSize: 50,          // Events per batch
          batchIntervalMs: 5000,  // 5 seconds
        }
      : undefined,
    
    // Filter noisy events to reduce log spam
    disableEventTypes: [
      'audio.send' as TraceEventType,
      'audio.receive' as TraceEventType,
    ],
    
    // Metadata for all events
    metadata: {
      environment: process.env.NODE_ENV || 'development',
      timestamp: new Date().toISOString(),
      version: process.env.NEXT_PUBLIC_APP_VERSION || '1.0.0',
      userAgent: typeof window !== 'undefined' ? window.navigator.userAgent : 'server',
      deployment: process.env.NEXT_PUBLIC_DEPLOYMENT || 'unknown',
    },
    
    // Audio aggregation configuration
    audioAggregation: enableAudioAggregation
      ? {
          flushIntervalMs: 30000, // 30 seconds
        }
      : undefined,
  };
  
  return {
    // Basic configuration
    debugLogs: debugMode,
    captureMethod,
    model: 'models/gemini-2.5-flash-preview-native-audio-dialog',
    
    // Authentication with base URL [[memory:5135225]]
    auth: {
      token: jwtToken,
      baseUrl: baseUrl,  // All endpoints derived from this
      onTokenExpired,
    },
    
    // Apply observability configuration
    observability: observabilityConfig,
  };
};

/**
 * Example usage in a React component
 */
export const SammyProviderWrapper: React.FC<{ children: React.ReactNode }> = ({ 
  children 
}) => {
  const { jwtToken, handleTokenExpired } = useSammyAuth({ isInternal: false });
  
  if (!jwtToken) {
    return <div>Loading authentication...</div>;
  }
  
  const config = createSammyProviderConfig({
    jwtToken,
    onTokenExpired: handleTokenExpired,
    captureMethod: 'render',
    enableWorkerMode: true,      // Use worker for performance
    enableAudioAggregation: true, // Enable audio tracking
    debugMode: false,             // Set to true for debugging
  });
  
  return (
    <SammyAgentProvider config={config}>
      {children}
    </SammyAgentProvider>
  );
};