import { NextRequest, NextResponse } from 'next/server';
import bcrypt from 'bcryptjs';
import { PrismaClient } from '@prisma/client';
import { gmailService } from '@/lib/gmailService';

const prisma = new PrismaClient();

export async function POST(request: NextRequest) {
  try {
    const { token, password, confirmPassword } = await request.json();
    
    console.log('Activation attempt for token:', token?.substring(0, 20) + '...');
    
    // Validate input
    if (!token) {
      return NextResponse.json({ error: 'Token is required' }, { status: 400 });
    }
    
    if (!password || password !== confirmPassword) {
      return NextResponse.json({ error: 'Passwords do not match' }, { status: 400 });
    }
    
    // Password strength validation
    if (password.length < 8) {
      return NextResponse.json({ error: 'Password must be at least 8 characters' }, { status: 400 });
    }
    
    const hasUpperCase = /[A-Z]/.test(password);
    const hasLowerCase = /[a-z]/.test(password);
    const hasNumbers = /\d/.test(password);
    const hasSpecialChar = /[@$!%*?&]/.test(password);
    
    if (!hasUpperCase || !hasLowerCase || !hasNumbers || !hasSpecialChar) {
      return NextResponse.json({ 
        error: 'Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character (@$!%*?&)' 
      }, { status: 400 });
    }
    
    // Find user with valid token
    const user = await prisma.user.findFirst({
      where: {
        activationToken: token,
        tokenExpiry: { gt: new Date() },
        status: 'PENDING_ACTIVATION',
      },
    });
    
    if (!user) {
      // Check if token exists but expired
      const expiredUser = await prisma.user.findFirst({
        where: {
          activationToken: token,
          tokenExpiry: { lte: new Date() },
        },
      });
      
      if (expiredUser) {
        return NextResponse.json({ 
          error: 'Activation link has expired. Please request a new one.' 
        }, { status: 410 });
      }
      
      return NextResponse.json({ error: 'Invalid or expired activation link' }, { status: 400 });
    }
    
    console.log(`Activating user: ${user.email}`);
    
    // Hash password and activate user
    const hashedPassword = await bcrypt.hash(password, 12);
    
    const activatedUser = await prisma.user.update({
      where: { id: user.id },
      data: {
        passwordHash: hashedPassword,
        status: 'ACTIVE',
        isEmailVerified: true,
        emailVerifiedAt: new Date(),
        activationToken: null,
        tokenExpiry: null,
        isFirstLogin: false,
      },
    });
    
    console.log(`✅ User activated successfully: ${activatedUser.email}`);
    
    // Send welcome email (optional - don't fail if this fails)
    try {
      await gmailService.sendEmail(
        activatedUser.email,
        'Welcome to HRMS! 🎉',
        `
        <!DOCTYPE html>
        <html>
        <head><title>Welcome to HRMS</title></head>
        <body style="font-family: Arial, sans-serif;">
          <div style="max-width: 600px; margin: auto; padding: 20px;">
            <h2 style="color: #b828a0;">Welcome to HRMS, ${activatedUser.name || 'User'}!</h2>
            <p>Your account has been successfully activated.</p>
            <p>You can now log in to the HRMS portal using your email address and the password you just created.</p>
            <div style="margin: 30px 0; text-align: center;">
              <a href="${process.env.FRONTEND_URL || 'http://localhost:3000'}/login" 
                 style="background: #b828a0; color: white; padding: 12px 24px; text-decoration: none; border-radius: 5px;">
                Login to HRMS
              </a>
            </div>
            <hr>
            <p style="font-size: 12px; color: #666;">&copy; ${new Date().getFullYear()} HRMS System</p>
          </div>
        </body>
        </html>
        `
      );
      console.log('Welcome email sent to:', activatedUser.email);
    } catch (emailError) {
      console.error('Failed to send welcome email:', emailError);
      // Don't fail the activation if welcome email fails
    }
    
    return NextResponse.json({ 
      success: true, 
      message: 'Account activated successfully! You can now login.',
      redirectTo: '/login'
    });
    
  } catch (error) {
    console.error('Activation error:', error);
    return NextResponse.json({ 
      error: 'Failed to activate account. Please try again.' 
    }, { status: 500 });
  }
}

export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const token = searchParams.get('token');
    
    if (!token) {
      return NextResponse.json({ valid: false, error: 'Token required' });
    }
    
    console.log('Validating token:', token.substring(0, 20) + '...');
    
    // Check for valid token
    const user = await prisma.user.findFirst({
      where: {
        activationToken: token,
        tokenExpiry: { gt: new Date() },
        status: 'PENDING_ACTIVATION',
      },
    });
    
    if (user) {
      console.log(`✅ Valid token for: ${user.email}`);
      return NextResponse.json({ 
        valid: true, 
        email: user.email, 
        name: user.name 
      });
    }
    
    // Check if token expired
    const expiredUser = await prisma.user.findFirst({
      where: {
        activationToken: token,
        tokenExpiry: { lte: new Date() },
      },
    });
    
    if (expiredUser) {
      console.log('❌ Expired token');
      return NextResponse.json({ 
        valid: false, 
        expired: true,
        error: 'Activation link has expired' 
      });
    }
    
    // Check if already activated
    const activatedUser = await prisma.user.findFirst({
      where: {
        activationToken: token,
        status: 'ACTIVE',
      },
    });
    
    if (activatedUser) {
      console.log('❌ Already activated account');
      return NextResponse.json({ 
        valid: false, 
        activated: true,
        error: 'Account already activated. Please login.' 
      });
    }
    
    console.log('❌ Invalid token');
    return NextResponse.json({ 
      valid: false, 
      error: 'Invalid activation token' 
    });
    
  } catch (error) {
    console.error('Token validation error:', error);
    return NextResponse.json({ 
      valid: false, 
      error: 'Failed to validate token' 
    });
  }
}