package main

import (
	"errors"
	"regexp"
	"strings"
)

// currently we only cover the invalid keys with this function
// it would be fully validated to cover all cases in the next fix

// this function would be replaced by validating from the expression engine directly to cover all cases
func IsParenthesisBalanced(str string) bool {
	isBalanced := true
	s := make([]rune, 0, len(str))
	for _, c := range str {
		if c == '(' {
			s = append(s, c)
		} else if c == ')' {
			if len(s) == 0 {
				isBalanced = false
				break
			}
			s = s[:len(s)-1]
		}
	}
	if len(s) != 0 {
		isBalanced = false
	}
	return isBalanced
}

// this function would be replaced by mocking  the envrionment keys
// so the the validation would be performed by the expression engine directly to cover all invalid keys
func ContainsInvalidValues(str string, invalid []string) bool {
	for _, i := range invalid {
		if strings.Contains(str, i) {
			return true
		}
	}
	return false
}

func CheckLegalExpression(str string) error {
	re := regexp.MustCompile(`^{[^{}]*?}$`)
	invalid := []string{"TiDB.IOPS", "TiDB.Throughput"}
	if ContainsInvalidValues(str, invalid) {
		return errors.New("expression has invalid values")
	}
	if strings.Contains(str, "{") || strings.Contains(str, "}") {
		if re.MatchString(str) {
			str = strings.TrimPrefix(str, "{")
			str = strings.TrimSuffix(str, "}")
			if !IsParenthesisBalanced(str) {
				return errors.New("expression has inbalanced parenthesis")
			}
			return nil
		}
		return errors.New("expression has malformed format")
	}
	return nil
}