package iterator

import (
	"gitee.com/xxbiji/go-iterator/chain"
	"gitee.com/xxbiji/go-iterator/consumer"
	"gitee.com/xxbiji/go-iterator/types"
)

type IterWrapper struct {
	iter types.Iterator
}

func EmptyWrapper() *IterWrapper {
	return &IterWrapper{
		iter: &chain.EmptyIterator{},
	}
}

func WrapIterator(iter types.Iterator) *IterWrapper {
	if iter == nil {
		return EmptyWrapper()
	}
	return &IterWrapper{iter}
}

func (it *IterWrapper) Next() (any, bool) {
	return it.iter.Next()
}

func (it *IterWrapper) Map(fn func(any) any) *IterWrapper {
	return WrapIterator(chain.NewMapChain(it, fn))
}

func (it *IterWrapper) Filter(fn func(any) bool) *IterWrapper {
	return WrapIterator(chain.NewFilterChain(it, fn))
}

func (it *IterWrapper) Take(count int) *IterWrapper {
	return WrapIterator(chain.NewTakeChain(it, count))
}

func (it *IterWrapper) Concat(other types.Iterator) *IterWrapper {
	if other == nil {
		return it
	}
	return WrapIterator(chain.NewConcatChain(it, other))
}

func (it *IterWrapper) Intersperse(separator any) *IterWrapper {
	return WrapIterator(chain.NewIntersperseChain(it, separator))
}

func (it *IterWrapper) IntersperseWith(separator func() any) *IterWrapper {
	return WrapIterator(chain.NewIntersperseWithChain(it, separator))
}

func (it *IterWrapper) Inspect(fn func(any)) *IterWrapper {
	return WrapIterator(chain.NewInspectChain(it, fn))
}

func (it *IterWrapper) Enumerate() *IterWrapper {
	return WrapIterator(chain.NewEnumerateChain(it))
}

func (it *IterWrapper) Scan(base any, fn func(any, any) any) *IterWrapper {
	return WrapIterator(chain.NewScanChain(it, base, fn))
}

func (it *IterWrapper) StepBy(step uint) *IterWrapper {
	return WrapIterator(chain.NewStepChain(it, step))
}

func (it *IterWrapper) ForEach(fn func(any)) {
	consumer.ForEach(it, fn)
}

func (it *IterWrapper) Reduce(base any, fn func(any, any) any) any {
	return consumer.Reduce(it, base, fn)
}

// func (it *IterWrapper) Collect(typ any) any {
// 	refTyp := reflect.TypeOf(typ)
// 	chain.Collect[refTyp]()
// }