Razorpay Payment Integration: Educational Platform for Indian Market

const Razorpay = require('razorpay');

const razorpayConfig = {
  key_id: process.env.RAZORPAY_KEY_ID,
  key_secret: process.env.RAZORPAY_KEY_SECRET,
  payment_capture: 1,
  currency: 'INR',
  theme: {
    color: '#FFD60A'
  }
};

const razorpay = new Razorpay({
  key_id: razorpayConfig.key_id,
  key_secret: razorpayConfig.key_secret
});

const coursePaymentOptions = {
  basic: {
    price: 299900,
    emi_options: true,
    upi_preferred: true,
    installments: [3, 6, 12]
  },
  professional: {
    price: 799900,
    emi_options: true,
    education_loan: true,
    installments: [6, 12, 24]
  },
  premium: {
    price: 1999900,
    emi_options: true,
    corporate_billing: true,
    custom_installments: true
  }
};

async function createEducationalOrder(courseId, studentId, paymentMethod) {
  const course = await getCourseDetails(courseId);
  const student = await getStudentData(studentId);
  
  const orderOptions = {
    amount: course.price,
    currency: 'INR',
    receipt: `course_${courseId}_${studentId}_${Date.now()}`,
    payment_capture: 1,
    notes: {
      course_id: courseId,
      student_id: studentId,
      course_name: course.name,
      student_email: student.email,
      payment_type: 'course_enrollment'
    }
  };
  
  if (paymentMethod === 'emi') {
    orderOptions.method = {
      emi: 1,
      card: 1
    };
    orderOptions.offers = await getEMIOffers(course.price);
  }
  
  const order = await razorpay.orders.create(orderOptions);
  
  await storePendingPayment({
    order_id: order.id,
    student_id: studentId,
    course_id: courseId,
    amount: course.price,
    status: 'pending'
  });
  
  return order;
}

function initializeEducationalCheckout(courseData, studentData) {
  const options = {
    key: razorpayConfig.key_id,
    amount: courseData.finalPrice,
    currency: 'INR',
    name: 'SkillMaster Online',
    description: `${courseData.title} - ${courseData.duration}`,
    image: '/assets/images/logo.png',
    order_id: courseData.orderId,
    
    prefill: {
      name: studentData.fullName,
      email: studentData.email,
      contact: studentData.phone
    },
    
    theme: {
      color: '#FFD60A'
    },
    
    config: {
      display: {
        blocks: {
          upi: {
            name: 'Pay using UPI',
            instruments: [
              {
                method: 'upi',
                flows: ['collect', 'intent', 'qr']
              }
            ]
          },
          card: {
            name: 'Credit/Debit Cards',
            instruments: [
              {
                method: 'card'
              }
            ]
          },
          netbanking: {
            name: 'NetBanking',
            instruments: [
              {
                method: 'netbanking'
              }
            ]
          }
        },
        sequence: ['block.upi', 'block.card', 'block.netbanking'],
        preferences: {
          show_default_blocks: true
        }
      }
    },
    
    handler: function(response) {
      verifyEducationalPayment(response, courseData, studentData);
    },
    
    modal: {
      ondismiss: function() {
        trackCheckoutAbandonment(courseData.courseId, studentData.studentId);
      }
    }
  };
  
  const rzp = new Razorpay(options);
  rzp.open();
}

class EducationalEMIManager {
  constructor() {
    this.emiPartners = {
      hdfc: { minAmount: 500000, maxTenure: 24, interestRate: 0 },
      icici: { minAmount: 300000, maxTenure: 18, interestRate: 0 },
      axis: { minAmount: 500000, maxTenure: 24, interestRate: 0 },
      bajaj: { minAmount: 199900, maxTenure: 24, interestRate: 3.5 }
    };
  }
  
  async calculateEMIOptions(coursePrice, studentProfile) {
    const eligibleOptions = [];
    
    for (const [bank, terms] of Object.entries(this.emiPartners)) {
      if (coursePrice >= terms.minAmount) {
        for (let tenure = 3; tenure <= terms.maxTenure; tenure += 3) {
          const monthlyEMI = this.calculateMonthlyEMI(
            coursePrice, 
            terms.interestRate, 
            tenure
          );
          
          eligibleOptions.push({
            bank: bank.toUpperCase(),
            tenure: tenure,
            monthlyAmount: monthlyEMI,
            totalAmount: monthlyEMI * tenure,
            interestRate: terms.interestRate,
            processingFee: 0
          });
        }
      }
    }
    
    return eligibleOptions.sort((a, b) => a.monthlyAmount - b.monthlyAmount);
  }
  
  calculateMonthlyEMI(principal, annualRate, tenureMonths) {
    if (annualRate === 0) {
      return Math.ceil(principal / tenureMonths);
    }
    
    const monthlyRate = annualRate / 12 / 100;
    const emi = principal * monthlyRate * 
      Math.pow(1 + monthlyRate, tenureMonths) / 
      (Math.pow(1 + monthlyRate, tenureMonths) - 1);
    
    return Math.ceil(emi);
  }
  
  async createEMIOrder(courseId, studentId, emiPlan) {
    const orderOptions = {
      amount: emiPlan.totalAmount,
      currency: 'INR',
      method: {
        emi: 1
      },
      emi: {
        duration: emiPlan.tenure
      },
      customer_id: studentId,
      notes: {
        course_id: courseId,
        emi_plan: JSON.stringify(emiPlan),
        payment_type: 'educational_emi'
      }
    };
    
    return await razorpay.orders.create(orderOptions);
  }
}

const subscriptionPlans = {
  basic: {
    planId: 'plan_skillmaster_basic',
    amount: 99900,
    currency: 'INR',
    interval: 1,
    period: 'monthly',
    features: ['access_basic_courses', 'community_support']
  },
  pro: {
    planId: 'plan_skillmaster_pro',
    amount: 99900,
    currency: 'INR',
    interval: 1,
    period: 'monthly',
    features: ['access_all_courses', 'live_sessions', 'certifications', 'priority_support']
  },
  premium: {
    planId: 'plan_skillmaster_premium',
    amount: 199900,
    currency: 'INR',
    interval: 1,
    period: 'monthly',
    features: ['access_all_courses', 'live_sessions', 'certifications', 'one_on_one_mentoring', 'career_services']
  }
};

async function createEducationalSubscription(studentId, planType, paymentMethodId) {
  const plan = subscriptionPlans[planType];
  const student = await getStudentData(studentId);
  
  const subscriptionData = {
    plan_id: plan.planId,
    customer_notify: 1,
    quantity: 1,
    total_count: 12,
    start_at: Math.floor(Date.now() / 1000),
    expire_by: Math.floor(Date.now() / 1000) + (365 * 24 * 60 * 60),
    addons: [],
    notes: {
      student_id: studentId,
      student_email: student.email,
      plan_type: planType,
      subscription_type: 'educational'
    }
  };
  
  const subscription = await razorpay.subscriptions.create(subscriptionData);
  
  await storeSubscriptionData({
    razorpay_subscription_id: subscription.id,
    student_id: studentId,
    plan_type: planType,
    status: 'created',
    start_date: new Date(),
    features: plan.features
  });
  
  return subscription;
}

async function handleSubscriptionWebhook(webhookBody, signature) {
  const isValidSignature = validateWebhookSignature(webhookBody, signature);
  
  if (!isValidSignature) {
    throw new Error('Invalid webhook signature');
  }
  
  const event = JSON.parse(webhookBody);
  
  switch (event.event) {
    case 'subscription.charged':
      await handleSuccessfulSubscriptionPayment(event.payload.subscription.entity);
      break;
      
    case 'subscription.cancelled':
      await handleSubscriptionCancellation(event.payload.subscription.entity);
      break;
      
    case 'subscription.completed':
      await handleSubscriptionCompletion(event.payload.subscription.entity);
      break;
      
    case 'invoice.failed':
      await handleFailedSubscriptionPayment(event.payload.payment.entity);
      break;
  }
}

class EducationalRefundManager {
  constructor() {
    this.refundPolicies = {
      seven_day_guarantee: {
        eligibilityDays: 7,
        maxCompletionPercent: 25,
        autoApproval: true,
        refundPercent: 100
      },
      partial_refund: {
        eligibilityDays: 30,
        requiresApproval: true,
        refundFormula: 'prorated'
      },
      technical_issues: {
        eligibilityDays: 90,
        autoApproval: true,
        refundPercent: 100
      }
    };
  }
  
  async processEducationalRefund(enrollmentId, refundReason, requestedBy) {
    const enrollment = await getEnrollmentData(enrollmentId);
    const course = await getCourseData(enrollment.course_id);
    const student = await getStudentData(enrollment.student_id);
    
    const refundPolicy = this.determineRefundPolicy(refundReason, enrollment);
    const eligibility = await this.checkRefundEligibility(enrollment, refundPolicy);
    
    if (!eligibility.eligible) {
      return { success: false, reason: eligibility.reason };
    }
    
    const refundAmount = this.calculateRefundAmount(enrollment, refundPolicy);
    
    if (refundPolicy.autoApproval) {
      return await this.processAutomaticRefund(enrollment, refundAmount);
    } else {
      return await this.createRefundRequest(enrollment, refundAmount, refundReason);
    }
  }
  
  async checkRefundEligibility(enrollment, policy) {
    const daysSincePurchase = this.getDaysSincePurchase(enrollment.created_at);
    const completionPercent = await this.getCourseCompletionPercent(enrollment.id);
    
    if (daysSincePurchase > policy.eligibilityDays) {
      return { eligible: false, reason: 'Refund period expired' };
    }
    
    if (policy.maxCompletionPercent && completionPercent > policy.maxCompletionPercent) {
      return { eligible: false, reason: 'Course completion exceeds refund threshold' };
    }
    
    return { eligible: true };
  }
  
  calculateRefundAmount(enrollment, policy) {
    const originalAmount = enrollment.amount_paid;
    
    if (policy.refundFormula === 'prorated') {
      const completionPercent = this.getCourseCompletionPercent(enrollment.id);
      return originalAmount * (100 - completionPercent) / 100;
    }
    
    return originalAmount * (policy.refundPercent / 100);
  }
  
  async processAutomaticRefund(enrollment, refundAmount) {
    try {
      const refund = await razorpay.payments.refund(enrollment.payment_id, {
        amount: refundAmount * 100,
        speed: 'optimum',
        notes: {
          refund_reason: 'Educational policy compliance',
          enrollment_id: enrollment.id,
          processed_by: 'automated_system'
        }
      });
      
      await this.updateEnrollmentStatus(enrollment.id, 'refunded');
      await this.sendRefundConfirmationEmail(enrollment, refund);
      
      return { success: true, refund_id: refund.id, amount: refundAmount };
    } catch (error) {
      await this.logRefundError(enrollment.id, error);
      throw error;
    }
  }
}

class EducationalAnalytics {
  async generatePaymentInsights(timeRange = '30d') {
    return {
      paymentMethodDistribution: await this.getPaymentMethodStats(timeRange),
      courseWiseRevenue: await this.getCourseRevenueBreakdown(timeRange),
      studentDemographics: await this.getStudentPaymentDemographics(timeRange),
      emiPerformance: await this.getEMIAdoptionMetrics(timeRange),
      refundAnalysis: await this.getRefundPatternAnalysis(timeRange)
    };
  }
  
  async getPaymentMethodStats(timeRange) {
    const query = `
      SELECT 
        payment_method,
        COUNT(*) as transaction_count,
        SUM(amount) as total_revenue,
        AVG(amount) as avg_transaction_value,
        success_rate
      FROM educational_payments 
      WHERE created_at >= DATE_SUB(NOW(), INTERVAL ${timeRange})
      GROUP BY payment_method
      ORDER BY total_revenue DESC
    `;
    
    return await this.executeQuery(query);
  }
  
  async trackStudentLearningJourney(studentId) {
    return {
      enrollmentHistory: await this.getStudentEnrollments(studentId),
      paymentPreferences: await this.getPaymentMethodHistory(studentId),
      courseCompletionRate: await this.getCompletionMetrics(studentId),
      subscriptionBehavior: await this.getSubscriptionHistory(studentId),
      lifetimeValue: await this.calculateStudentLTV(studentId)
    };
  }
  
  async generateEducationalReports() {
    return {
      monthlyRevenueReport: await this.generateMonthlyReport(),
      coursePerformanceReport: await this.generateCourseReport(),
      paymentFailureAnalysis: await this.analyzePaymentFailures(),
      studentSegmentationReport: await this.generateSegmentationReport(),
      instructorPayoutReport: await this.generateInstructorReport()
    };
  }
}