/**
 * Health check routes factory
 */
import { Hono } from 'hono';
import type { IServiceContainer } from '@stock-bot/handlers';
import { getLogger } from '@stock-bot/logger';

const logger = getLogger('health-routes');

export function createHealthRoutes(container: IServiceContainer) {
  const healthRoutes = new Hono();

  // Basic health check
  healthRoutes.get('/', c => {
    logger.debug('Basic health check requested');

    const response = {
      status: 'healthy',
      service: 'web-api',
      timestamp: new Date().toISOString(),
    };

    logger.info('Basic health check successful', { status: response.status });
    return c.json(response);
  });

  // Detailed health check with database connectivity
  healthRoutes.get('/detailed', async c => {
    logger.debug('Detailed health check requested');

    const health = {
      status: 'healthy',
      service: 'web-api',
      timestamp: new Date().toISOString(),
      checks: {
        mongodb: { status: 'unknown', message: '' },
        postgresql: { status: 'unknown', message: '' },
      },
    };

    // Check MongoDB
    logger.debug('Checking MongoDB connectivity');
    try {
      const mongoClient = container.mongodb;
      if (mongoClient && mongoClient.connected) {
        // Try a simple operation
        const db = mongoClient.getDatabase();
        await db.admin().ping();
        health.checks.mongodb = { status: 'healthy', message: 'Connected and responsive' };
        logger.debug('MongoDB health check passed');
      } else {
        health.checks.mongodb = { status: 'unhealthy', message: 'Not connected' };
        logger.warn('MongoDB health check failed - not connected');
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
      health.checks.mongodb = {
        status: 'unhealthy',
        message: errorMessage,
      };
      logger.error('MongoDB health check failed', { error: errorMessage });
    }

    // Check PostgreSQL
    logger.debug('Checking PostgreSQL connectivity');
    try {
      const postgresClient = container.postgres;
      if (postgresClient) {
        await postgresClient.query('SELECT 1');
        health.checks.postgresql = { status: 'healthy', message: 'Connected and responsive' };
        logger.debug('PostgreSQL health check passed');
      } else {
        health.checks.postgresql = {
          status: 'unhealthy',
          message: 'PostgreSQL client not available',
        };
        logger.warn('PostgreSQL health check failed - client not available');
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
      health.checks.postgresql = {
        status: 'unhealthy',
        message: errorMessage,
      };
      logger.error('PostgreSQL health check failed', { error: errorMessage });
    }

    // Overall status
    const allHealthy = Object.values(health.checks).every(check => check.status === 'healthy');
    health.status = allHealthy ? 'healthy' : 'unhealthy';

    const statusCode = allHealthy ? 200 : 503;

    if (allHealthy) {
      logger.info('Detailed health check successful - all systems healthy', {
        mongodb: health.checks.mongodb.status,
        postgresql: health.checks.postgresql.status,
      });
    } else {
      logger.warn('Detailed health check failed - some systems unhealthy', {
        mongodb: health.checks.mongodb.status,
        postgresql: health.checks.postgresql.status,
        overallStatus: health.status,
      });
    }

    return c.json(health, statusCode);
  });

  return healthRoutes;
}

// Export legacy routes for backward compatibility during migration
export const healthRoutes = createHealthRoutes({} as IServiceContainer);
