// lib/notification-store.ts
interface Notification {
  id: string;
  type: 'error' | 'warning' | 'info';
  title: string;
  message: string;
  timestamp: number;
  read: boolean;
  source: string; // misal: "health-check", "system", "user"
}

class NotificationStore {
  private notifications: Notification[] = [];
  private subscribers: Set<(n: Notification[]) => void> = new Set();
  private persistPath = '/data/notifications.json';

  constructor() {
    this.load();
  }

  // Load dari file saat startup
  private async load() {
    try {
      const fs = await import('fs/promises');
      const data = await fs.readFile(this.persistPath, 'utf-8');
      this.notifications = JSON.parse(data);
    } catch {
      this.notifications = [];
    }
  }

  // Simpan ke file setiap ada perubahan
  private async persist() {
    try {
      const fs = await import('fs/promises');
      await fs.writeFile(
        this.persistPath,
        JSON.stringify(this.notifications, null, 2)
      );
    } catch (err) {
      console.error('[NotificationStore] Persist failed:', err);
    }
  }

  // Tambah notifikasi baru + broadcast
  async add(notification: Omit<Notification, 'id' | 'timestamp' | 'read'>) {
    const entry: Notification = {
      ...notification,
      id: crypto.randomUUID(),
      timestamp: Date.now(),
      read: false,
    };
    this.notifications.unshift(entry);
    // Keep max 200 notifikasi biar nggak bengkak
    this.notifications = this.notifications.slice(0, 200);
    await this.persist();
    this.broadcast();
    return entry;
  }

  // Mark single / all as read
  async markRead(id?: string) {
    if (id) {
      const n = this.notifications.find(n => n.id === id);
      if (n) n.read = true;
    } else {
      this.notifications.forEach(n => (n.read = true));
    }
    await this.persist();
    this.broadcast();
  }

  // Dapatkan unread count
  getUnreadCount() {
    return this.notifications.filter(n => !n.read).length;
  }

  // Dapatkan semua notifikasi (with pagination)
  getAll(limit = 50, offset = 0) {
    return this.notifications.slice(offset, offset + limit);
  }

  // Subscribe untuk real-time updates (SSE)
  subscribe(callback: (n: Notification[]) => void) {
    this.subscribers.add(callback);
    callback(this.notifications); // send current state immediately
    return () => this.subscribers.delete(callback);
  }

  private broadcast() {
    const snapshot = [...this.notifications];
    this.subscribers.forEach(cb => cb(snapshot));
  }
}

// Singleton — satu instance per server process
export const notificationStore = new NotificationStore();

// lib/health-checker.ts
import cron from 'node-cron';
import { notificationStore } from './notification-store';

interface HealthTarget {
  name: string;
  url: string;
  expectedStatus: number;
  timeoutMs?: number;
}

const targets: HealthTarget[] = [
  { name: 'API Gateway', url: 'https://api.example.com/health', expectedStatus: 200, timeoutMs: 5000 },
  { name: 'Database Proxy', url: 'https://db-proxy.example.com/ping', expectedStatus: 200, timeoutMs: 3000 },
  { name: 'CDN Origin', url: 'https://origin.example.com/alive', expectedStatus: 200, timeoutMs: 8000 },
];

async function checkTarget(target: HealthTarget): Promise<boolean> {
  try {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), target.timeoutMs ?? 5000);
    const res = await fetch(target.url, { signal: controller.signal });
    clearTimeout(timeout);
    return res.status === target.expectedStatus;
  } catch {
    return false;
  }
}

let previousFailures = new Set<string>();

async function runHealthChecks() {
  for (const target of targets) {
    const healthy = await checkTarget(target);
    if (!healthy && !previousFailures.has(target.name)) {
      // Baru gagal → kirim notifikasi
      await notificationStore.add({
        type: 'error',
        title: `${target.name} Down`,
        message: `Health check gagal untuk ${target.name}. Endpoint: ${target.url}`,
        source: 'health-check',
      });
      previousFailures.add(target.name);
    } else if (healthy && previousFailures.has(target.name)) {
      // Recovery → kirim info
      await notificationStore.add({
        type: 'info',
        title: `${target.name} Recovered`,
        message: `${target.name} kembali normal.`,
        source: 'health-check',
      });
      previousFailures.delete(target.name);
    }
  }
}

// Jalankan setiap 5 menit
export function startHealthCron() {
  // Initial check saat startup
  runHealthChecks();
  cron.schedule('*/5 * * * *', runHealthChecks);
  console.log('[HealthChecker] Cron started (every 5 minutes)');
}

// app/api/notifications/route.ts
import { notificationStore } from '@/lib/notification-store';
import { NextRequest } from 'next/server';

export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url);
  const format = searchParams.get('format');

  // SSE endpoint untuk real-time
  if (format === 'sse') {
    const encoder = new TextEncoder();
    const stream = new ReadableStream({
      start(controller) {
        const unsubscribe = notificationStore.subscribe((notifications) => {
          const data = JSON.stringify({
            count: notificationStore.getUnreadCount(),
            notifications: notifications.slice(0, 10),
          });
          controller.enqueue(encoder.encode(`data: ${data}\n\n`));
        });
        // Cleanup saat client disconnect
        request.signal.addEventListener('abort', () => {
          unsubscribe();
          controller.close();
        });
      },
    });
    return new Response(stream, {
      headers: {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive',
      },
    });
  }

  // Normal REST endpoint (fallback / polling)
  const limit = parseInt(searchParams.get('limit') ?? '50');
  const offset = parseInt(searchParams.get('offset') ?? '0');
  return Response.json({
    count: notificationStore.getUnreadCount(),
    notifications: notificationStore.getAll(limit, offset),
  });
}

export async function PATCH(request: NextRequest) {
  const body = await request.json();
  await notificationStore.markRead(body.id);
  return Response.json({ success: true });
}

// app/layout.tsx
import { startHealthCron } from '@/lib/health-checker';

// Next.js 14+: pakai instrumentation hook
// instrumentation.ts di root project
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { startHealthCron } = await import('@/lib/health-checker');
    startHealthCron();
  }
}