// Licensed to the LF AI & Data foundation under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package datacoord

import (
	"context"
	"fmt"
	"runtime/debug"
	"time"

	"github.com/samber/lo"
	"google.golang.org/protobuf/proto"

	"github.com/milvus-io/milvus-proto/go-api/v3/commonpb"
	"github.com/milvus-io/milvus-proto/go-api/v3/msgpb"
	"github.com/milvus-io/milvus/internal/storage"
	"github.com/milvus-io/milvus/pkg/v3/mlog"
	"github.com/milvus-io/milvus/pkg/v3/proto/datapb"
	"github.com/milvus-io/milvus/pkg/v3/util/paramtable"
)

// SegmentsInfo wraps a map, which maintains ID to SegmentInfo relation
type SegmentsInfo struct {
	segments         map[UniqueID]*SegmentInfo
	secondaryIndexes segmentInfoIndexes
	// map the compact relation, value is the segment which `CompactFrom` contains key.
	// now segment could be compacted to multiple segments
	compactionTo map[UniqueID][]UniqueID
}

type segmentInfoIndexes struct {
	coll2Segments    map[UniqueID]map[UniqueID]*SegmentInfo
	channel2Segments map[string]map[UniqueID]*SegmentInfo
}

// SegmentInfo wraps datapb.SegmentInfo and patches some extra info on it
type SegmentInfo struct {
	*datapb.SegmentInfo
	allocations     []*Allocation
	lastFlushTime   time.Time
	isCompacting    bool
	lastWrittenTime time.Time
}

// EnsureStats returns a non-nil Statistics view for read-only aggregate
// queries. It does NOT mutate s — concurrent readers under m.segMu.RLock()
// would race otherwise. The persisted s.Stats is populated eagerly by
// NewSegmentInfo on construction and by the array-mutating operators
// (AddBinlogsOperator, UpdateBinlogsFromSaveBinlogPathsOperator,
// UpdateSegmentStats), both of which run under m.segMu.Lock(). When a
// caller hands us a SegmentInfo built via the struct literal
// `&SegmentInfo{SegmentInfo: ...}` with a nil Stats (the only remaining
// path is now legacy tests), we fall back to a transient recompute so
// readers see the right number; we just don't write it back.
func (s *SegmentInfo) EnsureStats() *datapb.Statistics {
	if s.SegmentInfo == nil {
		return nil
	}
	if stats := s.GetStats(); stats != nil {
		return stats
	}
	return storage.BuildStatsFromFieldBinlogs(s.GetBinlogs(), s.GetStatslogs(), s.GetBm25Statslogs(), s.GetDeltalogs())
}

func (s *SegmentInfo) GetResidualSegmentSize() int64 {
	if s.GetNumOfRows() == 0 {
		return 0
	}
	deltaRatio := float64(s.EnsureStats().GetDeleteNumRows()) / float64(s.GetNumOfRows())
	if deltaRatio >= 1.0 {
		// segments with too many deleted rows should be considered as prioritized segments and be compacted definitely
		return s.getSegmentSize()
	}
	residualRatio := 1.0 - deltaRatio
	return int64(residualRatio * float64(s.getSegmentSize()))
}

func (s *SegmentInfo) GetEarliestTs() uint64 {
	// For import segments, row timestamps predate the actual commit time.
	// Use commit_timestamp as the effective data age so compaction priority
	// and TTL decisions are not distorted by stale row timestamps.
	if commitTs := s.GetCommitTimestamp(); commitTs != 0 {
		return commitTs
	}
	// Stats.TimestampFrom is the exact min(TimestampFrom) across all insert
	// binlogs (populated by StatisticsCollector on the writer side, or by
	// BuildStatsFromFieldBinlogs on V2 fallback / migration).
	return s.EnsureStats().GetTimestampFrom()
}

// NewSegmentInfo create `SegmentInfo` wrapper from `datapb.SegmentInfo`
// assign current rows to last checkpoint and pre-allocate `allocations` slice
// Note that the allocation information is not preserved,
// the worst case scenario is to have a segment with twice size we expects
//
// Stats is populated from the FieldBinlog arrays when nil so legacy
// segments (persisted before Statistics existed) and live aggregate
// reads agree without callers needing a fallback. EnsureStats covers the
// struct-literal construction path that bypasses this constructor.
func NewSegmentInfo(info *datapb.SegmentInfo) *SegmentInfo {
	if info.Stats == nil {
		info.Stats = storage.BuildStatsFromFieldBinlogs(info.GetBinlogs(), info.GetStatslogs(), info.GetBm25Statslogs(), info.GetDeltalogs())
	}
	s := &SegmentInfo{
		SegmentInfo: info,
	}
	// setup growing fields
	if s.GetState() == commonpb.SegmentState_Growing {
		s.allocations = make([]*Allocation, 0, 16)
		s.lastFlushTime = time.Now().Add(-1 * paramtable.Get().DataCoordCfg.SegmentFlushInterval.GetAsDuration(time.Second))
		// A growing segment from recovery can be also considered idle.
		s.lastWrittenTime = getZeroTime()
	}
	return s
}

// NewSegmentsInfo creates a `SegmentsInfo` instance, which makes sure internal map is initialized
// note that no mutex is wrapped so external concurrent control is needed
func NewSegmentsInfo() *SegmentsInfo {
	return &SegmentsInfo{
		segments: make(map[UniqueID]*SegmentInfo),
		secondaryIndexes: segmentInfoIndexes{
			coll2Segments:    make(map[UniqueID]map[UniqueID]*SegmentInfo),
			channel2Segments: make(map[string]map[UniqueID]*SegmentInfo),
		},
		compactionTo: make(map[UniqueID][]UniqueID),
	}
}

// GetSegment returns SegmentInfo
// the logPath in meta is empty
func (s *SegmentsInfo) GetSegment(segmentID UniqueID) *SegmentInfo {
	segment, ok := s.segments[segmentID]
	if !ok {
		return nil
	}
	return segment
}

// GetSegments iterates internal map and returns all SegmentInfo in a slice
// no deep copy applied
// the logPath in meta is empty
func (s *SegmentsInfo) GetSegments() []*SegmentInfo {
	return lo.Values(s.segments)
}

func (s *SegmentsInfo) getCandidates(criterion *segmentCriterion) map[UniqueID]*SegmentInfo {
	if criterion.collectionID > 0 {
		collSegments, ok := s.secondaryIndexes.coll2Segments[criterion.collectionID]
		if !ok {
			return nil
		}

		// both collection id and channel are filters of criterion
		if criterion.channel != "" {
			return lo.OmitBy(collSegments, func(k UniqueID, v *SegmentInfo) bool {
				return v.InsertChannel != criterion.channel
			})
		}
		return collSegments
	}

	if criterion.channel != "" {
		channelSegments, ok := s.secondaryIndexes.channel2Segments[criterion.channel]
		if !ok {
			return nil
		}
		return channelSegments
	}

	return s.segments
}

func (s *SegmentsInfo) GetSegmentsBySelector(filters ...SegmentFilter) []*SegmentInfo {
	criterion := &segmentCriterion{}
	for _, filter := range filters {
		filter.AddFilter(criterion)
	}

	// apply criterion
	candidates := s.getCandidates(criterion)
	result := make([]*SegmentInfo, 0, len(candidates))
	for _, segment := range candidates {
		if criterion.Match(segment) {
			result = append(result, segment)
		}
	}
	return result
}

func (s *SegmentsInfo) GetRealSegmentsForChannel(channel string) []*SegmentInfo {
	channelSegments := s.secondaryIndexes.channel2Segments[channel]
	var result []*SegmentInfo
	for _, segment := range channelSegments {
		if !segment.GetIsFake() {
			result = append(result, segment)
		}
	}
	return result
}

// GetCompactionTo returns the segment that the provided segment is compacted to.
// Return (nil, false) if given segmentID can not found in the meta and compact to is nil.
// Return (nil, true) if given segmentID can be found with no compaction to.
// Return (notnil, true) if given segmentID can be found and has compaction to.
func (s *SegmentsInfo) GetCompactionTo(fromSegmentID int64) ([]*SegmentInfo, bool) {
	_, exist := s.segments[fromSegmentID]
	if compactTos, ok := s.compactionTo[fromSegmentID]; ok {
		result := []*SegmentInfo{}
		for _, compactTo := range compactTos {
			to, ok := s.segments[compactTo]
			if !ok {
				mlog.Warn(context.TODO(), "compactionTo relation is broken", mlog.Int64("from", fromSegmentID), mlog.Int64("to", compactTo))
				return nil, exist
			}
			result = append(result, to)
		}
		return result, exist
	}
	return nil, exist
}

// DropSegment deletes provided segmentID
// no extra method is taken when segmentID not exists
func (s *SegmentsInfo) DropSegment(segmentID UniqueID) {
	if segment, ok := s.segments[segmentID]; ok {
		s.deleteCompactTo(segment)
		s.removeSecondaryIndex(segment)
		delete(s.segments, segmentID)
	}
}

// SetSegment sets SegmentInfo with segmentID, perform overwrite if already exists
// set the logPath of segment in meta empty, to save space
// if segment has logPath, make it empty
func (s *SegmentsInfo) SetSegment(segmentID UniqueID, segment *SegmentInfo) {
	if segment, ok := s.segments[segmentID]; ok {
		// Remove old segment compact to relation first.
		s.deleteCompactTo(segment)
		s.removeSecondaryIndex(segment)
	}
	s.segments[segmentID] = segment
	s.addSecondaryIndex(segment)
	s.addCompactTo(segment)
}

// SetRowCount sets rowCount info for SegmentInfo with provided segmentID
// if SegmentInfo not found, do nothing
func (s *SegmentsInfo) SetRowCount(segmentID UniqueID, rowCount int64) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.Clone(SetRowCount(rowCount))
	}
}

// SetDmlPosition sets DmlPosition info (checkpoint for recovery) for SegmentInfo with provided segmentID
// if SegmentInfo not found, do nothing
func (s *SegmentsInfo) SetDmlPosition(segmentID UniqueID, pos *msgpb.MsgPosition) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.Clone(SetDmlPosition(pos))
	}
}

// SetStartPosition sets StartPosition info (recovery info when no checkout point found) for SegmentInfo with provided segmentID
// if SegmentInfo not found, do nothing
func (s *SegmentsInfo) SetStartPosition(segmentID UniqueID, pos *msgpb.MsgPosition) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.Clone(SetStartPosition(pos))
	}
}

// SetAllocations sets allocations for segment with specified id
// if the segment id is not found, do nothing
// uses `ShadowClone` since internal SegmentInfo is not changed
func (s *SegmentsInfo) SetAllocations(segmentID UniqueID, allocations []*Allocation) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.ShadowClone(SetAllocations(allocations))
	}
}

// AddAllocation adds a new allocation to specified segment
// if the segment is not found, do nothing
// uses `Clone` since internal SegmentInfo's LastExpireTime is changed
func (s *SegmentsInfo) AddAllocation(segmentID UniqueID, allocation *Allocation) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.Clone(AddAllocation(allocation))
	}
}

// UpdateLastWrittenTime updates segment last writtent time to now.
// if the segment is not found, do nothing
// uses `ShadowClone` since internal SegmentInfo is not changed
func (s *SegmentsInfo) SetLastWrittenTime(segmentID UniqueID) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.ShadowClone(SetLastWrittenTime())
	}
}

// SetFlushTime sets flush time for segment
// if the segment is not found, do nothing
// uses `ShadowClone` since internal SegmentInfo is not changed
func (s *SegmentsInfo) SetFlushTime(segmentID UniqueID, t time.Time) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.ShadowClone(SetFlushTime(t))
	}
}

// SetIsCompacting sets compaction status for segment.
// NOTE: This method manually updates secondary indexes after ShadowClone.
// Other Set methods (SetRowCount, SetLevel, SetFlushTime, etc.) have the same
// stale-index problem but are not yet fixed. See #48593 for the tracking issue
// to extract a common updateSegment helper for all Set methods.
func (s *SegmentsInfo) SetIsCompacting(segmentID UniqueID, isCompacting bool) {
	st := string(debug.Stack())
	mlog.Info(context.TODO(), "set compacting", mlog.FieldSegmentID(segmentID), mlog.Bool("isCompacting", isCompacting), mlog.Any("stacktrace", st))
	if segment, ok := s.segments[segmentID]; ok {
		newSegment := segment.ShadowClone(SetIsCompacting(isCompacting))
		s.segments[segmentID] = newSegment
		if collSegs, ok := s.secondaryIndexes.coll2Segments[segment.GetCollectionID()]; ok {
			collSegs[segmentID] = newSegment
		}
		if chSegs, ok := s.secondaryIndexes.channel2Segments[segment.GetInsertChannel()]; ok {
			chSegs[segmentID] = newSegment
		}
	}
}

func (s *SegmentInfo) IsDeltaLogExists(logID int64) bool {
	for _, deltaLogs := range s.GetDeltalogs() {
		for _, l := range deltaLogs.GetBinlogs() {
			if l.GetLogID() == logID {
				return true
			}
		}
	}
	return false
}

func (s *SegmentInfo) IsStatsLogExists(logID int64) bool {
	for _, statsLogs := range s.GetStatslogs() {
		for _, l := range statsLogs.GetBinlogs() {
			if l.GetLogID() == logID {
				return true
			}
		}
	}
	return false
}

// SetLevel sets level for segment
func (s *SegmentsInfo) SetLevel(segmentID UniqueID, level datapb.SegmentLevel) {
	if segment, ok := s.segments[segmentID]; ok {
		s.segments[segmentID] = segment.ShadowClone(SetLevel(level))
	}
}

// Clone deep clone the segment info and return a new instance. Stats lives
// on the proto and is copied by proto.Clone, so the cloned segment's
// aggregate reads stay consistent with its (cloned) binlog arrays. Opts
// that replace binlogs should also refresh Stats eagerly (recompute via
// storage.BuildStatsFromFieldBinlogs); EnsureStats no longer writes back lazily —
// concurrent RLock readers would race.
func (s *SegmentInfo) Clone(opts ...SegmentInfoOption) *SegmentInfo {
	info := proto.Clone(s.SegmentInfo).(*datapb.SegmentInfo)
	cloned := &SegmentInfo{
		SegmentInfo:     info,
		allocations:     s.allocations,
		lastFlushTime:   s.lastFlushTime,
		isCompacting:    s.isCompacting,
		lastWrittenTime: s.lastWrittenTime,
	}
	for _, opt := range opts {
		opt(cloned)
	}
	return cloned
}

// ShadowClone shadow clone the segment and return a new instance
func (s *SegmentInfo) ShadowClone(opts ...SegmentInfoOption) *SegmentInfo {
	cloned := &SegmentInfo{
		SegmentInfo:     s.SegmentInfo,
		allocations:     s.allocations,
		lastFlushTime:   s.lastFlushTime,
		isCompacting:    s.isCompacting,
		lastWrittenTime: s.lastWrittenTime,
	}
	for _, opt := range opts {
		opt(cloned)
	}
	return cloned
}

func (s *SegmentsInfo) addSecondaryIndex(segment *SegmentInfo) {
	collID := segment.GetCollectionID()
	channel := segment.GetInsertChannel()
	if _, ok := s.secondaryIndexes.coll2Segments[collID]; !ok {
		s.secondaryIndexes.coll2Segments[collID] = make(map[UniqueID]*SegmentInfo)
	}
	s.secondaryIndexes.coll2Segments[collID][segment.ID] = segment

	if _, ok := s.secondaryIndexes.channel2Segments[channel]; !ok {
		s.secondaryIndexes.channel2Segments[channel] = make(map[UniqueID]*SegmentInfo)
	}
	s.secondaryIndexes.channel2Segments[channel][segment.ID] = segment
}

func (s *SegmentsInfo) removeSecondaryIndex(segment *SegmentInfo) {
	collID := segment.GetCollectionID()
	channel := segment.GetInsertChannel()
	if segments, ok := s.secondaryIndexes.coll2Segments[collID]; ok {
		delete(segments, segment.ID)
		if len(segments) == 0 {
			delete(s.secondaryIndexes.coll2Segments, collID)
		}
	}

	if segments, ok := s.secondaryIndexes.channel2Segments[channel]; ok {
		delete(segments, segment.ID)
		if len(segments) == 0 {
			delete(s.secondaryIndexes.channel2Segments, channel)
		}
	}
}

// addCompactTo adds the compact relation to the segment
func (s *SegmentsInfo) addCompactTo(segment *SegmentInfo) {
	for _, from := range segment.GetCompactionFrom() {
		s.compactionTo[from] = append(s.compactionTo[from], segment.GetID())
	}
}

// deleteCompactTo deletes the compact relation to the segment
func (s *SegmentsInfo) deleteCompactTo(segment *SegmentInfo) {
	for _, from := range segment.GetCompactionFrom() {
		delete(s.compactionTo, from)
	}
}

// SegmentInfoOption is the option to set fields in segment info
type SegmentInfoOption func(segment *SegmentInfo)

// SetRowCount is the option to set row count for segment info
func SetRowCount(rowCount int64) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.NumOfRows = rowCount
	}
}

// SetExpireTime is the option to set expire time for segment info
func SetExpireTime(expireTs Timestamp) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.LastExpireTime = expireTs
	}
}

// SetState is the option to set state for segment info
func SetState(state commonpb.SegmentState) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.State = state
	}
}

// SetDmlPosition is the option to set dml position for segment info
func SetDmlPosition(pos *msgpb.MsgPosition) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.DmlPosition = pos
	}
}

// SetStartPosition is the option to set start position for segment info
func SetStartPosition(pos *msgpb.MsgPosition) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.StartPosition = pos
	}
}

// SetAllocations is the option to set allocations for segment info
func SetAllocations(allocations []*Allocation) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.allocations = allocations
	}
}

// AddAllocation is the option to add allocation info for segment info
func AddAllocation(allocation *Allocation) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.allocations = append(segment.allocations, allocation)
		segment.LastExpireTime = allocation.ExpireTime
	}
}

// SetLastWrittenTime is the option to set last writtent time for segment info
func SetLastWrittenTime() SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.lastWrittenTime = time.Now()
	}
}

// SetFlushTime is the option to set flush time for segment info
func SetFlushTime(t time.Time) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.lastFlushTime = t
	}
}

// SetIsCompacting is the option to set compaction state for segment info
func SetIsCompacting(isCompacting bool) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.isCompacting = isCompacting
	}
}

// SetLevel is the option to set level for segment info
func SetLevel(level datapb.SegmentLevel) SegmentInfoOption {
	return func(segment *SegmentInfo) {
		segment.Level = level
	}
}

func (s *SegmentInfo) getSegmentSize() int64 {
	stats := s.EnsureStats()
	return stats.GetInsertBinlogSize() + stats.GetStatsBinlogSize() + stats.GetDeltaBinlogSize()
}

func (s *SegmentInfo) getFieldBinlogSize(fieldID int64) int64 {
	var size int64
	for _, binlogs := range s.GetBinlogs() {
		if binlogs.GetFieldID() == fieldID {
			for _, l := range binlogs.GetBinlogs() {
				size += l.GetMemorySize()
			}
		} else {
			for _, childFieldID := range binlogs.GetChildFields() {
				if childFieldID == fieldID {
					for _, l := range binlogs.GetBinlogs() {
						size += l.GetMemorySize()
					}
				}
			}
		}
	}
	if size <= 0 {
		return s.getSegmentSize()
	}
	return size
}

func (s *SegmentInfo) getDeltaCount() int64 {
	return s.EnsureStats().GetDeleteNumRows()
}

// SegmentInfoSelector is the function type to select SegmentInfo from meta
type SegmentInfoSelector func(*SegmentInfo) bool

// ValidateManifestSegment checks that segments with manifest_path have empty
// legacy stats fields. Returns a descriptive message if validation fails,
// or empty string if the segment is valid.
func ValidateManifestSegment(info *SegmentInfo) string {
	if info.GetManifestPath() == "" {
		return ""
	}

	var nonEmpty []string
	if len(info.GetStatslogs()) > 0 {
		nonEmpty = append(nonEmpty, fmt.Sprintf("statslogs(%d)", len(info.GetStatslogs())))
	}
	if len(info.GetBm25Statslogs()) > 0 {
		nonEmpty = append(nonEmpty, fmt.Sprintf("bm25statslogs(%d)", len(info.GetBm25Statslogs())))
	}
	if len(info.GetTextStatsLogs()) > 0 {
		nonEmpty = append(nonEmpty, fmt.Sprintf("textStatsLogs(%d)", len(info.GetTextStatsLogs())))
	}
	if len(info.GetJsonKeyStats()) > 0 {
		nonEmpty = append(nonEmpty, fmt.Sprintf("jsonKeyStats(%d)", len(info.GetJsonKeyStats())))
	}

	if len(nonEmpty) > 0 {
		return fmt.Sprintf("segment %d has manifest_path but non-empty legacy stats fields: %v",
			info.GetID(), nonEmpty)
	}
	return ""
}

// segmentEffectiveTs returns the start-position timestamp that governs temporal
// decisions for a segment. For import segments with a non-zero commit_timestamp,
// commit_timestamp overrides start_position.Timestamp because the data was not
// "officially present" until the import was committed.
func segmentEffectiveTs(seg *datapb.SegmentInfo) uint64 {
	if ts := seg.GetCommitTimestamp(); ts != 0 {
		return ts
	}
	return seg.GetStartPosition().GetTimestamp()
}

// segmentEffectiveDmlTs returns the DML-position timestamp for temporal decisions.
// Same override logic as segmentEffectiveTs but for dml_position consumers
// (GC eligibility, TruncateChannelByTime).
func segmentEffectiveDmlTs(seg *datapb.SegmentInfo) uint64 {
	if ts := seg.GetCommitTimestamp(); ts != 0 {
		return ts
	}
	return seg.GetDmlPosition().GetTimestamp()
}
