import express, { Request, Response } from 'express';
import { Pool } from 'pg';
import { SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
import AWSSecretsManagerCache from 'aws-secrets-cache';
import type { AWSSecretsConfig, Logger, UpdateEvent } from 'aws-secrets-cache';
import winston from 'winston';

const app = express();
const port = 3000;

// Optional: Create a Winston logger instance
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.printf(({ level, message, timestamp }) => {
      return `${timestamp} [${level.toUpperCase()}]: ${message}`;
    })
  ),
  transports: [new winston.transports.Console()],
}) satisfies Logger;

// Optional: custom AWS SecretsManagerClient with specific region
const customClient = new SecretsManagerClient({ region: 'us-west-2' });

const secretsConfig: AWSSecretsConfig = {
  secretMappings: { dbCredentials: 'arn:aws:secretsmanager:us-west-2:123456789012:secret:prod/postgres-credentials-xyz' },
  region: 'us-west-2',
  refreshInterval: 3600000,
  logger: logger,  
  client: customClient,
};

const secretsManager = new AWSSecretsManagerCache(secretsConfig);

let pgPool: Pool | undefined;

interface DbCredentials {
  username: string;
  password: string;
  host: string;
  dbname: string;
  port: number;
}

async function initDbConnection() {
  try {
    const dbCredentials = secretsManager.getSecret('dbCredentials') as DbCredentials | undefined;
    if (!dbCredentials) throw new Error('No DB credentials');

    if (pgPool) await pgPool.end();

    pgPool = new Pool({
      user: dbCredentials.username,
      host: dbCredentials.host,
      database: dbCredentials.dbname,
      password: dbCredentials.password,
      port: dbCredentials.port,
    });

    const client = await pgPool.connect();
    logger.info('DB connected');
    client.release();
  } catch (error) {
    logger.error('DB init failed:', error);
  }
}

secretsManager.on('update', async (event: UpdateEvent) => {
  if (event.userId === 'dbCredentials') {
    await initDbConnection();
  }
});

secretsManager.on('error', (data: { userId: string; error: Error }) => {
  logger.error(`Secrets error for ${data.userId}: ${data.error.message}`);
});

app.get('/users', async (_req: Request, res: Response) => {
  try {
    if (!pgPool) throw new Error('Database not initialized');
    const result = await pgPool.query('SELECT * FROM users LIMIT 10');
    res.json(result.rows);
  } catch (error) {
    logger.error('Query failed:', error);
    res.status(500).json({ error: 'Server error' });
  }
});

(async () => {
  await secretsManager.initialize();
  await initDbConnection();
  app.listen(port, () => logger.info(`Server on port ${port}`));
})();