import { prisma } from '../models';
import { LicenseStatus, PitStatus } from '@prisma/client';
import { NotificationService } from '../services/notification.service';
import { computeDaysRemaining } from '../lib/days-remaining';

export async function cascadeDisablePitsForLicense(licenseId: string): Promise<void> {
  await prisma.pit.updateMany({
    where: { license_id: licenseId, deleted_at: null },
    data: { status: PitStatus.DISABLED, operational_access: false },
  });
}

export async function runLicenseExpiryCheck(): Promise<{ warnings: number; expired: number }> {
  const today = new Date();
  const thirtyDaysFromNow = new Date(today);
  thirtyDaysFromNow.setDate(today.getDate() + 30);

  let warnings = 0;
  let expiredCount = 0;

  const expiringSoon = await prisma.license.findMany({
    where: {
      expiry_date: { lte: thirtyDaysFromNow, gt: today },
      status: LicenseStatus.ACTIVE,
      deleted_at: null,
    },
  });

  for (const license of expiringSoon) {
    const daysRemaining = computeDaysRemaining(license.expiry_date, today);
    if (daysRemaining > 0 && daysRemaining <= 30) {
      await NotificationService.sendLicenseExpiryWarning(license, daysRemaining);
      await prisma.license.update({
        where: { id: license.id },
        data: { status: LicenseStatus.PENDING_RENEWAL, days_remaining: daysRemaining },
      });
      warnings++;
    }
  }

  const expired = await prisma.license.findMany({
    where: {
      expiry_date: { lt: today },
      status: { in: [LicenseStatus.ACTIVE, LicenseStatus.PENDING_RENEWAL] },
      deleted_at: null,
    },
    include: { pits: true },
  });

  for (const license of expired) {
    await prisma.$transaction(async (tx) => {
      await tx.license.update({
        where: { id: license.id },
        data: { status: LicenseStatus.EXPIRED, days_remaining: 0 },
      });
      await tx.pit.updateMany({
        where: { license_id: license.id, deleted_at: null },
        data: { status: PitStatus.DISABLED, operational_access: false },
      });
      await tx.killSwitchLog.create({
        data: {
          license_id: license.id,
          license_number: license.license_number,
          trigger_date: new Date(),
          days_remaining: 0,
          action_taken: 'ACCESS_REVOKED',
          notified_md: true,
          notified_legal: true,
        },
      });
    });
    await NotificationService.sendLicenseExpiredAlert(license);
    expiredCount++;
  }

  return { warnings, expired: expiredCount };
}

export async function onLicenseSuspendedOrExpired(licenseId: string, status: LicenseStatus): Promise<void> {
  if (status === LicenseStatus.EXPIRED || status === LicenseStatus.SUSPENDED) {
    await cascadeDisablePitsForLicense(licenseId);
  }
}