-- CỰC KỲ NGUY HIỂM: Phản mẫu (Antipattern) trong hệ thống tài chính!
UPDATE accounts SET balance = balance - 100 WHERE id = 'alice';
UPDATE accounts SET balance = balance + 100 WHERE id = 'bob';

-- PostgreSQL 17 Core Banking Ledger Schema
CREATE TABLE accounts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    customer_id UUID NOT NULL,
    account_number VARCHAR(34) NOT NULL UNIQUE,
    currency VARCHAR(3) NOT NULL,
    account_type VARCHAR(20) NOT NULL, -- ASSET, LIABILITY, EQUITY, REVENUE, EXPENSE
    current_balance BIGINT NOT NULL DEFAULT 0, -- Tính theo đơn vị tiền tệ nhỏ nhất (ví dụ: xu/cents)
    version BIGINT NOT NULL DEFAULT 1,
    created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);

CREATE TABLE journal_entries (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    idempotency_key VARCHAR(64) NOT NULL UNIQUE,
    narration TEXT NOT NULL,
    posted_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);

CREATE TABLE journal_legs (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    entry_id UUID NOT NULL REFERENCES journal_entries(id) ON DELETE RESTRICT,
    account_id UUID NOT NULL REFERENCES accounts(id) ON DELETE RESTRICT,
    direction VARCHAR(2) NOT NULL CHECK (direction IN ('DR', 'CR')),
    amount BIGINT NOT NULL CHECK (amount > 0), -- Luôn lưu số nguyên dương
    sequence_num INT NOT NULL,
    UNIQUE (entry_id, sequence_num)
);

-- Chỉ mục tối ưu hóa truy vấn lịch sử giao dịch và đối soát
CREATE INDEX idx_legs_account_posted ON journal_legs(account_id, id);

package ledger

import (
	"errors"
	"fmt"
)

type Direction string

const (
	Debit  Direction = "DR" // Ghi Nợ
	Credit Direction = "CR" // Ghi Có
)

type JournalLeg struct {
	AccountID string
	Direction Direction
	Amount    int64 // Lưu đơn vị nhỏ nhất (ví dụ: xu, đồng)
}

type JournalEntry struct {
	IdempotencyKey string
	Narration      string
	Legs           []JournalLeg
}

// ValidateInvariant kiểm tra tổng Nợ phải bằng tuyệt đối tổng Có.
func (e *JournalEntry) ValidateInvariant() error {
	if len(e.Legs) < 2 {
		return errors.New("bút toán kế toán phải có tối thiểu 2 chân giao dịch")
	}

	var totalDebit, totalCredit int64
	for _, leg := range e.Legs {
		if leg.Amount <= 0 {
			return fmt.Errorf("số tiền không hợp lệ: %d (bắt buộc phải > 0)", leg.Amount)
		}
		switch leg.Direction {
		case Debit:
			totalDebit += leg.Amount
		case Credit:
			totalCredit += leg.Amount
		default:
			return fmt.Errorf("chiều bút toán không xác định: %s", leg.Direction)
		}
	}

	if totalDebit != totalCredit {
		return fmt.Errorf("vi phạm bất biến cân đối sổ cái: Nợ=%d, Có=%d, chênh lệch=%d",
			totalDebit, totalCredit, totalDebit-totalCredit)
	}

	return nil
}

package ledger

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"sync"
	"time"
)

type JournalRecord struct {
	ID        int64     `json:"id"`
	BatchID   string    `json:"batch_id"`
	AccountID string    `json:"account_id"`
	Amount    int64     `json:"amount"`
	Currency  string    `json:"currency"`
	Direction string    `json:"direction"`
	PrevHash  string    `json:"prev_hash"`
	Hash      string    `json:"hash"`
	CreatedAt time.Time `json:"created_at"`
}

type PartitionedLedgerStore struct {
	mu           sync.RWMutex
	partitions   map[string][]JournalRecord
	latestHashes map[string]string
}

func NewPartitionedLedgerStore() *PartitionedLedgerStore {
	return &PartitionedLedgerStore{
		partitions:   make(map[string][]JournalRecord),
		latestHashes: make(map[string]string),
	}
}

func (s *PartitionedLedgerStore) AppendRecord(ctx context.Context, batchID, accountID, currency, direction string, amount int64) (*JournalRecord, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	partitionKey := time.Now().Format("2006_01_02")
	prevHash, exists := s.latestHashes[partitionKey]
	if !exists {
		prevHash = "0000000000000000000000000000000000000000000000000000000000000000"
	}

	h := sha256.New()
	h.Write([]byte(fmt.Sprintf("%s:%s:%s:%d:%s:%s", batchID, accountID, currency, amount, direction, prevHash)))
	recordHash := hex.EncodeToString(h.Sum(nil))

	record := JournalRecord{
		ID:        int64(len(s.partitions[partitionKey]) + 1),
		BatchID:   batchID,
		AccountID: accountID,
		Amount:    amount,
		Currency:  currency,
		Direction: direction,
		PrevHash:  prevHash,
		Hash:      recordHash,
		CreatedAt: time.Now(),
	}

	s.partitions[partitionKey] = append(s.partitions[partitionKey], record)
	s.latestHashes[partitionKey] = recordHash

	return &record, nil
}

func (s *PartitionedLedgerStore) VerifyPartitionIntegrity(partitionKey string) bool {
	s.mu.RLock()
	defer s.mu.RUnlock()

	records := s.partitions[partitionKey]
	for i := 1; i < len(records); i++ {
		if records[i].PrevHash != records[i-1].Hash {
			return false
		}
	}
	return true
}

package ledger

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

type TrialBalanceReport struct {
	TotalDebits  int64
	TotalCredits int64
	Difference   int64
	Balanced     bool
	GeneratedAt  time.Time
}

type ReconciliationEngine struct {
	mu       sync.RWMutex
	accounts map[string]int64
}

func NewReconciliationEngine() *ReconciliationEngine {
	return &ReconciliationEngine{
		accounts: make(map[string]int64),
	}
}

func (r *ReconciliationEngine) UpdateAccount(accountID string, balance int64) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.accounts[accountID] = balance
}

func (r *ReconciliationEngine) GenerateTrialBalance(ctx context.Context) TrialBalanceReport {
	r.mu.RLock()
	defer r.mu.RUnlock()

	var debits, credits int64
	for _, bal := range r.accounts {
		if bal > 0 {
			debits += bal
		} else {
			credits += -bal
		}
	}

	diff := debits - credits
	return TrialBalanceReport{
		TotalDebits:  debits,
		TotalCredits: credits,
		Difference:   diff,
		Balanced:     diff == 0,
		GeneratedAt:  time.Now(),
	}
}

package ledger

import (
	"context"
	"encoding/json"
	"fmt"
	"sync"
	"time"
)

type CDCEvent struct {
	Operation string        `json:"op"`
	Timestamp time.Time     `json:"ts"`
	Record    JournalRecord `json:"record"`
}

type CDCReplicator struct {
	mu           sync.Mutex
	shadowLedger map[string]int64
}

func NewCDCReplicator() *CDCReplicator {
	return &CDCReplicator{
		shadowLedger: make(map[string]int64),
	}
}

func (r *CDCReplicator) IngestCDCEvent(ctx context.Context, payload []byte) error {
	var ev CDCEvent
	if err := json.Unmarshal(payload, &ev); err != nil {
		return fmt.Errorf("không thể phân tích cú pháp sự kiện CDC: %w", err)
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	if ev.Record.Direction == "DEBIT" {
		r.shadowLedger[ev.Record.AccountID] -= ev.Record.Amount
	} else {
		r.shadowLedger[ev.Record.AccountID] += ev.Record.Amount
	}

	return nil
}

package ledger

import (
	"crypto/sha256"
	"encoding/hex"
)

type MerkleNode struct {
	Left  *MerkleNode
	Right *MerkleNode
	Hash  string
}

func BuildMerkleTree(hashes []string) *MerkleNode {
	if len(hashes) == 0 {
		return nil
	}

	var nodes []*MerkleNode
	for _, h := range hashes {
		nodes = append(nodes, &MerkleNode{Hash: h})
	}

	for len(nodes) > 1 {
		var nextLevel []*MerkleNode
		for i := 0; i < len(nodes); i += 2 {
			if i+1 < len(nodes) {
				combined := nodes[i].Hash + nodes[i+1].Hash
				hasher := sha256.New()
				hasher.Write([]byte(combined))
				parentHash := hex.EncodeToString(hasher.Sum(nil))
				nextLevel = append(nextLevel, &MerkleNode{
					Left:  nodes[i],
					Right: nodes[i+1],
					Hash:  parentHash,
				})
			} else {
				nextLevel = append(nextLevel, nodes[i])
			}
		}
		nodes = nextLevel
	}

	return nodes[0]
}