-- DANGEROUS: Fatal anti-pattern in financial ledgers
BEGIN;
  UPDATE accounts SET balance = balance - 500000 WHERE id = 'alice_acc';
  UPDATE accounts SET balance = balance + 500000 WHERE id = 'bob_acc';
COMMIT;

-- 1. Accounts Master Table (Tracks accounts metadata and cached projection)
CREATE TABLE accounts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_number VARCHAR(34) NOT NULL UNIQUE,
    holder_id UUID NOT NULL,
    currency CHAR(3) NOT NULL, -- ISO 4217 (e.g. 'VND', 'USD')
    scale SMALLINT NOT NULL DEFAULT 2, -- e.g. 2 for cents, 0 for VND
    account_category VARCHAR(16) NOT NULL CHECK (account_category IN ('ASSET', 'LIABILITY', 'EQUITY', 'REVENUE', 'EXPENSE')),
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);

-- 2. Journal Transactions Header Table
CREATE TABLE journal_transactions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    idempotency_key VARCHAR(128) NOT NULL UNIQUE,
    reference_id VARCHAR(64) NOT NULL,
    description TEXT NOT NULL,
    posted_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);

-- 3. Immutable Journal Postings (Legs) Table
CREATE TABLE journal_postings (
    id BIGSERIAL PRIMARY KEY,
    transaction_id UUID NOT NULL REFERENCES journal_transactions(id) ON DELETE RESTRICT,
    account_id UUID NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
    amount BIGINT NOT NULL, -- Minor units (positive for DEBIT, negative for CREDIT)
    sequence_num SMALLINT NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);

-- Enforce zero updates or deletes on ledger postings
CREATE OR REPLACE RULE no_update_postings AS ON UPDATE TO journal_postings DO INSTEAD NOTHING;
CREATE OR REPLACE RULE no_delete_postings AS ON DELETE TO journal_postings DO INSTEAD NOTHING;

-- 4. Atomic Deferred Balancing Trigger
CREATE OR REPLACE FUNCTION verify_transaction_balance() RETURNS TRIGGER AS $$
DECLARE
    net_sum BIGINT;
BEGIN
    SELECT COALESCE(SUM(amount), 0) INTO net_sum
    FROM journal_postings
    WHERE transaction_id = NEW.transaction_id;

    IF net_sum <> 0 THEN
        RAISE EXCEPTION 'Financial invariant violated: Transaction % net sum is % (expected 0)', NEW.transaction_id, net_sum;
    END IF;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE CONSTRAINT TRIGGER trg_verify_journal_balance
AFTER INSERT ON journal_postings
DEFERRABLE INITIALLY DEFERRED
FOR EACH ROW
EXECUTE FUNCTION verify_transaction_balance();

// Package main implements a production-grade double-entry ledger engine for 2027 SOTA architectures.
// Utilizes Go 1.25 range-over-func iterators, typed domain error unions, and zero-allocation memory pooling.
package main

import (
	"context"
	"errors"
	"fmt"
	"iter"
	"log/slog"
	"os"
	"sync"
	"time"

	tb "github.com/tigerbeetle/tigerbeetle-go"
	tb_types "github.com/tigerbeetle/tigerbeetle-go/pkg/types"
)

// Standard domain error definitions
var (
	ErrUnbalancedJournal   = errors.New("journal entry is unbalanced: sum of debits must equal sum of credits")
	ErrInsufficientBalance = errors.New("insufficient available balance for transfer hold")
	ErrTransferExpired     = errors.New("pending transfer hold has expired")
	ErrDuplicateIdempotency = errors.New("transfer idempotency key already exists in ledger")
)

// JournalLeg represents a single debit or credit entry in the general ledger
type JournalLeg struct {
	AccountID tb_types.Uint128
	Amount    int64 // Positive: Debit, Negative: Credit
}

// JournalEntry aggregates multiple balanced legs forming an atomic journal transaction
type JournalEntry struct {
	TransactionID tb_types.Uint128
	LedgerID      uint32
	Legs          []JournalLeg
	Timestamp     time.Time
}

// ValidateBalance enforces the accounting invariant: Sum(Debits) + Sum(Credits) == 0.
// Utilizes Go 1.25 range-over-func iterator for zero-allocation traversal.
func (entry *JournalEntry) ValidateBalance() error {
	var netSum int64
	for leg := range entry.AllLegs() {
		netSum += leg.Amount
	}
	if netSum != 0 {
		return fmt.Errorf("%w: net balance discrepancy of %d minor units", ErrUnbalancedJournal, netSum)
	}
	return nil
}

// AllLegs produces an iter.Seq[JournalLeg] iterator compliant with Go 1.25 idioms.
func (entry *JournalEntry) AllLegs() iter.Seq[JournalLeg] {
	return func(yield func(JournalLeg) bool) {
		for _, leg := range entry.Legs {
			if !yield(leg) {
				return
			}
		}
	}
}

// TwoPhaseTransferEngine encapsulates client communication and pending hold management.
type TwoPhaseTransferEngine struct {
	client tb.Client
	logger *slog.Logger
	mu     sync.RWMutex
}

// NewTwoPhaseTransferEngine initializes an active connection to the TigerBeetle cluster.
func NewTwoPhaseTransferEngine(clusterID tb_types.Uint128, addresses []string, logger *slog.Logger) (*TwoPhaseTransferEngine, error) {
	client, err := tb.NewClient(clusterID, addresses)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to TigerBeetle cluster: %w", err)
	}
	return &TwoPhaseTransferEngine{
		client: client,
		logger: logger,
	}, nil
}

// CreatePendingTransfer places a temporary hold on the debtor's balance.
func (e *TwoPhaseTransferEngine) CreatePendingTransfer(
	ctx context.Context,
	transferID tb_types.Uint128,
	debitAcc tb_types.Uint128,
	creditAcc tb_types.Uint128,
	amount uint64,
	timeoutSeconds uint32,
) error {
	e.logger.Info("Initiating two-phase pending transfer hold",
		"transfer_id", transferID.String(),
		"amount", amount,
		"timeout_sec", timeoutSeconds,
	)

	transfers := []tb_types.Transfer{
		{
			ID:              transferID,
			DebitAccountID:  debitAcc,
			CreditAccountID: creditAcc,
			Amount:          tb_types.ToUint128(amount),
			Ledger:          1,    // Core Retail VND Ledger
			Code:            1001, // P2P Instant Transfer Code
			Flags:           tb_types.TransferFlags{Pending: true}.ToUint16(),
			Timeout:         timeoutSeconds,
		},
	}

	results, err := e.client.CreateTransfers(transfers)
	if err != nil {
		e.logger.Error("TigerBeetle transport error during pending transfer", "error", err)
		return err
	}

	for _, res := range results {
		if res.Result != tb_types.TransferOK {
			e.logger.Warn("TigerBeetle rejected transfer request", "code", res.Result)
			return fmt.Errorf("transfer failed with rejection code: %d", res.Result)
		}
	}

	e.logger.Info("Pending transfer hold successfully placed", "transfer_id", transferID.String())
	return nil
}

// PostPendingTransfer commits the reserved funds to final settlement.
func (e *TwoPhaseTransferEngine) PostPendingTransfer(ctx context.Context, postID, pendingTransferID tb_types.Uint128) error {
	e.logger.Info("Posting pending transfer to final settlement",
		"post_id", postID.String(),
		"pending_id", pendingTransferID.String(),
	)

	transfers := []tb_types.Transfer{
		{
			ID:        postID,
			PendingID: pendingTransferID,
			Flags:     tb_types.TransferFlags{PostPendingTransfer: true}.ToUint16(),
		},
	}

	results, err := e.client.CreateTransfers(transfers)
	if err != nil {
		return err
	}

	for _, res := range results {
		if res.Result != tb_types.TransferOK {
			return fmt.Errorf("failed to post pending transfer %s: code %d", pendingTransferID.String(), res.Result)
		}
	}

	e.logger.Info("Transfer successfully settled into permanent ledger", "post_id", postID.String())
	return nil
}

// VoidPendingTransfer rolls back the pending hold and restores available balance.
func (e *TwoPhaseTransferEngine) VoidPendingTransfer(ctx context.Context, voidID, pendingTransferID tb_types.Uint128) error {
	e.logger.Info("Voiding pending transfer hold",
		"void_id", voidID.String(),
		"pending_id", pendingTransferID.String(),
	)

	transfers := []tb_types.Transfer{
		{
			ID:        voidID,
			PendingID: pendingTransferID,
			Flags:     tb_types.TransferFlags{VoidPendingTransfer: true}.ToUint16(),
		},
	}

	results, err := e.client.CreateTransfers(transfers)
	if err != nil {
		return err
	}

	for _, res := range results {
		if res.Result != tb_types.TransferOK {
			return fmt.Errorf("failed to void pending transfer %s: code %d", pendingTransferID.String(), res.Result)
		}
	}

	e.logger.Info("Pending transfer hold successfully voided", "void_id", voidID.String())
	return nil
}

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
	logger.Info("Initializing Core Banking Go 1.25 Ledger Engine")

	// Verify balance invariant verification on sample entry
	sampleEntry := JournalEntry{
		TransactionID: tb_types.ToUint128(7701),
		LedgerID:      1,
		Timestamp:     time.Now(),
		Legs: []JournalLeg{
			{AccountID: tb_types.ToUint128(101), Amount: 500000},  // Debit Alice: 500,000 VND
			{AccountID: tb_types.ToUint128(202), Amount: -500000}, // Credit Bob: 500,000 VND
		},
	}

	if err := sampleEntry.ValidateBalance(); err != nil {
		logger.Error("Accounting invariant check failed", "error", err)
	} else {
		logger.Info("Journal entry validated: Mathematical debit/credit balance verified")
	}
}