package channel

type Result[T any] struct {
	value *T
	err   error
}

func ResultOf[T any](value T, err error) Result[T] {
	if err != nil {
		return Result[T]{value: nil, err: err}
	}

	return Result[T]{value: &value, err: nil}
}

func WrapMapFunc[I, O any](f func(I) (O, error)) func(I) Result[O] {
	return func(i I) Result[O] { return ResultOf(f(i)) }
}

func WrapMapResultFunc[I, O any](f func(I) (O, error)) func(Result[I]) Result[O] {
	resFunc := WrapMapFunc(f)
	nilValue := *new(O)
	return func(r Result[I]) Result[O] {
		v, err := r.Get()
		if err != nil {
			return ResultOf(nilValue, err)
		}
		return resFunc(v)
	}
}

func (r Result[T]) Success() bool {
	return r.err == nil
}

func (r Result[T]) Fail() bool {
	return !r.Success()
}

func (r Result[T]) GetOrDefault(defaultValue T) T {
	if r.Fail() {
		return defaultValue
	}

	return *r.value
}

func (r Result[T]) Get() (T, error) {
	return *r.value, r.err
}

func FilterSuccess[T any](source <-chan Result[T]) <-chan T {
	succeeded := Filter(source, func(r Result[T]) bool { return r.Success() })

	return MapSuccessive(succeeded, func(r Result[T]) T {
		v, _ := r.Get()
		return v
	})
}