/**
 * Health Check Library
 *
 * Provides Tauri health check command wrappers and utilities
 * for monitoring the health status of the OpenFang backend.
 */

import { invoke } from '@tauri-apps/api/core';
import { isTauriRuntime } from './tauri-gateway';

// === Types ===

export type HealthStatus = 'healthy' | 'unhealthy' | 'unknown';

export interface HealthCheckResult {
  status: HealthStatus;
  message?: string;
  timestamp: number;
  details?: Record<string, unknown>;
}

export interface OpenFangHealthResponse {
  healthy: boolean;
  message?: string;
  details?: Record<string, unknown>;
}

// === Health Check Functions ===

/**
 * Perform a single health check via Tauri command.
 * Returns a structured result with status, message, and timestamp.
 */
export async function performHealthCheck(): Promise<HealthCheckResult> {
  const timestamp = Date.now();

  if (!isTauriRuntime()) {
    return {
      status: 'unknown',
      message: 'Not running in Tauri environment',
      timestamp,
    };
  }

  try {
    const response = await invoke<OpenFangHealthResponse>('openfang_health_check');

    return {
      status: response.healthy ? 'healthy' : 'unhealthy',
      message: response.message,
      timestamp,
      details: response.details,
    };
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    return {
      status: 'unhealthy',
      message: `Health check failed: ${errorMessage}`,
      timestamp,
    };
  }
}

/**
 * Create a periodic health check scheduler.
 * Returns cleanup function to stop the interval.
 */
export function createHealthCheckScheduler(
  callback: (result: HealthCheckResult) => void,
  intervalMs: number = 30000 // Default: 30 seconds
): () => void {
  let intervalId: ReturnType<typeof setInterval> | null = null;
  let isChecking = false;

  const check = async () => {
    // Prevent overlapping checks
    if (isChecking) return;
    isChecking = true;

    try {
      const result = await performHealthCheck();
      callback(result);
    } catch (error) {
      console.error('[HealthCheck] Scheduled check failed:', error);
      callback({
        status: 'unknown',
        message: error instanceof Error ? error.message : 'Unknown error',
        timestamp: Date.now(),
      });
    } finally {
      isChecking = false;
    }
  };

  // Perform initial check immediately
  check();

  // Schedule periodic checks
  intervalId = setInterval(check, intervalMs);

  // Return cleanup function
  return () => {
    if (intervalId !== null) {
      clearInterval(intervalId);
      intervalId = null;
    }
  };
}

// === Utility Functions ===

/**
 * Get a human-readable label for a health status.
 */
export function getHealthStatusLabel(status: HealthStatus): string {
  switch (status) {
    case 'healthy':
      return '健康';
    case 'unhealthy':
      return '异常';
    case 'unknown':
    default:
      return '未知';
  }
}

/**
 * Format a timestamp for display.
 */
export function formatHealthCheckTime(timestamp: number): string {
  const date = new Date(timestamp);
  return date.toLocaleTimeString('zh-CN', {
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit',
  });
}