either.go

package mo

import (
	"bytes"
	"encoding/gob"
	"errors"
	"fmt"
)

var errEitherShouldBeLeftOrRight = fmt.Errorf("either should be Left or Right")
var errEitherMissingLeftValue = fmt.Errorf("no such Left value")
var errEitherMissingRightValue = fmt.Errorf("no such Right value")

// Left builds the left side of the Either struct, as opposed to the Right side.
func Left[L any, R any](value L) Either[L, R] {
	return Either[L, R]{
		isLeft: true,
		left:   value,
	}
}

// Right builds the right side of the Either struct, as opposed to the Left side.
func Right[L any, R any](value R) Either[L, R] {
	return Either[L, R]{
		isLeft: false,
		right:  value,
	}
}

// Either respresents a value of 2 possible types.
// An instance of Either is an instance of either A or B.
type Either[L any, R any] struct {
	isLeft bool

	left  L
	right R
}

// IsLeft returns true if Either is an instance of Left.
func (e Either[L, R]) IsLeft() bool {
	return e.isLeft
}

// IsRight returns true if Either is an instance of Right.
func (e Either[L, R]) IsRight() bool {
	return !e.isLeft
}

// Left returns left value of a Either struct.
func (e Either[L, R]) Left() (L, bool) {
	if e.IsLeft() {
		return e.left, true
	}
	return empty[L](), false
}

// Right returns right value of a Either struct.
func (e Either[L, R]) Right() (R, bool) {
	if e.IsRight() {
		return e.right, true
	}
	return empty[R](), false
}

// MustLeft returns left value of a Either struct or panics.
func (e Either[L, R]) MustLeft() L {
	if !e.IsLeft() {
		panic(errEitherMissingLeftValue)
	}

	return e.left
}

// MustRight returns right value of a Either struct or panics.
func (e Either[L, R]) MustRight() R {
	if !e.IsRight() {
		panic(errEitherMissingRightValue)
	}

	return e.right
}

// Unpack returns all values
func (e Either[L, R]) Unpack() (L, R) {
	return e.left, e.right
}

// LeftOrElse returns left value of a Either struct or fallback.
func (e Either[L, R]) LeftOrElse(fallback L) L {
	if e.IsLeft() {
		return e.left
	}

	return fallback
}

// RightOrElse returns right value of a Either struct or fallback.
func (e Either[L, R]) RightOrElse(fallback R) R {
	if e.IsRight() {
		return e.right
	}

	return fallback
}

// LeftOrEmpty returns left value of a Either struct or empty value.
func (e Either[L, R]) LeftOrEmpty() L {
	if e.IsLeft() {
		return e.left
	}

	return empty[L]()
}

// RightOrEmpty returns right value of a Either struct or empty value.
func (e Either[L, R]) RightOrEmpty() R {
	if e.IsRight() {
		return e.right
	}

	return empty[R]()
}

// Swap returns the left value in Right and vice versa.
func (e Either[L, R]) Swap() Either[R, L] {
	if e.IsLeft() {
		return Right[R](e.left)
	}

	return Left[R, L](e.right)
}

// ForEach executes the given side-effecting function, depending of value is Left or Right.
func (e Either[L, R]) ForEach(leftCb func(L), rightCb func(R)) {
	if e.IsLeft() {
		leftCb(e.left)
	} else if e.IsRight() {
		rightCb(e.right)
	}
}

// Match executes the given function, depending of value is Left or Right, and returns result.
func (e Either[L, R]) Match(onLeft func(L) Either[L, R], onRight func(R) Either[L, R]) Either[L, R] {
	if e.IsLeft() {
		return onLeft(e.left)
	} else if e.IsRight() {
		return onRight(e.right)
	}

	panic(errEitherShouldBeLeftOrRight)
}

// MapLeft executes the given function, if Either is of type Left, and returns result.
func (e Either[L, R]) MapLeft(mapper func(L) Either[L, R]) Either[L, R] {
	if e.IsLeft() {
		return mapper(e.left)
	} else if e.IsRight() {
		return Right[L, R](e.right)
	}

	panic(errEitherShouldBeLeftOrRight)
}

// MapRight executes the given function, if Either is of type Right, and returns result.
func (e Either[L, R]) MapRight(mapper func(R) Either[L, R]) Either[L, R] {
	if e.isLeft {
		return Left[L, R](e.left)
	} else if e.IsRight() {
		return mapper(e.right)
	}

	panic(errEitherShouldBeLeftOrRight)
}

// leftValue returns left value of a Either struct.(implementation of Foldable interface)
//
//nolint:unused
func (e Either[L, R]) leftValue() L {
	return e.left
}

// rightValue returns right value of a Either struct.(implementation of Foldable interface)
//
//nolint:unused
func (e Either[L, R]) rightValue() R {
	return e.right
}

// hasLeft returns true if the Result represents an error state.
//
//nolint:unused
func (e Either[L, R]) hasLeftValue() bool {
	return e.isLeft
}

// MarshalBinary encodes Either into binary form.
func (e Either[L, R]) MarshalBinary() ([]byte, error) {
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)

	if e.isLeft {
		buf.WriteByte(1)
		if err := enc.Encode(e.left); err != nil {
			return []byte{}, err
		}
		return buf.Bytes(), nil
	}

	buf.WriteByte(0)
	if err := enc.Encode(e.right); err != nil {
		return []byte{}, err
	}
	return buf.Bytes(), nil
}

// UnmarshalBinary decodes Either from binary form.
func (e *Either[L, R]) UnmarshalBinary(data []byte) error {
	if len(data) == 0 {
		return errors.New("Either[L, R].UnmarshalBinary: no data")
	}

	buf := bytes.NewBuffer(data[1:])
	dec := gob.NewDecoder(buf)

	if data[0] == 1 {
		if err := dec.Decode(&e.left); err != nil {
			return err
		}
		e.isLeft = true
		e.right = empty[R]()
		return nil
	}

	if err := dec.Decode(&e.right); err != nil {
		return err
	}
	e.isLeft = false
	e.left = empty[L]()
	return nil
}

// GobEncode implements the gob.GobEncoder interface.
func (e Either[L, R]) GobEncode() ([]byte, error) {
	return e.MarshalBinary()
}

// GobDecode implements the gob.GobDecoder interface.
func (e *Either[L, R]) GobDecode(data []byte) error {
	return e.UnmarshalBinary(data)
}