import { router, protectedProcedure, adminProcedure } from "../_core/trpc.ts";
import { z } from 'zod';
import {
  sendWelcomeEmail,
  sendSecurityTipsEmail,
  sendRoleTrainingEmail,
} from "../_core/welcomeEmail.ts";
import { emitAlert } from "../_core/alertEmitter.ts";
import { logActivity } from "../_core/activityLogger.ts";
import { TRPCError } from '@trpc/server';

export const adminWelcomeRouter = router({
  /**
   * Send welcome email to new admin
   * Super admin only
   */
  sendWelcomeEmail: adminProcedure
    .input(
      z.object({
        adminId: z.string(),
        adminName: z.string(),
        adminEmail: z.string().email(),
        role: z.string(),
        onboardingUrl: z.string().url(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        const result = await sendWelcomeEmail({
          adminName: input.adminName,
          adminEmail: input.adminEmail,
          role: input.role,
          onboardingUrl: input.onboardingUrl,
          supportEmail: 'support@playcoinkrazy.com',
          companyName: 'CoinKrazy',
        });

        // Log activity
        await logActivity({
          adminId: ctx.user.id,
          action: 'WELCOME_EMAIL_SENT',
          resourceType: 'admin',
          resourceId: input.adminId,
          details: {
            recipientEmail: input.adminEmail,
            recipientRole: input.role,
            status: result ? 'success' : 'failed',
          },
        });

        // Emit alert
        if (result) {
          await emitAlert({
            type: 'admin_onboarded',
            title: 'New Admin Onboarded',
            message: `Welcome email sent to ${input.adminName} (${input.adminEmail})`,
            severity: 'info',
            resourceType: 'admin',
            resourceId: input.adminId,
          });
        }

        return { success: result };
      } catch (error) {
        console.error('[AdminWelcome] Error sending welcome email:', error);
        throw new Error('Failed to send welcome email');
      }
    }),

  /**
   * Send security tips email
   */
  sendSecurityTips: adminProcedure
    .input(
      z.object({
        adminId: z.string(),
        adminName: z.string(),
        adminEmail: z.string().email(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        const result = await sendSecurityTipsEmail(input.adminEmail, input.adminName);

        await logActivity({
          adminId: ctx.user.id,
          action: 'SECURITY_EMAIL_SENT',
          resourceType: 'admin',
          resourceId: input.adminId,
          details: {
            recipientEmail: input.adminEmail,
            status: result ? 'success' : 'failed',
          },
        });

        return { success: result };
      } catch (error) {
        console.error('[AdminWelcome] Error sending security tips:', error);
        throw new Error('Failed to send security tips email');
      }
    }),

  /**
   * Send role-specific training email
   */
  sendRoleTraining: adminProcedure
    .input(
      z.object({
        adminId: z.string(),
        adminName: z.string(),
        adminEmail: z.string().email(),
        role: z.string(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        const result = await sendRoleTrainingEmail(
          input.adminEmail,
          input.adminName,
          input.role
        );

        await logActivity({
          adminId: ctx.user.id,
          action: 'ROLE_TRAINING_EMAIL_SENT',
          resourceType: 'admin',
          resourceId: input.adminId,
          details: {
            recipientEmail: input.adminEmail,
            role: input.role,
            status: result ? 'success' : 'failed',
          },
        });

        return { success: result };
      } catch (error) {
        console.error('[AdminWelcome] Error sending role training:', error);
        throw new Error('Failed to send role training email');
      }
    }),

  /**
   * Send complete onboarding email sequence
   */
  sendCompleteOnboardingSequence: adminProcedure
    .input(
      z.object({
        adminId: z.string(),
        adminName: z.string(),
        adminEmail: z.string().email(),
        role: z.string(),
        onboardingUrl: z.string().url(),
      })
    )
    .mutation(async ({ input, ctx }) => {
      try {
        // Send emails in sequence
        const welcomeResult = await sendWelcomeEmail({
          adminName: input.adminName,
          adminEmail: input.adminEmail,
          role: input.role,
          onboardingUrl: input.onboardingUrl,
          supportEmail: 'support@playcoinkrazy.com',
          companyName: 'CoinKrazy',
        });

        const securityResult = await sendSecurityTipsEmail(
          input.adminEmail,
          input.adminName
        );

        const trainingResult = await sendRoleTrainingEmail(
          input.adminEmail,
          input.adminName,
          input.role
        );

        // Log complete sequence
        await logActivity({
          adminId: ctx.user.id,
          action: 'ONBOARDING_SEQUENCE_SENT',
          resourceType: 'admin',
          resourceId: input.adminId,
          details: {
            recipientEmail: input.adminEmail,
            recipientRole: input.role,
            welcomeEmail: welcomeResult,
            securityEmail: securityResult,
            trainingEmail: trainingResult,
            allSuccessful: welcomeResult && securityResult && trainingResult,
          },
        });

        // Emit alert
        await emitAlert({
          type: 'admin_onboarded',
          title: 'Admin Onboarding Emails Sent',
          message: `Complete onboarding sequence sent to ${input.adminName}`,
          severity: 'info',
          resourceType: 'admin',
          resourceId: input.adminId,
        });

        return {
          success: welcomeResult && securityResult && trainingResult,
          results: {
            welcome: welcomeResult,
            security: securityResult,
            training: trainingResult,
          },
        };
      } catch (error) {
        console.error('[AdminWelcome] Error sending onboarding sequence:', error);
        throw new Error('Failed to send onboarding email sequence');
      }
    }),
});