import { NextRequest, NextResponse } from 'next/server';
import { dbConnect } from '@/lib/dbConnect';
import { Order } from '@/models/Order';
import { Course } from '@/models/Course';
import { Subscription } from '@/models/Subscription';
import { CoursePurchaseHistory } from '@/models/CoursePurchaseHistory';
import { Settings } from '@/models/Settings';
import { requireAuth } from '@/lib/auth';
import { extractFilename } from '@/lib/media';

interface Params {
  params: { id: string };
}

// PATCH /api/orders/[id]/bank-transfer
export async function PATCH(req: NextRequest, { params }: Params) {
  const auth = requireAuth(req);
  if (auth instanceof NextResponse) return auth;

  try {
    await dbConnect();
    const body = await req.json();

    const order = await Order.findById(params.id);
    if (!order) {
      return NextResponse.json({ success: false, error: 'Order not found' }, { status: 404 });
    }

    if (order.gateway !== 'bank_transfer') {
      return NextResponse.json(
        { success: false, error: 'This order does not use Bank Transfer gateway' },
        { status: 400 }
      );
    }

    const isAdmin = auth.user.role === 'admin' || auth.user.role === 'super_admin';

    // Student action: upload proof of payment
    if (!isAdmin) {
      if (order.student.toString() !== auth.user.id) {
        return NextResponse.json({ success: false, error: 'Forbidden' }, { status: 403 });
      }

      const { proofOfPaymentUrl, senderAccountName, senderBank } = body;
      if (!proofOfPaymentUrl) {
        return NextResponse.json(
          { success: false, error: 'proofOfPaymentUrl is required' },
          { status: 400 }
        );
      }

      if (!order.bankTransferDetails) {
        order.bankTransferDetails = { adminConfirmationStatus: 'pending' };
      }

      order.bankTransferDetails.proofOfPaymentUrl = extractFilename(proofOfPaymentUrl);
      if (senderAccountName) order.bankTransferDetails.senderAccountName = senderAccountName;
      if (senderBank) order.bankTransferDetails.senderBank = senderBank;
      order.status = 'pending';

      await order.save();

      return NextResponse.json({
        success: true,
        message: 'Bank transfer payment proof submitted successfully. Pending admin verification.',
        order,
      });
    }

    // Admin action: approve or reject bank transfer
    const { adminConfirmationStatus, adminNotes } = body;
    if (!['approved', 'rejected'].includes(adminConfirmationStatus)) {
      return NextResponse.json(
        { success: false, error: 'adminConfirmationStatus must be "approved" or "rejected"' },
        { status: 400 }
      );
    }

    if (!order.bankTransferDetails) {
      order.bankTransferDetails = { adminConfirmationStatus: 'pending' };
    }

    order.bankTransferDetails.adminConfirmationStatus = adminConfirmationStatus;
    order.bankTransferDetails.confirmedBy = auth.user.id as any;
    order.bankTransferDetails.confirmedAt = new Date();
    if (adminNotes) order.bankTransferDetails.adminNotes = adminNotes;
    order.confirmedAt = new Date();

    if (adminConfirmationStatus === 'approved') {
      order.status = 'succeeded';

      const settings = await Settings.getSettings();
      const courses = await Course.find({ _id: order.courseId });

      // Create CoursePurchaseHistory record
      await CoursePurchaseHistory.create({
        student: order.student,
        order: order._id,
        courseId: order.courseId,
        lessons: order.lessons || [],
        amountPaid: order.amount,
        currency: order.currency,
        discountApplied: 0,
        paymentMethod: 'bank_transfer',
        transactionId: order.gatewayTransactionId || `BT-${order._id.toString().slice(-8).toUpperCase()}`,
        paymentStatus: 'completed',
        purchasedAt: new Date(),
      });

      // Grant Subscriptions with standard 4-month validity (or course-level override)
      for (const course of courses) {
        const validityMonths = course.validityMonths || settings.defaultCourseExpiryMonths || 4;
        const startDate = new Date();
        const expiryDate = new Date();
        expiryDate.setMonth(expiryDate.getMonth() + validityMonths);

        const existingSub = await Subscription.findOne({
          student: order.student,
          course: course._id,
        });

        if (existingSub) {
          existingSub.expiryDate = expiryDate;
          existingSub.status = 'active';

          if (Array.isArray(order.lessons) && order.lessons.length > 0) {
            const mergedLessons = Array.from(
              new Set([
                ...(existingSub.lessons || []).map((id) => id.toString()),
                ...order.lessons.map((id) => id.toString()),
              ])
            );
            existingSub.lessons = mergedLessons as any;
          }

          await existingSub.save();
        } else {
          await Subscription.create({
            student: order.student,
            course: course._id,
            lessons: order.lessons || [],
            order: order._id,
            startDate,
            expiryDate,
            status: 'active',
            completedChapters: [],
            completedPercent: 0,
            lastWatchedPositionSeconds: 0,
          });
        }
      }
    } else {
      order.status = 'failed';
    }

    await order.save();

    return NextResponse.json({
      success: true,
      message: `Bank transfer payment ${adminConfirmationStatus} successfully`,
      order,
    });
  } catch (error: any) {
    return NextResponse.json(
      { success: false, error: error.message || 'Server error verifying bank transfer' },
      { status: 500 }
    );
  }
}