stack

var Add = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		so.Stack.Push(so.Stack.Pop() + so.Stack.Pop())
		return so.Stack.Display(), nil
	},
	2, 1,
	"Pop 'a', 'b'; push the result of summing 'a' and 'b'.",
}

var Arccosine = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		f := so.Stack.Pop()
		if f < -1 || f > 1 {
			return "", so.Fail("cannot take arccosine of number less than -1 or greater than 1", f)
		}
		so.Stack.Push(math.Acos(f))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the arccosine of 'a' in radians.",
}

var Arcsine = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		f := so.Stack.Pop()
		if f < -1 || f > 1 {
			return "", so.Fail("cannot take arcsine of number less than -1 or greater than 1", f)
		}
		so.Stack.Push(math.Asin(f))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the arcsine of 'a' in radians.",
}

var Arctangent = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		so.Stack.Push(math.Atan(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the argtangent of 'a' in radians.",
}

var Average = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		n := float64(len(so.Stack.Values))
		Sum.Call(so)
		so.Stack.Push(so.Stack.Pop() / n)
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop all values in the stack; push their average.",
}

var Ceiling = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(math.Ceil(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the least integer value greater than or equal to 'a'.",
}

var Clear = &Action{
	func(so *StackOperator) (string, error) {
		var c byte
		n := len(so.Stack.Values)
		if n != 1 {
			c = 's'
		}
		so.Stack.Values = make([]float64, 0, cap(so.Stack.Values))
		return fmt.Sprintf("cleared %d value%c\n", n, c), nil
	}, 0, 0,
	"Pop all values in the stack.",
}

var ClearScreen = &Action{
	func(so *StackOperator) (string, error) {
		return "\x1b[2J\x1b[H", nil
	}, 0, 0,
	"Clear the terminal screen.",
}

var Clip = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		c := cap(so.Stack.Values)
		so.Stack.Values = slices.Clip(so.Stack.Values)
		return fmt.Sprintf("clipped %d capacity\n", c-cap(so.Stack.Values)), nil
	}, 0, 0,
	"DEBUG; clip unused stack capacity.",
}

var Cosine = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(math.Cos(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the cosine of 'a' in radians.",
}

var Degrees = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(so.Stack.Pop() * 180 / math.Pi)
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the result of converting 'a' from radians to degrees.",
}

var Display = &Action{
	func(so *StackOperator) (string, error) {
		sBuf := make([]string, len(so.Stack.Values))
		for i, f := range so.Stack.Values {
			sBuf[i] = fmt.Sprint(f)
		}
		return fmt.Sprintf("[ %s ]\n", strings.Join(sBuf, " ")), nil
	}, 0, 0,
	"Display all values in the stack.",
}

var Divide = &Action{
	func(so *StackOperator) (string, error) {
		divisor := so.Stack.Pop()
		if divisor == 0 {
			return "", so.Fail("cannot divide by 0", divisor)
		}
		so.Stack.Push(so.Stack.Pop() / divisor)
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the result of dividing 'b' by 'a'.",
}

var Factorial = &Action{
	func(so *StackOperator) (string, error) {
		x := so.Stack.Pop()
		if x != float64(int(x)) {
			return "", so.Fail("cannot take factorial of non-integer", x)
		}
		if x < 0 {
			return "", so.Fail("cannot take factorial of negative number", x)
		}
		p := 1
		for i := 2; i <= int(x); i++ {
			p *= i
		}
		so.Stack.Push(float64(p))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the factorial of 'a'.",
}

var Fill = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		for i := 0; i < cap(so.Stack.Values); i++ {
			if i > len(so.Stack.Values)-1 {
				so.Stack.Values = append(so.Stack.Values, float64(rand.Intn(255)))
			}
		}
		return so.Stack.Display(), nil
	}, 0, 0,
	"DEBUG; fill stack with random values.",
}

var Floor = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(math.Floor(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the greatest integer value less than or equal to 'a'.",
}

var Froll = &Action{
	func(so *StackOperator) (string, error) {
		newVals := make([]float64, 0, cap(so.Stack.Values))
		l := len(so.Stack.Values)
		newVals = append(newVals, so.Stack.Values[l-1])
		for _, f := range so.Stack.Values[:l-1] {
			newVals = append(newVals, f)
		}
		so.Stack.Values = newVals
		return so.Stack.Display(), nil
	}, 2, 2,
	"Roll the stack to the right one position.",
}

var Grow = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		if cap(so.Stack.Values) == 0 {
			so.Stack.Values = slices.Grow(so.Stack.Values, 1)
			return fmt.Sprintf("new stack capacity is %d\n", cap(so.Stack.Values)), nil
		}
		if len(so.Stack.Values) == 0 {
			return "", nil
		}
		n := so.Stack.Pop()
		if n != float64(int(n)) {
			return "", so.Fail("cannot grow stack by non-integer value", n)
		}
		if n < 0 {
			return "", so.Fail("cannot grow stack by negative value", n)
		}
		so.Stack.Push(n)
		so.Stack.Values = slices.Grow(so.Stack.Values, int(n))
		return fmt.Sprintf("new stack capacity is %d\n", cap(so.Stack.Values)), nil
	}, 0, 0,
	"DEBUG; pop 'a'; push 'a'; grow stack to accomadate 'a' more values.",
}

var Help = &Action{
	func(so *StackOperator) (string, error) {
		header := "operator"
		maxLen := len(slices.MaxFunc(so.Actions.List, func(a string, b string) int {
			if len(a) > len(b) {
				return 1
			}
			if len(b) < len(a) {
				return -1
			}
			return 0
		}))
		if maxLen < len(header) {
			maxLen = len(header)
		}
		sb := new(strings.Builder)
		pad := strings.Repeat(" ", maxLen-len(header))
		sb.WriteString(fmt.Sprintf("%s%s | %s\n", pad, header, "description"))
		for k, v, ok := so.Actions.Next(); ok; k, v, ok = so.Actions.Next() {
			if k[0] != 'D' {
				pad := strings.Repeat(" ", maxLen-len(k))
				sb.WriteString(fmt.Sprintf("%s%s : %s\n", pad, k, v.Help))
			}
		}
		return sb.String(), nil
	}, 0, 0,
	"Display this information screen.",
}

var Ln = &Action{
	func(so *StackOperator) (string, error) {
		x := so.Stack.Pop()
		if x <= 0 {
			return "", so.Fail("cannot take logarithm of non-positive number", x)
		}
		so.Stack.Push(math.Log(x))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the natural logarithm of 'a'.",
}

var Log = &Action{
	func(so *StackOperator) (string, error) {
		x := so.Stack.Pop()
		if x <= 0 {
			return "", so.Fail("cannot take logarithm of non-positive number", x)
		}
		so.Stack.Push(math.Log10(x))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the logarithm base 10 of 'a'.",
}

var Modulo = &Action{
	func(so *StackOperator) (string, error) {
		divisor := so.Stack.Pop()
		if divisor == 0 {
			return "", so.Fail("cannot divide by 0", divisor)
		}
		so.Stack.Push(math.Mod(so.Stack.Pop(), divisor))
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the remainder of dividing 'b' by 'a'.",
}

var Multiply = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(so.Stack.Pop() * so.Stack.Pop())
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the result of multiplying 'a' and 'b'.",
}

var Pop = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Pop()
		return so.Stack.Display(), nil
	}, 1, 0,
	"Pop 'a'.",
}

var Power = &Action{
	func(so *StackOperator) (string, error) {
		exponent := so.Stack.Pop()
		base := so.Stack.Pop()
		if base == 0 && exponent < 0 {
			return "", so.Fail("cannot raise 0 to negative power", base, exponent)
		}
		if base < 0 && exponent != float64(int(exponent)) {
			return "", so.Fail("cannot raise negative number to non-integer power", base, exponent)
		}
		so.Stack.Push(math.Pow(base, exponent))
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the result of raising 'b' to the power 'a'.",
}

var Pull = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(so.Stack.Stash)
		return so.Stack.Display(), nil
	}, 0, 1,
	"Push the value in the stash.",
}

var Quit = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		return "", io.EOF
	}, 0, 0,
	"Exit goclacker.",
}

var Radians = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(so.Stack.Pop() * math.Pi / 180)
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the result of converting 'a' from degrees to radians.",
}

var Random = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(rand.Float64())
		return so.Stack.Display(), nil
	}, 0, 1,
	"Push a random number between 0 and 1.",
}

var Round = &Action{
	func(so *StackOperator) (string, error) {
		precision := so.Stack.Pop()
		if precision < 0 || precision != float64(int(precision)) {
			return "", so.Fail("precision must be non-negative integer")
		}
		ratio := math.Pow(10, precision)
		so.Stack.Push(math.Round(so.Stack.Pop()*ratio) / ratio)
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the result of rounding 'b' to 'a' decimal places.",
}

var Rroll = &Action{
	func(so *StackOperator) (string, error) {
		newVals := make([]float64, 0, cap(so.Stack.Values))
		for _, f := range so.Stack.Values[1:] {
			newVals = append(newVals, f)
		}
		newVals = append(newVals, so.Stack.Values[0])
		so.Stack.Values = newVals
		return so.Stack.Display(), nil
	}, 2, 2,
	"Roll the stack to the left one position.",
}

var Sine = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(math.Sin(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the sine of 'a' in radians.",
}

var Stash = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Stash = so.Stack.Pop()
		return so.Stack.Display(), nil
	}, 1, 0,
	"Pop 'a'; stash 'a'.",
}

var Subtract = &Action{
	func(so *StackOperator) (string, error) {
		x := so.Stack.Pop()
		y := so.Stack.Pop()
		so.Stack.Push(y - x)
		return so.Stack.Display(), nil
	}, 2, 1,
	"Pop 'a', 'b'; push the result of subtracting 'a' from 'b'.",
}

var Sum = &Action{
	func(so *StackOperator) (toPrint string, err error) {
		var sum float64
		for len(so.Stack.Values) > 0 {
			sum += so.Stack.Pop()
		}
		so.Stack.Push(sum)
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop all values in the stack; push their sum.",
}

var Swap = &Action{
	func(so *StackOperator) (string, error) {
		x := so.Stack.Pop()
		y := so.Stack.Pop()
		so.Stack.Push(x)
		so.Stack.Push(y)
		return so.Stack.Display(), nil
	}, 2, 2,
	"Pop 'a', 'b'; push 'b', 'a'.",
}

var Tangent = &Action{
	func(so *StackOperator) (string, error) {
		so.Stack.Push(math.Tan(so.Stack.Pop()))
		return so.Stack.Display(), nil
	}, 1, 1,
	"Pop 'a'; push the tangent of 'a' in radians.",
}

var Words = &Action{
	func(so *StackOperator) (string, error) {
		keys := make([]string, len(so.Words)+len(so.ValWords))
		i := 0
		for k := range so.Words {
			keys[i] = k
			i++
		}
		for k := range so.ValWords {
			keys[i] = k
			i++
		}
		maxLen := len(slices.MaxFunc(keys,
			func(a string, b string) int {
				if len(a) > len(b) {
					return 1
				}
				if len(a) < len(b) {
					return -1
				}
				return 0
			},
		))
		slices.SortFunc(keys,
			func(a string, b string) int {
				if len(a) > len(b) {
					return -1
				}
				if len(a) < len(b) {
					return 1
				}
				if a > b {
					return 1
				}
				if a < b {
					return -1
				}
				return 0
			},
		)
		sb := new(strings.Builder)
		for _, k := range keys {
			pad := strings.Repeat(" ", maxLen-len(k))
			val, sep := getWordVal(so, k)
			sb.WriteString(fmt.Sprintf("%s%s %c %s\n", pad, k, sep, val))
		}
		return sb.String(), nil
	}, 0, 0,
	"Display all defined words.",
}