init

internal/service/repayment_service.go

@@ -0,0 +1,506 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"accounting-app/internal/models"
+	"accounting-app/internal/repository"
+
+	"gorm.io/gorm"
+)
+
+// Repayment service errors
+var (
+	ErrRepaymentPlanNotFound     = errors.New("repayment plan not found")
+	ErrInstallmentNotFound       = errors.New("installment not found")
+	ErrInvalidInstallmentCount   = errors.New("installment count must be at least 2")
+	ErrInvalidInstallmentAmount  = errors.New("installment amount must be positive")
+	ErrPlanAlreadyExists         = errors.New("repayment plan already exists for this bill")
+	ErrBillAlreadyPaid           = errors.New("bill is already paid")
+	ErrInvalidRepaymentAmount    = errors.New("payment amount must be positive")
+	ErrPaymentExceedsInstallment = errors.New("payment amount exceeds installment amount")
+	ErrInstallmentAlreadyPaid    = errors.New("installment is already paid")
+)
+
+// RepaymentService handles business logic for repayment plans and reminders
+type RepaymentService struct {
+	repaymentRepo *repository.RepaymentRepository
+	billingRepo   *repository.BillingRepository
+	accountRepo   *repository.AccountRepository
+	db            *gorm.DB
+}
+
+// NewRepaymentService creates a new RepaymentService instance
+func NewRepaymentService(
+	repaymentRepo *repository.RepaymentRepository,
+	billingRepo *repository.BillingRepository,
+	accountRepo *repository.AccountRepository,
+	db *gorm.DB,
+) *RepaymentService {
+	return &RepaymentService{
+		repaymentRepo: repaymentRepo,
+		billingRepo:   billingRepo,
+		accountRepo:   accountRepo,
+		db:            db,
+	}
+}
+
+// CreateRepaymentPlanInput represents input for creating a repayment plan
+type CreateRepaymentPlanInput struct {
+	BillID           uint      `json:"bill_id" binding:"required"`
+	InstallmentCount int       `json:"installment_count" binding:"required,min=2"`
+	FirstDueDate     time.Time `json:"first_due_date" binding:"required"`
+}
+
+// CreateRepaymentPlan creates a new repayment plan for a bill
+func (s *RepaymentService) CreateRepaymentPlan(userID uint, input CreateRepaymentPlanInput) (*models.RepaymentPlan, error) {
+	// Validate installment count
+	if input.InstallmentCount < 2 {
+		return nil, ErrInvalidInstallmentCount
+	}
+
+	// Get the bill
+	bill, err := s.billingRepo.GetByID(userID, input.BillID)
+	if err != nil {
+		if errors.Is(err, repository.ErrBillNotFound) {
+			return nil, fmt.Errorf("bill not found: %w", err)
+		}
+		return nil, fmt.Errorf("failed to get bill: %w", err)
+	}
+
+	// Check if bill is already paid
+	if bill.Status == models.BillStatusPaid {
+		return nil, ErrBillAlreadyPaid
+	}
+
+	// Check if plan already exists for this bill
+	existingPlan, err := s.repaymentRepo.GetPlanByBillID(userID, input.BillID)
+	if err != nil && !errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+		return nil, fmt.Errorf("failed to check existing plan: %w", err)
+	}
+	if existingPlan != nil {
+		return nil, ErrPlanAlreadyExists
+	}
+
+	// Calculate installment amount
+	totalAmount := bill.CurrentBalance
+	installmentAmount := totalAmount / float64(input.InstallmentCount)
+
+	// Create the plan
+	plan := &models.RepaymentPlan{
+		UserID:            userID,
+		BillID:            input.BillID,
+		TotalAmount:       totalAmount,
+		RemainingAmount:   totalAmount,
+		InstallmentCount:  input.InstallmentCount,
+		InstallmentAmount: installmentAmount,
+		Status:            models.RepaymentPlanStatusActive,
+	}
+
+	// Create plan and installments in a transaction
+	err = s.db.Transaction(func(tx *gorm.DB) error {
+		// Create the plan using the transaction
+		if err := tx.Create(plan).Error; err != nil {
+			return fmt.Errorf("failed to create plan: %w", err)
+		}
+
+		// Create installments
+		currentDueDate := input.FirstDueDate
+		for i := 1; i <= input.InstallmentCount; i++ {
+			// Last installment gets any remaining amount due to rounding
+			amount := installmentAmount
+			if i == input.InstallmentCount {
+				amount = totalAmount - (installmentAmount * float64(input.InstallmentCount-1))
+			}
+
+			installment := &models.RepaymentInstallment{
+				PlanID:     plan.ID,
+				DueDate:    currentDueDate,
+				Amount:     amount,
+				PaidAmount: 0,
+				Status:     models.RepaymentInstallmentStatusPending,
+				Sequence:   i,
+			}
+
+			if err := tx.Create(installment).Error; err != nil {
+				return fmt.Errorf("failed to create installment: %w", err)
+			}
+
+			// Move to next month for next installment
+			currentDueDate = currentDueDate.AddDate(0, 1, 0)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create repayment plan: %w", err)
+	}
+
+	// Reload plan with installments
+	plan, err = s.repaymentRepo.GetPlanByID(userID, plan.ID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to reload plan: %w", err)
+	}
+
+	return plan, nil
+}
+
+// GetRepaymentPlan retrieves a repayment plan by ID
+func (s *RepaymentService) GetRepaymentPlan(userID uint, id uint) (*models.RepaymentPlan, error) {
+	plan, err := s.repaymentRepo.GetPlanByID(userID, id)
+	if err != nil {
+		if errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+			return nil, ErrRepaymentPlanNotFound
+		}
+		return nil, fmt.Errorf("failed to get repayment plan: %w", err)
+	}
+	return plan, nil
+}
+
+// GetRepaymentPlanByBillID retrieves a repayment plan by bill ID
+func (s *RepaymentService) GetRepaymentPlanByBillID(userID uint, billID uint) (*models.RepaymentPlan, error) {
+	plan, err := s.repaymentRepo.GetPlanByBillID(userID, billID)
+	if err != nil {
+		if errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+			return nil, ErrRepaymentPlanNotFound
+		}
+		return nil, fmt.Errorf("failed to get repayment plan: %w", err)
+	}
+	return plan, nil
+}
+
+// GetActivePlans retrieves all active repayment plans
+func (s *RepaymentService) GetActivePlans(userID uint) ([]models.RepaymentPlan, error) {
+	plans, err := s.repaymentRepo.GetActivePlans(userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get active plans: %w", err)
+	}
+	return plans, nil
+}
+
+// PayInstallmentInput represents input for paying an installment
+type PayInstallmentInput struct {
+	InstallmentID uint    `json:"installment_id" binding:"required"`
+	Amount        float64 `json:"amount" binding:"required,gt=0"`
+	FromAccountID uint    `json:"from_account_id" binding:"required"`
+}
+
+// PayInstallment processes a payment for an installment
+func (s *RepaymentService) PayInstallment(userID uint, input PayInstallmentInput) error {
+	// Validate amount
+	if input.Amount <= 0 {
+		return ErrInvalidRepaymentAmount
+	}
+
+	// Get the installment
+	installment, err := s.repaymentRepo.GetInstallmentByID(input.InstallmentID)
+	if err != nil {
+		if errors.Is(err, repository.ErrInstallmentNotFound) {
+			return ErrInstallmentNotFound
+		}
+		return fmt.Errorf("failed to get installment: %w", err)
+	}
+
+	// Check if already paid
+	if installment.Status == models.RepaymentInstallmentStatusPaid {
+		return ErrInstallmentAlreadyPaid
+	}
+
+	// Check if payment amount is valid
+	remainingAmount := installment.Amount - installment.PaidAmount
+	if input.Amount > remainingAmount {
+		return ErrPaymentExceedsInstallment
+	}
+
+	// Get the from account
+	fromAccount, err := s.accountRepo.GetByID(userID, input.FromAccountID)
+	if err != nil {
+		if errors.Is(err, repository.ErrAccountNotFound) {
+			return fmt.Errorf("from account not found: %w", err)
+		}
+		return fmt.Errorf("failed to get from account: %w", err)
+	}
+
+	// Check if from account has sufficient balance (for non-credit accounts)
+	if !models.IsCreditAccountType(fromAccount.Type) && fromAccount.Balance < input.Amount {
+		return fmt.Errorf("insufficient balance in from account")
+	}
+
+	// Process payment in a transaction
+	err = s.db.Transaction(func(tx *gorm.DB) error {
+		// Update installment
+		installment.PaidAmount += input.Amount
+		now := time.Now()
+
+		// Mark as paid if fully paid
+		if installment.PaidAmount >= installment.Amount {
+			installment.Status = models.RepaymentInstallmentStatusPaid
+			installment.PaidAt = &now
+		}
+
+		if err := s.repaymentRepo.UpdateInstallment(installment); err != nil {
+			return err
+		}
+
+		// Update plan remaining amount
+		plan, err := s.repaymentRepo.GetPlanByID(userID, installment.PlanID)
+		if err != nil {
+			return err
+		}
+
+		plan.RemainingAmount -= input.Amount
+
+		// Check if plan is completed
+		if plan.RemainingAmount <= 0 {
+			plan.Status = models.RepaymentPlanStatusCompleted
+
+			// Mark the bill as paid
+			if err := s.billingRepo.MarkAsPaid(userID, plan.BillID, plan.TotalAmount, now); err != nil {
+				return err
+			}
+		}
+
+		if err := s.repaymentRepo.UpdatePlan(plan); err != nil {
+			return err
+		}
+
+		// Update from account balance
+		fromAccount.Balance -= input.Amount
+		if err := s.accountRepo.Update(fromAccount); err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to process payment: %w", err)
+	}
+
+	return nil
+}
+
+// CancelRepaymentPlan cancels a repayment plan
+func (s *RepaymentService) CancelRepaymentPlan(userID uint, id uint) error {
+	// Get the plan
+	plan, err := s.repaymentRepo.GetPlanByID(userID, id)
+	if err != nil {
+		if errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+			return ErrRepaymentPlanNotFound
+		}
+		return fmt.Errorf("failed to get plan: %w", err)
+	}
+
+	// Update status to cancelled
+	if err := s.repaymentRepo.UpdatePlanStatus(plan.ID, models.RepaymentPlanStatusCancelled); err != nil {
+		return fmt.Errorf("failed to cancel plan: %w", err)
+	}
+
+	return nil
+}
+
+// ========================================
+// Reminder Management
+// ========================================
+
+// GenerateRemindersForUpcomingPayments generates reminders for upcoming payments
+func (s *RepaymentService) GenerateRemindersForUpcomingPayments(userID uint, daysAhead int) ([]models.PaymentReminder, error) {
+	now := time.Now()
+	endDate := now.AddDate(0, 0, daysAhead)
+
+	var reminders []models.PaymentReminder
+
+	// Generate reminders for bills without repayment plans
+	bills, err := s.billingRepo.GetBillsDueInRange(userID, now, endDate)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get upcoming bills: %w", err)
+	}
+
+	for _, bill := range bills {
+		// Check if bill has a repayment plan
+		_, err := s.repaymentRepo.GetPlanByBillID(userID, bill.ID)
+		if err != nil && !errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+			return nil, fmt.Errorf("failed to check repayment plan: %w", err)
+		}
+
+		// Only create reminder if no repayment plan exists
+		if errors.Is(err, repository.ErrRepaymentPlanNotFound) {
+			daysUntilDue := int(bill.PaymentDueDate.Sub(now).Hours() / 24)
+			message := fmt.Sprintf("Payment due in %d days for %s. Amount: %.2f",
+				daysUntilDue, bill.Account.Name, bill.CurrentBalance)
+
+			reminder := models.PaymentReminder{
+				BillID:       bill.ID,
+				ReminderDate: now,
+				Message:      message,
+				IsRead:       false,
+			}
+
+			if err := s.repaymentRepo.CreateReminder(&reminder); err != nil {
+				return nil, fmt.Errorf("failed to create reminder: %w", err)
+			}
+
+			reminders = append(reminders, reminder)
+		}
+	}
+
+	// Generate reminders for upcoming installments
+	installments, err := s.repaymentRepo.GetInstallmentsDueInRange(now, endDate)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get upcoming installments: %w", err)
+	}
+
+	for _, installment := range installments {
+		daysUntilDue := int(installment.DueDate.Sub(now).Hours() / 24)
+		message := fmt.Sprintf("Installment %d/%d due in %d days for %s. Amount: %.2f",
+			installment.Sequence, installment.Plan.InstallmentCount,
+			daysUntilDue, installment.Plan.Bill.Account.Name, installment.Amount)
+
+		reminder := models.PaymentReminder{
+			BillID:        installment.Plan.BillID,
+			InstallmentID: &installment.ID,
+			ReminderDate:  now,
+			Message:       message,
+			IsRead:        false,
+		}
+
+		if err := s.repaymentRepo.CreateReminder(&reminder); err != nil {
+			return nil, fmt.Errorf("failed to create reminder: %w", err)
+		}
+
+		reminders = append(reminders, reminder)
+	}
+
+	return reminders, nil
+}
+
+// GetUnreadReminders retrieves all unread payment reminders
+func (s *RepaymentService) GetUnreadReminders(userID uint) ([]models.PaymentReminder, error) {
+	reminders, err := s.repaymentRepo.GetUnreadReminders(userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get unread reminders: %w", err)
+	}
+	return reminders, nil
+}
+
+// MarkReminderAsRead marks a reminder as read
+func (s *RepaymentService) MarkReminderAsRead(id uint) error {
+	if err := s.repaymentRepo.MarkReminderAsRead(id); err != nil {
+		if errors.Is(err, repository.ErrReminderNotFound) {
+			return fmt.Errorf("reminder not found: %w", err)
+		}
+		return fmt.Errorf("failed to mark reminder as read: %w", err)
+	}
+	return nil
+}
+
+// UpdateOverdueInstallments updates the status of installments that are overdue
+func (s *RepaymentService) UpdateOverdueInstallments() error {
+	now := time.Now()
+
+	// Get all pending installments
+	installments, err := s.repaymentRepo.GetPendingInstallments()
+	if err != nil {
+		return fmt.Errorf("failed to get pending installments: %w", err)
+	}
+
+	for _, installment := range installments {
+		// Check if due date has passed
+		if installment.DueDate.Before(now) {
+			if err := s.repaymentRepo.UpdateInstallmentStatus(installment.ID, models.RepaymentInstallmentStatusOverdue); err != nil {
+				return fmt.Errorf("failed to update installment %d status: %w", installment.ID, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// GetDebtSummary returns a summary of all debts across credit accounts
+type DebtSummary struct {
+	TotalDebt           float64       `json:"total_debt"`
+	TotalMinimumPayment float64       `json:"total_minimum_payment"`
+	PendingBillsCount   int           `json:"pending_bills_count"`
+	OverdueBillsCount   int           `json:"overdue_bills_count"`
+	ActivePlansCount    int           `json:"active_plans_count"`
+	AccountDebts        []AccountDebt `json:"account_debts"`
+}
+
+type AccountDebt struct {
+	AccountID        uint       `json:"account_id"`
+	AccountName      string     `json:"account_name"`
+	CurrentBalance   float64    `json:"current_balance"`
+	MinimumPayment   float64    `json:"minimum_payment"`
+	NextPaymentDate  *time.Time `json:"next_payment_date,omitempty"`
+	HasRepaymentPlan bool       `json:"has_repayment_plan"`
+}
+
+// GetDebtSummary retrieves a comprehensive debt summary
+func (s *RepaymentService) GetDebtSummary(userID uint) (*DebtSummary, error) {
+	summary := &DebtSummary{
+		AccountDebts: []AccountDebt{},
+	}
+
+	// Get all pending bills
+	pendingBills, err := s.billingRepo.GetPendingBills(userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get pending bills: %w", err)
+	}
+	summary.PendingBillsCount = len(pendingBills)
+
+	// Get all overdue bills
+	overdueBills, err := s.billingRepo.GetOverdueBills(userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get overdue bills: %w", err)
+	}
+	summary.OverdueBillsCount = len(overdueBills)
+
+	// Get all active plans
+	activePlans, err := s.repaymentRepo.GetActivePlans(userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get active plans: %w", err)
+	}
+	summary.ActivePlansCount = len(activePlans)
+
+	// Aggregate debt by account
+	accountDebtMap := make(map[uint]*AccountDebt)
+
+	// Process pending and overdue bills
+	allBills := append(pendingBills, overdueBills...)
+	for _, bill := range allBills {
+		if _, exists := accountDebtMap[bill.AccountID]; !exists {
+			accountDebtMap[bill.AccountID] = &AccountDebt{
+				AccountID:   bill.AccountID,
+				AccountName: bill.Account.Name,
+			}
+		}
+
+		debt := accountDebtMap[bill.AccountID]
+		debt.CurrentBalance += bill.CurrentBalance
+		debt.MinimumPayment += bill.MinimumPayment
+
+		// Set next payment date to the earliest due date
+		if debt.NextPaymentDate == nil || bill.PaymentDueDate.Before(*debt.NextPaymentDate) {
+			debt.NextPaymentDate = &bill.PaymentDueDate
+		}
+
+		// Check if bill has a repayment plan
+		_, err := s.repaymentRepo.GetPlanByBillID(userID, bill.ID)
+		if err == nil {
+			debt.HasRepaymentPlan = true
+		}
+
+		summary.TotalDebt += bill.CurrentBalance
+		summary.TotalMinimumPayment += bill.MinimumPayment
+	}
+
+	// Convert map to slice
+	for _, debt := range accountDebtMap {
+		summary.AccountDebts = append(summary.AccountDebts, *debt)
+	}
+
+	return summary, nil
+}