index

var (
	MinValue = Value{Min, nil}
	MaxValue = Value{Max, nil}
)

var MaxDatom = Datom{math.MaxInt64, math.MaxInt64, MaxValue, math.MaxInt64, true}

var MemoryReadHandlers = map[string]fressian.ReadHandler{
	"mu.memory.Index": func(r *fressian.Reader, tag string, fieldCount int) interface{} {
		datomsRaw, _ := r.ReadValue()
		datoms := datomsRaw.(*btset.Set)
		return &MemoryIndex{datoms}
	},
	"btset.Set":         btset.ReadHandlers["btset.Set"],
	"btset.PointerNode": btset.ReadHandlers["btset.PointerNode"],
	"btset.LeafNode":    btset.ReadHandlers["btset.LeafNode"],
}

var MemoryWriteHandler fressian.WriteHandler = func(w *fressian.Writer, val interface{}) error {
	switch val := val.(type) {
	case *MemoryIndex:
		return w.WriteExt("mu.memory.Index", val.datoms)
	case *MergedIndex:
		return w.WriteExt("mu.memory.Index", val.memory.datoms)
	default:
		return defaultHandler(w, val)
	}
}

var MinDatom = Datom{0, 0, MinValue, 0, false}

var ReadHandlers = map[string]fressian.ReadHandler{
	"mu.Datom": func(r *fressian.Reader, tag string, fieldCount int) interface{} {
		entityRaw, _ := r.ReadValue()
		attributeRaw, _ := r.ReadValue()
		valueRaw, _ := r.ReadValue()
		addedRaw, _ := r.ReadValue()
		transactionRaw, _ := r.ReadValue()
		return &Datom{
			entityRaw.(int),
			attributeRaw.(int),
			NewValue(valueRaw),
			txOffset + transactionRaw.(int),
			addedRaw.(bool),
		}
	},
}

var SegmentReadHandlers = map[string]fressian.ReadHandler{
	"index-root-node": func(r *fressian.Reader, tag string, fieldCount int) interface{} {
		tData, _ := r.ReadValue()
		directoriesRaw, _ := r.ReadValue()

		directories := make([]string, len(directoriesRaw.([]interface{})))
		for i, dir := range directoriesRaw.([]interface{}) {
			directories[i] = dir.(fressian.UUID).String()
		}
		return Root{
			tData:       tData.(TransposedData),
			directories: directories,
		}
	},
	"index-tdata": func(r *fressian.Reader, tag string, fieldCount int) interface{} {
		vs, _ := r.ReadValue()
		es, _ := r.ReadValue()
		as, _ := r.ReadValue()
		txs, _ := r.ReadValue()
		addeds, _ := r.ReadValue()
		transactions := make([]int, len(txs.([]int)))
		for i, tx := range txs.([]int) {
			transactions[i] = 3*(1<<42) + tx
		}
		var values []interface{}
		if values != nil {
			values = vs.([]interface{})
		}
		return TransposedData{
			entities:     es.([]int),
			attributes:   as.([]int),
			values:       values,
			transactions: transactions,
			addeds:       addeds.([]bool),
		}
	},
	"index-dir-node": func(r *fressian.Reader, tag string, fieldCount int) interface{} {
		tData, _ := r.ReadValue()
		segmentsRaw, _ := r.ReadValue()
		mystery1, _ := r.ReadValue()
		mystery2, _ := r.ReadValue()

		segments := make([]string, len(segmentsRaw.([]interface{})))
		for i, dir := range segmentsRaw.([]interface{}) {
			segments[i] = dir.(fressian.UUID).String()
		}
		return Directory{
			tData:    tData.(TransposedData),
			segments: segments,
			mystery1: mystery1.([]int),
			mystery2: mystery2.([]int),
		}
	},
}

var WriteHandler fressian.WriteHandler = func(w *fressian.Writer, val interface{}) error {
	switch val := val.(type) {
	case *Datom:
		return w.WriteExt("mu.Datom", val.entity, val.attribute, val.value, val.added, val.transaction%txOffset)
	case Value:
		return w.WriteValue(val.val)
	default:
		return fressian.DefaultHandler(w, val)
	}

}