indexlib

type AggDateHistogram struct {
	Field            string
	FixedInterval    int64 // nanos
	CalendarInterval string
	Format           string
	TimeZone         *time.Location
	Offset           any
	MinDocCount      int
	Keyed            bool
	Missing          string
	ExtendedBounds   *DateHistogramBound
	HardBounds       *DateHistogramBound
}

type AggDateRange struct {
	Field    string
	Format   string
	TimeZone *time.Location
	Ranges   []DateRange
	Keyed    bool
}

type AggFilter struct {
	FilterQuery QueryRequest
}

type AggHistogram struct {
	Field          string
	Interval       float64
	MinDocCount    int
	Offset         float64
	Keyed          bool
	Missing        string
	ExtendedBounds *HistogramBound
	HardBounds     *HistogramBound
}

type AggMetric struct {
	Field string
}

type AggNumericRange struct {
	Field  string
	Ranges []NumericRange
	Keyed  bool
}

type AggPercentiles struct {
	Field       string
	Percents    []float64
	Compression float64
}

type AggTerms struct {
	Field     string
	Size      int
	ShardSize int
}

type AggWeightedAvg struct {
	Value  *AggMetric
	Weight *AggMetric
}

type Aggregation struct {
	Value   interface{}       `json:"value,omitempty"`   // metric aggregation
	Buckets []protocol.Bucket `json:"buckets,omitempty"` // bucket aggregation
}

type Aggs struct {
	Terms         *AggTerms
	NumericRange  *AggNumericRange
	DateRange     *AggDateRange
	Count         *AggMetric
	Sum           *AggMetric
	Min           *AggMetric
	Max           *AggMetric
	Avg           *AggMetric
	Cardinality   *AggMetric
	WeightedAvg   *AggWeightedAvg
	Percentiles   *AggPercentiles
	DateHistogram *AggDateHistogram
	Histogram     *AggHistogram
	Filter        *AggFilter
	Aggs          map[string]Aggs
}

type BaseQuery struct {
	Boost float64
	Aggs  map[string]Aggs
	Sort  Sort
}

type BooleanQuery struct {
	*BaseQuery
	Musts     []QueryRequest
	Shoulds   []QueryRequest
	MustNots  []QueryRequest
	Filters   []QueryRequest
	MinShould int
}

type Config struct {
	IndexLib      string
	DirectoryType string
	FS            *FileSystem
	OSS           *ObjectStorageService
}

type DateHistogramBound struct {
	Min int64
	Max int64
}

type DateRange struct {
	To   string
	From string
}

type FileSystem struct {
	Path string
}

type HistogramBound struct {
	Min float64
	Max float64
}

type Hit struct {
	Index     string            `json:"_index"`
	ID        string            `json:"_id"`
	Source    protocol.Document `json:"_source"`
	Timestamp time.Time         `json:"@timestamp"`
	Score     float64           `json:"_score"`
	Type      string            `json:"_type"`
}

type Hits struct {
	Total    Total   `json:"total"`
	Hits     []Hit   `json:"hits"`
	MaxScore float64 `json:"max_score"`
}

type HookReader struct {
	Reader
	CloseHook func(Reader)
}

type LibFieldType struct {
	Type         string               // lib type
	MappingTypes []string             // Tatris mapping types
	Validator    func(value any) bool // used to validate whether the value matches the field type
}

type MatchAllQuery struct {
	*BaseQuery
}

type MatchPhraseQuery struct {
	*BaseQuery
	MatchPhrase string
	Field       string
	Analyzer    string
	Slop        int // Defaults to 0
}

type MatchQuery struct {
	*BaseQuery
	Match     string
	Field     string
	Analyzer  string // STANDARD(default), KEYWORD, SIMPLE, WEB
	Prefix    int    // Defaults to 0
	Fuzziness int
	Operator  string // OR, AND
}

type NumericRange struct {
	To   float64
	From float64
}

type ObjectStorageService struct {
	Endpoint                   string
	Bucket                     string
	AccessKeyID                string
	SecretAccessKey            string
	MinimumConcurrencyLoadSize int
}

type QueryRequest interface {
	SetAggs(aggregations map[string]Aggs)
	GetAggs() map[string]Aggs
	SetSort(sort Sort)
	GetSort() Sort
}

type QueryResponse struct {
	Took         int64                  `json:"took"`
	Hits         Hits                   `json:"hits"`
	Aggregations map[string]Aggregation `json:"aggregations"`
}

type QueryString struct {
	*BaseQuery
	Query    string
	Analyzer string
}

type RangeQuery struct {
	*BaseQuery
	Range map[string]*RangeVal
}

type RangeVal struct {
	GT  interface{}
	GTE interface{}
	LT  interface{}
	LTE interface{}
}

type Reader interface {
	OpenReader() error
	Search(ctx context.Context, req QueryRequest, limit, from int) (*QueryResponse, error)
	Count() int
	Close()
}

type Sort []map[string]SortTerm

type SortTerm struct {
	Order   string
	Missing string
}

type TermQuery struct {
	*BaseQuery
	Term  string
	Field string
}

type Terms struct {
	*BaseQuery
	Fields []string
}

type TermsQuery struct {
	*BaseQuery
	Terms map[string]*Terms
}

type Total struct {
	Value    int64  `json:"value"`
	Relation string `json:"relation"`
}

type Writer interface {
	OpenWriter() error
	Insert(docID string, doc protocol.Document) error
	Batch(docs map[string]protocol.Document) error
	Reader() (Reader, error)
	Close()
}