-- Daily Interest Accrual Table Schema
CREATE TABLE daily_interest_accruals (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES accounts(id),
    accrual_date DATE NOT NULL,
    closing_balance BIGINT NOT NULL,
    annual_rate_bps INT NOT NULL, -- Stored in Basis Points (1 bps = 0.01%)
    accrued_amount BIGINT NOT NULL, -- Minor currency unit
    is_capitalized BOOLEAN NOT NULL DEFAULT FALSE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
    UNIQUE (account_id, accrual_date)
);

package lending

import (
	"math"
	"time"
)

type RepaymentScheduleItem struct {
	Period          int
	DueDate         time.Time
	Installment     int64 // Minor currency unit
	PrincipalAmount int64
	InterestAmount  int64
	RemainingBalance int64
}

// CalculateEqualPrincipal calculates reducing balance loan amortization.
func CalculateEqualPrincipal(principal int64, annualRate float64, tenureMonths int, startDate time.Time) []RepaymentScheduleItem {
	schedule := make([]RepaymentScheduleItem, tenureMonths)
	monthlyPrincipal := principal / int64(tenureMonths)
	monthlyRate := annualRate / 12.0
	currentBalance := principal

	for i := 1; i <= tenureMonths; i++ {
		// Calculate interest on remaining balance using Banker's Rounding
		interest := int64(math.Round(float64(currentBalance) * monthlyRate))
		
		// Adjust final period to eliminate rounding drift
		pAmount := monthlyPrincipal
		if i == tenureMonths {
			pAmount = currentBalance
		}
		
		currentBalance -= pAmount
		dueDate := startDate.AddDate(0, i, 0)

		schedule[i-1] = RepaymentScheduleItem{
			Period:           i,
			DueDate:          dueDate,
			Installment:      pAmount + interest,
			PrincipalAmount:  pAmount,
			InterestAmount:   interest,
			RemainingBalance: currentBalance,
		}
	}

	return schedule
}

package lending

import (
	"errors"
	"math"
	"time"
)

type AmortizationScheduleItem struct {
	Period           int       `json:"period"`
	DueDate          time.Time `json:"due_date"`
	PaymentAmount    int64     `json:"payment_amount"`
	PrincipalPortion int64     `json:"principal_portion"`
	InterestPortion  int64     `json:"interest_portion"`
	RemainingBalance int64     `json:"remaining_balance"`
}

type LoanCalculator struct{}

func NewLoanCalculator() *LoanCalculator {
	return &LoanCalculator{}
}

func (c *LoanCalculator) CalculateEqualInstallmentSchedule(
	principalAmount int64,
	annualRatePercent float64,
	tenorMonths int,
	startDate time.Time,
) ([]AmortizationScheduleItem, error) {
	if principalAmount <= 0 || annualRatePercent <= 0 || tenorMonths <= 0 {
		return nil, errors.New("invalid loan calculation parameters")
	}

	monthlyRate := (annualRatePercent / 100.0) / 12.0
	factor := math.Pow(1.0+monthlyRate, float64(tenorMonths))
	monthlyPaymentExact := float64(principalAmount) * (monthlyRate * factor) / (factor - 1.0)
	monthlyPayment := int64(math.Round(monthlyPaymentExact))

	schedule := make([]AmortizationScheduleItem, 0, tenorMonths)
	remainingPrincipal := principalAmount

	for period := 1; period <= tenorMonths; period++ {
		interestPayment := int64(math.Round(float64(remainingPrincipal) * monthlyRate))
		principalPayment := monthlyPayment - interestPayment

		if period == tenorMonths || principalPayment > remainingPrincipal {
			principalPayment = remainingPrincipal
			monthlyPayment = principalPayment + interestPayment
			remainingPrincipal = 0
		} else {
			remainingPrincipal -= principalPayment
		}

		dueDate := startDate.AddDate(0, period, 0)
		schedule = append(schedule, AmortizationScheduleItem{
			Period:           period,
			DueDate:          dueDate,
			PaymentAmount:    monthlyPayment,
			PrincipalPortion: principalPayment,
			InterestPortion:  interestPayment,
			RemainingBalance: remainingPrincipal,
		})

		if remainingPrincipal == 0 {
			break
		}
	}

	return schedule, nil
}

package deposit

import (
	"context"
	"math/big"
	"time"
)

type AccountDailyAccrual struct {
	AccountID       string
	Date            time.Time
	AccruedInterest int64
}

type AccrualEngine struct {
	BasisDays int64
}

func NewAccrualEngine(basisDays int64) *AccrualEngine {
	if basisDays <= 0 {
		basisDays = 365
	}
	return &AccrualEngine{BasisDays: basisDays}
}

func (e *AccrualEngine) CalculateDayInterest(balanceMicros int64, rateBps int64) int64 {
	if balanceMicros <= 0 || rateBps <= 0 {
		return 0
	}
	bal := big.NewInt(balanceMicros)
	rate := big.NewInt(rateBps)
	denominator := big.NewInt(e.BasisDays * 10000)

	numerator := new(big.Int).Mul(bal, rate)
	result := new(big.Int).Div(numerator, denominator)
	return result.Int64()
}

func (e *AccrualEngine) ProcessBatch(ctx context.Context, accounts []AccountDailyAccrual) error {
	for i := range accounts {
		select {
		case <-ctx.Done():
			return ctx.Err()
		default:
			// Process ledger posting in atomic batch
		}
	}
	return nil
}

package lending

import "time"

type LoanAccountStatus string

const (
	StatusCurrent    LoanAccountStatus = "CURRENT"
	StatusDelinquent LoanAccountStatus = "DELINQUENT_STAGE_1"
	StatusNPL        LoanAccountStatus = "NON_PERFORMING_STAGE_2"
	StatusWriteOff   LoanAccountStatus = "WRITTEN_OFF_STAGE_3"
)

type LoanAccount struct {
	ID             string
	PrincipalDue   int64
	InterestDue    int64
	DaysPastDue    int
	Status         LoanAccountStatus
	LastStatusDate time.Time
}

func EvaluateLoanStatus(loan *LoanAccount) {
	switch {
	case loan.DaysPastDue == 0:
		loan.Status = StatusCurrent
	case loan.DaysPastDue <= 90:
		loan.Status = StatusDelinquent
	case loan.DaysPastDue <= 180:
		loan.Status = StatusNPL
	default:
		loan.Status = StatusWriteOff
	}
	loan.LastStatusDate = time.Now()
}

package deposit

import (
	"context"
	"fmt"
	"sync"
	"time"
)

type SweepResult struct {
	AccountID       string
	AccruedInterest int64
	Error           error
}

type InterestSweepDaemon struct {
	workerCount int
	batchSize   int
	engine      *AccrualEngine
}

func NewInterestSweepDaemon(workers int, batchSize int, basisDays int64) *InterestSweepDaemon {
	return &InterestSweepDaemon{
		workerCount: workers,
		batchSize:   batchSize,
		engine:      NewAccrualEngine(basisDays),
	}
}

func (d *InterestSweepDaemon) ExecuteSweep(
	ctx context.Context,
	accounts []AccountDailyAccrual,
	rateBps int64,
) ([]SweepResult, error) {
	accountChan := make(chan AccountDailyAccrual, d.batchSize)
	resultChan := make(chan SweepResult, len(accounts))
	var wg sync.WaitGroup

	for i := 0; i < d.workerCount; i++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			for {
				select {
				case <-ctx.Done():
					return
				case acc, ok := <-accountChan:
					if !ok {
						return
					}
					interest := d.engine.CalculateDayInterest(acc.AccruedInterest, rateBps)
					resultChan <- SweepResult{
						AccountID:       acc.AccountID,
						AccruedInterest: interest,
						Error:           nil,
					}
				}
			}
		}(i)
	}

	go func() {
		for _, acc := range accounts {
			select {
			case <-ctx.Done():
				break
			case accountChan <- acc:
			}
		}
		close(accountChan)
	}()

	wg.Wait()
	close(resultChan)

	results := make([]SweepResult, 0, len(accounts))
	for res := range resultChan {
		results = append(results, res)
	}
	return results, nil
}

package lending

import (
	"errors"
	"math/big"
	"time"
)

type PenaltyAssessment struct {
	OverduePrincipal   int64
	OverdueInterest    int64
	DaysOverdue        int
	PenaltyOnPrincipal int64
	PenaltyOnInterest  int64
	TotalPenalty       int64
}

type PenaltyAccrualEngine struct {
	GracePeriodDays      int
	MaxPrincipalRateBps  int64
	MaxInterestRateBps   int64
	YearBasisDays        int64
}

func NewPenaltyAccrualEngine(basisDays int64) *PenaltyAccrualEngine {
	if basisDays <= 0 {
		basisDays = 365
	}
	return &PenaltyAccrualEngine{
		GracePeriodDays:     10,
		MaxPrincipalRateBps: 15000,
		MaxInterestRateBps:  10000,
		YearBasisDays:       basisDays,
	}
}

func (p *PenaltyAccrualEngine) CalculatePenalty(
	principalOverdue int64,
	interestOverdue int64,
	dueDate time.Time,
	asOfDate time.Time,
) (*PenaltyAssessment, error) {
	if asOfDate.Before(dueDate) {
		return nil, errors.New("assessment date cannot precede due date")
	}

	days := int(asOfDate.Sub(dueDate).Hours() / 24)
	if days <= p.GracePeriodDays {
		return &PenaltyAssessment{
			OverduePrincipal: principalOverdue,
			OverdueInterest:  interestOverdue,
			DaysOverdue:      days,
		}, nil
	}

	effectiveDays := int64(days)
	denom := big.NewInt(p.YearBasisDays * 10000)

	calcPenalty := func(amount int64, rateBps int64) int64 {
		amtBig := big.NewInt(amount)
		rateBig := big.NewInt(rateBps)
		daysBig := big.NewInt(effectiveDays)

		num := new(big.Int).Mul(amtBig, rateBig)
		num = num.Mul(num, daysBig)
		return new(big.Int).Div(num, denom).Int64()
	}

	penaltyPrin := calcPenalty(principalOverdue, p.MaxPrincipalRateBps)
	penaltyInt := calcPenalty(interestOverdue, p.MaxInterestRateBps)

	return &PenaltyAssessment{
		OverduePrincipal:   principalOverdue,
		OverdueInterest:    interestOverdue,
		DaysOverdue:        days,
		PenaltyOnPrincipal: penaltyPrin,
		PenaltyOnInterest:  penaltyInt,
		TotalPenalty:       penaltyPrin + penaltyInt,
	}, nil
}