package bankengine

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
)

type TransferRequest struct {
	FromAccountID  string
	ToAccountID    string
	Amount         int64 // In minor currency unit
	IdempotencyKey string
	Narration      string
}

type Engine struct {
	pool *pgxpool.Pool
}

func NewEngine(pool *pgxpool.Pool) *Engine {
	return &Engine{pool: pool}
}

func (e *Engine) Transfer(ctx context.Context, req TransferRequest) error {
	if req.Amount <= 0 {
		return errors.New("transfer amount must be strictly positive")
	}
	if req.FromAccountID == req.ToAccountID {
		return errors.New("sender and recipient accounts must differ")
	}

	tx, err := e.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.ReadCommitted})
	if err != nil {
		return fmt.Errorf("failed to open transaction: %w", err)
	}
	defer tx.Rollback(ctx)

	// Enforce lock ordering: always lock smaller account ID first
	firstID, secondID := req.FromAccountID, req.ToAccountID
	if firstID > secondID {
		firstID, secondID = req.ToAccountID, req.FromAccountID
	}

	var bal1, bal2 int64
	lockSQL := "SELECT current_balance FROM accounts WHERE id = $1 FOR UPDATE"
	if err := tx.QueryRow(ctx, lockSQL, firstID).Scan(&bal1); err != nil {
		return fmt.Errorf("failed to lock %s: %w", firstID, err)
	}
	if err := tx.QueryRow(ctx, lockSQL, secondID).Scan(&bal2); err != nil {
		return fmt.Errorf("failed to lock %s: %w", secondID, err)
	}

	senderBal := bal1
	if firstID != req.FromAccountID {
		senderBal = bal2
	}

	if senderBal < req.Amount {
		return fmt.Errorf("insufficient balance: available %d, required %d", senderBal, req.Amount)
	}

	// 1. Insert immutable journal entry
	var entryID string
	entrySQL := "INSERT INTO journal_entries (idempotency_key, narration, posted_at) VALUES ($1, $2, $3) RETURNING id"
	if err := tx.QueryRow(ctx, entrySQL, req.IdempotencyKey, req.Narration, time.Now().UTC()).Scan(&entryID); err != nil {
		return fmt.Errorf("duplicate idempotency key or journal error: %w", err)
	}

	// 2. Insert balanced journal legs
	legSQL := "INSERT INTO journal_legs (entry_id, account_id, direction, amount, sequence_num) VALUES ($1, $2, $3, $4, $5)"
	if _, err := tx.Exec(ctx, legSQL, entryID, req.FromAccountID, "DR", req.Amount, 1); err != nil {
		return fmt.Errorf("failed to write debit leg: %w", err)
	}
	if _, err := tx.Exec(ctx, legSQL, entryID, req.ToAccountID, "CR", req.Amount, 2); err != nil {
		return fmt.Errorf("failed to write credit leg: %w", err)
	}

	// 3. Update projected balances atomically
	updateSQL := "UPDATE accounts SET current_balance = current_balance + $1 WHERE id = $2"
	if _, err := tx.Exec(ctx, updateSQL, -req.Amount, req.FromAccountID); err != nil {
		return fmt.Errorf("failed to update sender balance: %w", err)
	}
	if _, err := tx.Exec(ctx, updateSQL, req.Amount, req.ToAccountID); err != nil {
		return fmt.Errorf("failed to update recipient balance: %w", err)
	}

	return tx.Commit(ctx)
}

func TestConcurrentTransferInvariants(t *testing.T) {
	ctx := context.Background()
	engine, cleanup := setupTestBankingEngine(t)
	defer cleanup()

	// Initial condition: 10 accounts, each funded with 1,000,000 units ($10,000 total)
	const numAccounts = 10
	const initialBalancePerAccount = 1000000
	expectedTotalMoney := int64(numAccounts * initialBalancePerAccount)

	accounts := seedTestAccounts(t, engine, numAccounts, initialBalancePerAccount)

	const numTransactions = 1000
	var wg sync.WaitGroup
	wg.Add(numTransactions)

	for i := 0; i < numTransactions; i++ {
		go func(txIndex int) {
			defer wg.Done()
			from := accounts[rand.Intn(numAccounts)]
			to := accounts[rand.Intn(numAccounts)]
			for from == to {
				to = accounts[rand.Intn(numAccounts)]
			}

			amount := int64(rand.Intn(50000) + 100)
			key := fmt.Sprintf("tx-stress-%d", txIndex)

			_ = engine.Transfer(ctx, TransferRequest{
				FromAccountID:  from,
				ToAccountID:    to,
				Amount:         amount,
				IdempotencyKey: key,
				Narration:      "Stress Test Transfer",
			})
		}(i)
	}

	wg.Wait()

	// THE FINAL INVARIANT CHECK: Total money in the bank must NEVER change!
	actualTotalMoney := calculateTotalBankMoney(t, engine)
	if actualTotalMoney != expectedTotalMoney {
		t.Fatalf("CRITICAL FINANCIAL BUG: Total bank money drifted! Expected %d, Actual %d (Diff: %d)",
			expectedTotalMoney, actualTotalMoney, actualTotalMoney-expectedTotalMoney)
	}
}

package minicore

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"strings"
	"sync"
	"time"
)

type Account struct {
	ID             string    `json:"id"`
	Currency       string    `json:"currency"`
	BalanceMicros  int64     `json:"balance_micros"`
	OverdraftLimit int64     `json:"overdraft_limit"`
	Status         string    `json:"status"`
	CreatedAt      time.Time `json:"created_at"`
}

type JournalEntry struct {
	ID             string    `json:"id"`
	TransactionID  string    `json:"transaction_id"`
	AccountID      string    `json:"account_id"`
	AmountMicros   int64     `json:"amount_micros"`
	Direction      string    `json:"direction"` // DEBIT or CREDIT
	CreatedAt      time.Time `json:"created_at"`
}

type TransferCommand struct {
	IdempotencyKey string `json:"idempotency_key"`
	SourceID       string `json:"source_id"`
	DestinationID  string `json:"destination_id"`
	AmountMicros   int64  `json:"amount_micros"`
	Currency       string `json:"currency"`
}

type TransferReceipt struct {
	TransactionID string    `json:"transaction_id"`
	SourceID      string    `json:"source_id"`
	DestID        string    `json:"dest_id"`
	AmountMicros  int64     `json:"amount_micros"`
	Currency      string    `json:"currency"`
	Timestamp     time.Time `json:"timestamp"`
}

type Engine struct {
	db *sql.DB
	mu sync.RWMutex
}

func NewEngine(db *sql.DB) *Engine {
	return &Engine{db: db}
}

func (e *Engine) Transfer(ctx context.Context, cmd TransferCommand) (*TransferReceipt, error) {
	if cmd.SourceID == cmd.DestinationID {
		return nil, errors.New("cannot execute transfer between identical accounts")
	}
	if cmd.AmountMicros <= 0 {
		return nil, errors.New("transfer amount must be strictly greater than zero")
	}

	tx, err := e.db.BeginTx(ctx, &sql.TxOptions{
		Isolation: sql.LevelSerializable,
	})
	if err != nil {
		return nil, fmt.Errorf("failed to initiate transaction: %w", err)
	}
	defer tx.Rollback()

	// 1. Check Idempotency Key
	var existingTxID string
	err = tx.QueryRowContext(ctx, "SELECT transaction_id FROM idempotency_keys WHERE key = $1 FOR UPDATE", cmd.IdempotencyKey).Scan(&existingTxID)
	if err == nil {
		return &TransferReceipt{
			TransactionID: existingTxID,
			SourceID:      cmd.SourceID,
			DestID:        cmd.DestinationID,
			AmountMicros:  cmd.AmountMicros,
			Currency:      cmd.Currency,
			Timestamp:     time.Now(),
		}, nil
	} else if !errors.Is(err, sql.ErrNoRows) {
		return nil, fmt.Errorf("idempotency lookup failure: %w", err)
	}

	// 2. Deterministic Lock Acquisition Order
	id1, id2 := cmd.SourceID, cmd.DestinationID
	if strings.Compare(id1, id2) > 0 {
		id1, id2 = cmd.DestinationID, cmd.SourceID
	}

	rows, err := tx.QueryContext(ctx, `
		SELECT id, currency, balance_micros, overdraft_limit, status
		FROM accounts
		WHERE id IN ($1, $2)
		ORDER BY id ASC
		FOR UPDATE;
	`, id1, id2)
	if err != nil {
		return nil, fmt.Errorf("lock acquisition failure: %w", err)
	}
	defer rows.Close()

	accounts := make(map[string]*Account)
	for rows.Next() {
		var a Account
		if err := rows.Scan(&a.ID, &a.Currency, &a.BalanceMicros, &a.OverdraftLimit, &a.Status); err != nil {
			return nil, err
		}
		accounts[a.ID] = &a
	}

	src, okSrc := accounts[cmd.SourceID]
	dst, okDst := accounts[cmd.DestinationID]
	if !okSrc || !okDst {
		return nil, errors.New("one or both participating accounts do not exist")
	}

	if src.Status != "ACTIVE" || dst.Status != "ACTIVE" {
		return nil, errors.New("one or both participating accounts are frozen or inactive")
	}

	// 3. Evaluate Balances
	available := src.BalanceMicros + src.OverdraftLimit
	if available < cmd.AmountMicros {
		return nil, errors.New("insufficient balance and overdraft allowance")
	}

	// 4. Update Balances
	src.BalanceMicros -= cmd.AmountMicros
	dst.BalanceMicros += cmd.AmountMicros

	_, err = tx.ExecContext(ctx, "UPDATE accounts SET balance_micros = $1 WHERE id = $2", src.BalanceMicros, src.ID)
	if err != nil {
		return nil, err
	}
	_, err = tx.ExecContext(ctx, "UPDATE accounts SET balance_micros = $1 WHERE id = $2", dst.BalanceMicros, dst.ID)
	if err != nil {
		return nil, err
	}

	// 5. Append Journal Entries
	txID := fmt.Sprintf("tx_%d", time.Now().UnixNano())
	now := time.Now()

	journalSQL := `
		INSERT INTO journal_entries (id, transaction_id, account_id, amount_micros, direction, created_at)
		VALUES ($1, $2, $3, $4, $5, $6);
	`
	_, err = tx.ExecContext(ctx, journalSQL, fmt.Sprintf("j_%d_1", now.UnixNano()), txID, src.ID, cmd.AmountMicros, "DEBIT", now)
	if err != nil {
		return nil, err
	}
	_, err = tx.ExecContext(ctx, journalSQL, fmt.Sprintf("j_%d_2", now.UnixNano()), txID, dst.ID, cmd.AmountMicros, "CREDIT", now)
	if err != nil {
		return nil, err
	}

	// 6. Record Idempotency Key
	_, err = tx.ExecContext(ctx, "INSERT INTO idempotency_keys (key, transaction_id, created_at) VALUES ($1, $2, $3)", cmd.IdempotencyKey, txID, now)
	if err != nil {
		return nil, err
	}

	if err := tx.Commit(); err != nil {
		return nil, fmt.Errorf("transaction commit failed: %w", err)
	}

	return &TransferReceipt{
		TransactionID: txID,
		SourceID:      src.ID,
		DestID:        dst.ID,
		AmountMicros:  cmd.AmountMicros,
		Currency:      cmd.Currency,
		Timestamp:     now,
	}, nil
}

package minicore

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"time"
)

type AuditDaemon struct {
	db       *sql.DB
	interval time.Duration
}

func NewAuditDaemon(db *sql.DB, interval time.Duration) *AuditDaemon {
	return &AuditDaemon{db: db, interval: interval}
}

func (a *AuditDaemon) Start(ctx context.Context) {
	ticker := time.NewTicker(a.interval)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			if err := a.verifyLedgerInvariant(ctx); err != nil {
				fmt.Printf("EMERGENCY AUDIT ALERT: %v\n", err)
			}
		}
	}
}

func (a *AuditDaemon) verifyLedgerInvariant(ctx context.Context) error {
	query := `
		SELECT 
			COALESCE(SUM(CASE WHEN direction = 'DEBIT' THEN amount_micros ELSE 0 END), 0) AS total_debits,
			COALESCE(SUM(CASE WHEN direction = 'CREDIT' THEN amount_micros ELSE 0 END), 0) AS total_credits
		FROM journal_entries;
	`
	var debits, credits int64
	err := a.db.QueryRowContext(ctx, query).Scan(&debits, &credits)
	if err != nil {
		return fmt.Errorf("audit query failed: %w", err)
	}

	if debits != credits {
		return fmt.Errorf("CRITICAL LEDGER DRIFT: Total Debits (%d) != Total Credits (%d), delta = %d",
			debits, credits, debits-credits)
	}

	return nil
}

CREATE TABLE journal_entries (
    id VARCHAR(64) NOT NULL,
    transaction_id VARCHAR(64) NOT NULL,
    account_id VARCHAR(64) NOT NULL,
    amount_micros BIGINT NOT NULL,
    direction VARCHAR(8) NOT NULL,
    created_at TIMESTAMPTZ NOT NULL,
    PRIMARY KEY (id, created_at)
) PARTITION BY RANGE (created_at);

CREATE TABLE journal_entries_2026_05 PARTITION OF journal_entries
    FOR VALUES FROM ('2026-05-01 00:00:00+00') TO ('2026-06-01 00:00:00+00');

CREATE TABLE journal_entries_2026_06 PARTITION OF journal_entries
    FOR VALUES FROM ('2026-06-01 00:00:00+00') TO ('2026-07-01 00:00:00+00');

package minicore

import (
	"context"
	"fmt"
	"math/rand"
	"sync"
	"sync/atomic"
	"time"
)

type StressTestStats struct {
	TotalTransfers int64
	SuccessfulTx   int64
	FailedTx       int64
	Duration       time.Duration
}

type StressTester struct {
	engine *Engine
}

func NewStressTester(engine *Engine) *StressTester {
	return &StressTester{engine: engine}
}

func (st *StressTester) ExecuteStressTest(
	ctx context.Context,
	concurrency int,
	numAccounts int,
	transactionsPerWorker int,
) (*StressTestStats, error) {
	var totalSuccess int64
	var totalFailed int64
	var wg sync.WaitGroup

	startTime := time.Now()

	for w := 0; w < concurrency; w++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			for i := 0; i < transactionsPerWorker; i++ {
				select {
				case <-ctx.Done():
					return
				default:
				}

				srcNum := rand.Intn(numAccounts) + 1
				dstNum := rand.Intn(numAccounts) + 1
				for dstNum == srcNum {
					dstNum = rand.Intn(numAccounts) + 1
				}

				cmd := TransferCommand{
					IdempotencyKey: fmt.Sprintf("bench_%d_%d_%d", workerID, i, time.Now().UnixNano()),
					SourceID:       fmt.Sprintf("ACC_%06d", srcNum),
					DestinationID:  fmt.Sprintf("ACC_%06d", dstNum),
					AmountMicros:   int64(rand.Intn(5000)+1) * 10000,
					Currency:       "VND",
				}

				_, err := st.engine.Transfer(ctx, cmd)
				if err != nil {
					atomic.AddInt64(&totalFailed, 1)
				} else {
					atomic.AddInt64(&totalSuccess, 1)
				}
			}
		}(w)
	}

	wg.Wait()
	duration := time.Since(startTime)

	return &StressTestStats{
		TotalTransfers: totalSuccess + totalFailed,
		SuccessfulTx:   totalSuccess,
		FailedTx:       totalFailed,
		Duration:       duration,
	}, nil
}