seqlog/query.go

package seqlog

import (
	"encoding/binary"
	"fmt"
	"io"
	"os"
)

// RecordStatus 记录处理状态
type RecordStatus int

const (
	StatusProcessed   RecordStatus = iota // 已处理
	StatusProcessing                      // 处理中（当前位置）
	StatusPending                         // 待处理
	StatusUnavailable                     // 不可用（尚未写入）
)

// String 返回状态的字符串表示
func (s RecordStatus) String() string {
	switch s {
	case StatusProcessed:
		return "StatusProcessed"
	case StatusProcessing:
		return "StatusProcessing"
	case StatusPending:
		return "StatusPending"
	case StatusUnavailable:
		return "StatusUnavailable"
	default:
		return "StatusUnknown"
	}
}

// RecordWithStatus 带状态的记录
type RecordWithStatus struct {
	Record *Record
	Index  int          // 记录在日志文件中的索引位置
	Status RecordStatus // 记录的处理状态
}

// RecordWithIndex 带索引的记录
type RecordWithIndex struct {
	Record *Record
	Index  int // 记录在日志文件中的索引位置
}

// RecordQuery 记录查询器
type RecordQuery struct {
	logPath string
	fd      *os.File
	rbuf    []byte       // 复用读缓冲区
	index   *RecordIndex // 索引文件管理器（来自外部）
}

// NewRecordQuery 创建记录查询器
// index 参数必须由外部提供，确保所有组件使用同一个索引实例
func NewRecordQuery(logPath string, index *RecordIndex) (*RecordQuery, error) {
	if index == nil {
		return nil, NewValidationError("index", "index cannot be nil", ErrNilParameter)
	}

	fd, err := os.Open(logPath)
	if err != nil {
		return nil, fmt.Errorf("open log file: %w", err)
	}

	rq := &RecordQuery{
		logPath: logPath,
		fd:      fd,
		rbuf:    make([]byte, 8<<20), // 8 MiB 缓冲区
		index:   index,
	}

	return rq, nil
}

// readRecordsForward 从指定索引位置向前顺序读取记录
// startIndex: 起始记录索引
// count: 读取数量
func (rq *RecordQuery) readRecordsForward(startIndex, count int) ([]*Record, error) {
	// 获取起始 offset
	startOffset, err := rq.index.GetOffset(startIndex)
	if err != nil {
		return nil, fmt.Errorf("get start offset: %w", err)
	}

	if _, err := rq.fd.Seek(startOffset, 0); err != nil {
		return nil, fmt.Errorf("seek to offset %d: %w", startOffset, err)
	}

	results := make([]*Record, 0, count)
	currentOffset := startOffset

	for len(results) < count {
		// 读取头部：[4B len][4B CRC][16B UUID] = 24 字节
		hdr := rq.rbuf[:24]
		if _, err := io.ReadFull(rq.fd, hdr); err != nil {
			if err == io.EOF {
				break
			}
			return nil, fmt.Errorf("read header at offset %d: %w", currentOffset, err)
		}

		rec := &Record{
			Len: binary.LittleEndian.Uint32(hdr[0:4]),
			CRC: binary.LittleEndian.Uint32(hdr[4:8]),
		}
		copy(rec.UUID[:], hdr[8:24])

		// 读取数据
		rec.Data = make([]byte, rec.Len)
		if _, err := io.ReadFull(rq.fd, rec.Data); err != nil {
			return nil, fmt.Errorf("read data at offset %d: %w", currentOffset, err)
		}

		results = append(results, rec)
		currentOffset += 24 + int64(rec.Len)
	}

	return results, nil
}

// QueryOldest 从参考索引向索引递减方向查询记录（查询更早的记录）
// refIndex: 参考索引位置
// count: 查询数量
// 返回的记录按索引递增方向排序，包含索引信息
// 例如：QueryOldest(5, 3) 查询索引 2, 3, 4（不包含 5），返回 [2, 3, 4]
func (rq *RecordQuery) QueryOldest(refIndex, count int) ([]*RecordWithIndex, error) {
	if count <= 0 {
		return nil, NewValidationError("count", "count must be greater than 0", ErrInvalidCount)
	}

	totalCount := rq.index.Count()
	if totalCount == 0 {
		return []*RecordWithIndex{}, nil
	}

	// 验证参考索引范围（严格模式）
	if refIndex < 0 || refIndex > totalCount {
		return nil, NewValidationError("refIndex", fmt.Sprintf("refIndex %d out of range [0, %d]", refIndex, totalCount), ErrInvalidRange)
	}

	// 计算实际起始索引（向索引递减方向）
	startIndex := refIndex - count
	if startIndex < 0 {
		startIndex = 0
		count = refIndex // 调整实际数量
	}

	if count <= 0 {
		return []*RecordWithIndex{}, nil
	}

	// 读取记录
	records, err := rq.readRecordsForward(startIndex, count)
	if err != nil {
		return nil, err
	}

	// 转换为带索引的记录
	results := make([]*RecordWithIndex, len(records))
	for i, rec := range records {
		results[i] = &RecordWithIndex{
			Record: rec,
			Index:  startIndex + i,
		}
	}

	return results, nil
}

// QueryNewest 从参考索引向索引递增方向查询记录（查询更新的记录）
// refIndex: 参考索引位置
// count: 查询数量
// 返回的记录按索引递增方向排序，包含索引信息
// 例如：QueryNewest(5, 3) 查询索引 6, 7, 8（不包含 5），返回 [6, 7, 8]
func (rq *RecordQuery) QueryNewest(refIndex, count int) ([]*RecordWithIndex, error) {
	if count <= 0 {
		return nil, NewValidationError("count", "count must be greater than 0", ErrInvalidCount)
	}

	totalCount := rq.index.Count()
	if totalCount == 0 {
		return []*RecordWithIndex{}, nil
	}

	// 验证参考索引范围（严格模式）
	// QueryNewest 允许 refIndex = -1（从头开始查询）
	if refIndex < -1 || refIndex >= totalCount {
		return nil, NewValidationError("refIndex", fmt.Sprintf("refIndex %d out of range [-1, %d)", refIndex, totalCount), ErrInvalidRange)
	}

	// 计算实际起始索引（向索引递增方向）
	startIndex := refIndex + 1
	if startIndex >= totalCount {
		return []*RecordWithIndex{}, nil
	}

	// 限制查询数量
	remainCount := totalCount - startIndex
	if count > remainCount {
		count = remainCount
	}

	// 读取记录
	records, err := rq.readRecordsForward(startIndex, count)
	if err != nil {
		return nil, err
	}

	// 转换为带索引的记录
	results := make([]*RecordWithIndex, len(records))
	for i, rec := range records {
		results[i] = &RecordWithIndex{
			Record: rec,
			Index:  startIndex + i,
		}
	}

	return results, nil
}

// GetRecordCount 获取记录总数
func (rq *RecordQuery) GetRecordCount() (int, error) {
	return rq.index.Count(), nil
}

// GetRecordStatus 根据游标窗口索引位置获取记录状态
// recordIndex: 记录索引
// startIdx: 窗口开始索引（已处理位置）
// endIdx: 窗口结束索引（当前读取位置）
func GetRecordStatus(recordIndex, startIdx, endIdx int) RecordStatus {
	if recordIndex < startIdx {
		return StatusProcessed
	} else if recordIndex >= startIdx && recordIndex < endIdx {
		return StatusProcessing
	} else {
		return StatusPending
	}
}

// Close 关闭查询器
// 注意：不关闭 index，因为 index 是外部管理的
func (rq *RecordQuery) Close() error {
	// 只关闭日志文件
	if rq.fd != nil {
		return rq.fd.Close()
	}
	return nil
}