const (
	branchPageFlag   = 0x01
	leafPageFlag     = 0x02
	metaPageFlag     = 0x04
	freelistPageFlag = 0x10
)

// 通过 db 的信息给出真正的 meta, 有可靠的看可靠的，都可靠看事务大的，都没有就 panic 吧。
// meta retrieves the current meta page reference.
func (db *DB) meta() *meta {
	// We have to return the meta with the highest txid which doesn't fail
	// validation. Otherwise, we can cause errors when in fact the database is
	// in a consistent state. metaA is the one with the higher txid.
	metaA := db.meta0
	metaB := db.meta1
	if db.meta1.txid > db.meta0.txid {
		metaA = db.meta1
		metaB = db.meta0
	}

	// Use higher meta page if valid. Otherwise fallback to previous, if valid.
	if err := metaA.validate(); err == nil {
		return metaA
	} else if err := metaB.validate(); err == nil {
		return metaB
	}

	// This should never be reached, because both meta1 and meta0 were validated
	// on mmap() and we do fsync() on every write.
	panic("bolt.DB.meta(): invalid meta pages")
}

func addWeight(db *bolt.DB, weight string, date time.Time) error {
    err := db.Update(func(tx *bolt.Tx) error {
        err := tx.Bucket([]byte("DB")).Bucket([]byte("WEIGHT")).Put([]byte(date.Format(time.RFC3339)), []byte(weight))
        if err != nil {
            return fmt.Errorf("could not insert weight: %v", err)
        }
        return nil
    })
    fmt.Println("Added Weight")
    return err
}

// 读
err = db.View(func(tx *bolt.Tx) error {
    b := tx.Bucket([]byte("DB")).Bucket([]byte("WEIGHT"))
    b.ForEach(func(k, v []byte) error {
        fmt.Println(string(k), string(v))
        return nil
    })
    return nil
})

// Bucket represents a collection of key/value pairs inside the database.
type Bucket struct {
	// bucket: <seq, page_id>
	*bucket

	/**
	 * 下面是对应的内存结构
	 */

	tx *Tx // the associated transaction
	// Note: 只有写事务才有 buckets cache
	buckets map[string]*Bucket // subbucket cache

	// inline page
	page *page // inline page reference
	// root page 在内存中的缓存. 这个的 root 是 tree 的 root.
	rootNode *node // materialized node for the root page.

	// Note: 只有写事务才有 nodes cache
	nodes map[pgid]*node // node cache

	// Sets the threshold for filling nodes when they split. By default,
	// the bucket will fill to 50% but it can be useful to increase this
	// amount if you know that your write workloads are mostly append-only.
	//
	// This is non-persisted across transactions so it must be set in every Tx.
	FillPercent float64
}

// bucket represents the on-file representation of a bucket.
// This is stored as the "value" of a bucket key. If the bucket is small enough,
// then its root page can be stored inline in the "value", after the bucket
// header.
//
// In the case of inline buckets, the "root" will be 0.
type bucket struct {
	root     pgid   // page id of the bucket's root-level page
	sequence uint64 // monotonically incrementing, used by NextSequence()
}

// 对应的 page id
type pgid uint64

type page struct {
	id pgid
	// 对应上面的 flag, 有几种类型：
	// * freelist: 单独的 freelist page
	// 下面三种都是对应到 Btree 的
	// * leaf
	// * meta
	// * branch
	flags uint16
	// count 是一个 u16, 所以有的地方最大只给了 0xFFFF
	count uint16
	// overflow page, 一个 id, 表示 [id, id + overflow] 是这个 page 的逻辑范围
	overflow uint32
	// 保存的实际内容
	// 这个 ptr 实际上是 data 段
	ptr uintptr
}

// node represents an in-memory, deserialized page.
type node struct {
	// 自身存在的 bucket, 对于 branch 和 leaf 来说，共享同一个 bucket
	bucket *Bucket
	// 是否是 leaf page
	isLeaf bool
	// 下面应该和 btree 的状态有关。
	// unbalanced 和 rebalance 有关，暗示某个 leaf 可能过小，需要 balance
	// spill 和某个过大有关，暗示需要 spill
	unbalanced bool
	spilled    bool

	// node 起始的 key
	// NOTE: key 的内容可能引自 mmap, 可能是不可修改的
	key  []byte
	pgid pgid

	parent *node
	// 子节点
	children nodes
	// 存储 Page 中的 value
	// inode 类型类似 tagged enum, 是一个 flag + [ leaf 的值 | branch 的值 ]
	// NOTE: inode 的内容引自 mmap, 是不可修改的
	inodes inodes
}

// 看来是有剩余空间就丢到 freelist 里面，page_id 是可以重用的 id
// 这个应该是一个磁盘化结构。在 `read` 和 `write` 两个地方读写盘。
// 但是 ids 会持久化, 本来以为 pending 是个内存结构，但是实际上 pending 也是会持久化的，它处理的是两种内容：
// 1. 正在写入事务写过的 page
// 2. 写完了，正在被读引用的 page
// 把 1 写下去实际上是危险的，我看了下代码，只有 Commit 的时候，确保成功，才会调用 write, 这个时候 1 在逻辑是被转成 2 了。
// cache...你见过 cache 非内存的不。
//
// freelist represents a list of all pages that are available for allocation.
// It also tracks pages that have been freed but are still in use by open transactions.
type freelist struct {
	ids     []pgid          // all free and available free page ids.
	pending map[txid][]pgid // mapping of soon-to-be free page ids by tx.
	cache   map[pgid]bool   // fast lookup of all free and pending page ids.
}

// spill writes the nodes to dirty pages and splits nodes as it goes.
// Returns an error if dirty pages cannot be allocated.
//
// 1. 先递归对所有 children 调用 spill
// 2. split 自己， 按照 pageSize 和 percent 分成 n 个 page, 他们会共有一个 parent.
// 3. 针对2的结果，有必要的话 free 掉旧 page，然后 allocate 新的 page id 写上去
// 4. 如果分裂出来的新父节点需要 spill, 那就 spill 它，保证整个树操作完成
// 5. **注意**: commit 的时候会 rebalance && spill, spill 之后，node 不再会被读，所以递归的时候，子 node 不需要维护关系。
func (n *node) spill() error {...}