import { query } from '../db';

const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN || '';
const TELEGRAM_API = `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}`;

interface BriefSection {
  title: string;
  content: string;
}

export interface BriefPayload {
  sections: BriefSection[];
}

async function sendTelegram(chatId: number, text: string, parseMode: string = 'HTML'): Promise<boolean> {
  try {
    const resp = await fetch(`${TELEGRAM_API}/sendMessage`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        chat_id: chatId,
        text,
        parse_mode: parseMode,
        disable_web_page_preview: true,
      }),
    });
    if (!resp.ok) {
      console.error(`Telegram send failed for ${chatId}:`, await resp.text());
      return false;
    }
    return true;
  } catch (err) {
    console.error(`Telegram send error for ${chatId}:`, err);
    return false;
  }
}

const SEVERITY_EMOJI: Record<string, string> = {
  info: 'ℹ️',
  warn: '⚠️',
  critical: '🚨',
};

const EVENT_DEDUPE_WINDOW_MINUTES: Record<'info' | 'warn' | 'critical', number> = {
  info: 15,
  warn: 30,
  critical: 60,
};

class SportsClawAlerter {
  private async shouldSuppressDuplicateEvent(
    eventType: string,
    severity: 'info' | 'warn' | 'critical',
    source: string,
    message: string
  ): Promise<boolean> {
    const windowMinutes = EVENT_DEDUPE_WINDOW_MINUTES[severity];
    const result = await query(
      `SELECT 1
       FROM sc_system_events
       WHERE event_type = $1
         AND severity = $2
         AND source = $3
         AND message = $4
         AND created_at > NOW() - ($5::text || ' minutes')::interval
       LIMIT 1`,
      [eventType, severity, source, message, String(windowMinutes)]
    );

    return result.rows.length > 0;
  }

  async alertAdmins(level: 'info' | 'warn' | 'critical', message: string, details?: object): Promise<void> {
    // Write to event bus first
    await query(
      `INSERT INTO sc_system_events (event_type, severity, source, message, details)
       VALUES ('alert', $1, 'alerter', $2, $3)`,
      [level, message, details ? JSON.stringify(details) : null]
    );

    // Get admin telegram chat IDs
    const result = await query(
      `SELECT telegram_chat_id FROM sc_users WHERE role = 'admin' AND telegram_chat_id IS NOT NULL`
    );

    const emoji = SEVERITY_EMOJI[level] || '';
    const text = `${emoji} <b>SportsClaw ${level.toUpperCase()}</b>\n\n${message}`;

    for (const row of result.rows) {
      await sendTelegram(row.telegram_chat_id, text);
    }
  }

  async alertUser(chatId: number, message: string): Promise<boolean> {
    return sendTelegram(chatId, message);
  }

  async sendDailyBrief(chatId: number, briefData: BriefPayload): Promise<boolean> {
    let text = '📊 <b>SportsClaw Morning Brief</b>\n\n';
    for (const section of briefData.sections) {
      text += `<b>${section.title}</b>\n${section.content}\n\n`;
    }
    return sendTelegram(chatId, text);
  }

  async logEvent(
    eventType: string,
    severity: 'info' | 'warn' | 'critical',
    source: string,
    message: string,
    details?: object
  ): Promise<void> {
    if (await this.shouldSuppressDuplicateEvent(eventType, severity, source, message)) {
      return;
    }

    await query(
      `INSERT INTO sc_system_events (event_type, severity, source, message, details)
       VALUES ($1, $2, $3, $4, $5)`,
      [eventType, severity, source, message, details ? JSON.stringify(details) : null]
    );

    // Auto-alert admins on critical events
    if (severity === 'critical') {
      await this.alertAdmins(severity, `[${source}] ${message}`, details);
    }
  }

  async resolveEvent(eventId: string): Promise<void> {
    await query(
      `UPDATE sc_system_events SET resolved = TRUE, resolved_at = NOW() WHERE id = $1`,
      [eventId]
    );
  }
}

export const alerter = new SportsClawAlerter();