import { protectedProcedure, publicProcedure } from "../_core/trpc.ts";
import { z } from "zod";
import { sendCertificationEmail, sendCertificationExpirationReminder, testEmailConfiguration } from "../_core/certificationEmailService.ts";
import { TRPCError } from "@trpc/server";

/**
 * Test email configuration
 */
export const testEmailConfigProcedure = protectedProcedure.mutation(async ({ ctx }) => {
  // Only admins can test email config
  if (ctx.user?.role !== "admin") {
    throw new TRPCError({ code: "FORBIDDEN" });
  }

  try {
    const isValid = await testEmailConfiguration();
    return {
      success: isValid,
      message: isValid ? "Email configuration is valid" : "Email configuration failed",
    };
  } catch (error) {
    throw new TRPCError({
      code: "INTERNAL_SERVER_ERROR",
      message: error instanceof Error ? error.message : "Email test failed",
    });
  }
});

/**
 * Send test certification email
 */
export const sendTestCertificationEmailProcedure = protectedProcedure
  .input(
    z.object({
      adminEmail: z.string().email(),
      adminName: z.string(),
    })
  )
  .mutation(async ({ input, ctx }) => {
    // Only admins can send test emails
    if (ctx.user?.role !== "admin") {
      throw new TRPCError({ code: "FORBIDDEN" });
    }

    try {
      const result = await sendCertificationEmail({
        adminName: input.adminName,
        adminEmail: input.adminEmail,
        certificationTitle: "CoinKrazy Admin Certification (Test)",
        certificationLevel: "advanced",
        certificationNumber: `TEST-${Date.now()}`,
        issueDate: new Date(),
        expirationDate: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000),
        verificationUrl: `${process.env.VITE_APP_URL || "https://playplaycoinkrazy.com"}/verify-certificate/test-${Date.now()}`,
      });

      if (!result.success) {
        throw new TRPCError({
          code: "INTERNAL_SERVER_ERROR",
          message: result.error || "Failed to send email",
        });
      }

      return {
        success: true,
        messageId: result.messageId,
        message: "Test email sent successfully",
      };
    } catch (error) {
      throw new TRPCError({
        code: "INTERNAL_SERVER_ERROR",
        message: error instanceof Error ? error.message : "Failed to send test email",
      });
    }
  });

/**
 * Send certification email
 */
export const sendCertificationEmailProcedure = protectedProcedure
  .input(
    z.object({
      adminId: z.string(),
      adminName: z.string(),
      adminEmail: z.string().email(),
      certificationTitle: z.string(),
      certificationLevel: z.enum(["basic", "intermediate", "advanced"]),
      certificationNumber: z.string(),
      issueDate: z.date(),
      expirationDate: z.date(),
    })
  )
  .mutation(async ({ input, ctx }) => {
    // Only admins can send certification emails
    if (ctx.user?.role !== "admin") {
      throw new TRPCError({ code: "FORBIDDEN" });
    }

    try {
      const verificationUrl = `${process.env.VITE_APP_URL || "https://playplaycoinkrazy.com"}/verify-certificate/${input.certificationNumber}`;

      const result = await sendCertificationEmail({
        adminName: input.adminName,
        adminEmail: input.adminEmail,
        certificationTitle: input.certificationTitle,
        certificationLevel: input.certificationLevel,
        certificationNumber: input.certificationNumber,
        issueDate: input.issueDate,
        expirationDate: input.expirationDate,
        verificationUrl,
      });

      if (!result.success) {
        throw new TRPCError({
          code: "INTERNAL_SERVER_ERROR",
          message: result.error || "Failed to send certification email",
        });
      }

      return {
        success: true,
        messageId: result.messageId,
        message: "Certification email sent successfully",
      };
    } catch (error) {
      throw new TRPCError({
        code: "INTERNAL_SERVER_ERROR",
        message: error instanceof Error ? error.message : "Failed to send certification email",
      });
    }
  });

/**
 * Send expiration reminder email
 */
export const sendExpirationReminderProcedure = protectedProcedure
  .input(
    z.object({
      adminName: z.string(),
      adminEmail: z.string().email(),
      certificationTitle: z.string(),
      expirationDate: z.date(),
      certificationId: z.string(),
    })
  )
  .mutation(async ({ input, ctx }) => {
    // Only admins can send reminder emails
    if (ctx.user?.role !== "admin") {
      throw new TRPCError({ code: "FORBIDDEN" });
    }

    try {
      const verificationUrl = `${process.env.VITE_APP_URL || "https://playplaycoinkrazy.com"}/verify-certificate/${input.certificationId}`;

      const result = await sendCertificationExpirationReminder(
        input.adminName,
        input.adminEmail,
        input.certificationTitle,
        input.expirationDate,
        verificationUrl
      );

      if (!result.success) {
        throw new TRPCError({
          code: "INTERNAL_SERVER_ERROR",
          message: result.error || "Failed to send reminder email",
        });
      }

      return {
        success: true,
        messageId: result.messageId,
        message: "Expiration reminder sent successfully",
      };
    } catch (error) {
      throw new TRPCError({
        code: "INTERNAL_SERVER_ERROR",
        message: error instanceof Error ? error.message : "Failed to send reminder email",
      });
    }
  });

/**
 * Get email configuration status
 */
export const getEmailConfigStatusProcedure = protectedProcedure.query(async ({ ctx }) => {
  // Only admins can view email config
  if (ctx.user?.role !== "admin") {
    throw new TRPCError({ code: "FORBIDDEN" });
  }

  const smtpConfigured =
    !!process.env.SMTP_HOST &&
    !!process.env.SMTP_PORT &&
    !!process.env.SMTP_USER &&
    !!process.env.SMTP_PASSWORD;

  return {
    smtpConfigured,
    smtpHost: process.env.SMTP_HOST || "Not configured",
    smtpPort: process.env.SMTP_PORT || "Not configured",
    smtpUser: process.env.SMTP_USER ? `${process.env.SMTP_USER.substring(0, 3)}***` : "Not configured",
    smtpFrom: process.env.SMTP_FROM || "noreply@playplaycoinkrazy.com",
    appUrl: process.env.VITE_APP_URL || "https://playplaycoinkrazy.com",
  };
});