#include <Arduino.h>

class MathExpressionEvaluator {
public:
    MathExpressionEvaluator(float (*analogReadFunc)(), float (*logarithmFunc)(float), float beta)
        : analogReadFunc(analogReadFunc), logarithmFunc(logarithmFunc), beta(beta) {}

    float evaluate(const String& expression) {
        int i = 0;
        return parseExpression(expression, i);
    }

private:
    float (*analogReadFunc)();
    float (*logarithmFunc)(float);
    float beta;

    float parseExpression(const String& expression, int& i) {
        float result = parseTerm(expression, i);
        while (i < expression.length()) {
            char op = expression[i];
            if (op != '+' && op != '-') {
                // Error: Unsupported operator
                return 0.0f;
            }
            i++; // Move past the operator
            float term = parseTerm(expression, i);
            if (op == '+') {
                result += term;
            } else { // op == '-'
                result -= term;
            }
        }
        return result;
    }

    float parseTerm(const String& expression, int& i) {
        float result = parseFactor(expression, i);
        while (i < expression.length()) {
            char op = expression[i];
            if (op != '*' && op != '/') {
                break;
            }
            i++; // Move past the operator
            float factor = parseFactor(expression, i);
            if (op == '*') {
                result *= factor;
            } else { // op == '/'
                if (factor == 0) {
                    // Error: Division by zero
                    return 0.0f;
                }
                result /= factor;
            }
        }
        return result;
    }

    float parseFactor(const String& expression, int& i) {
        if (i >= expression.length()) {
            // Error: Unexpected end of expression
            return 0.0f;
        }

        char c = expression[i];
        if (c == '(') {
            i++; // Move past '('
            float result = parseExpression(expression, i);
            if (i >= expression.length() || expression[i] != ')') {
                // Error: Missing closing parenthesis
                return 0.0f;
            }
            i++; // Move past ')'
            return result;
        } else if (c == '-' || isdigit(c)) {
            // Parse number
            int start = i;
            while (i < expression.length() && (isdigit(expression[i]) || expression[i] == '.')) {
                i++;
            }
            String numStr = expression.substring(start, i);
            return numStr.toFloat();
        } else if (c == 'a') { // Assuming 'a' denotes analogRead function call
            // Move past 'analogReadValue()'
            i += 15; // Length of "analogReadValue()"
            // Call analogRead function
            return analogReadFunc();
        } else if (c == 'l') { // Assuming 'l' denotes log function call
            // Move past 'logarithm('
            i += 10; // Length of "logarithm("
            // Find the argument
            float arg = parseExpression(expression, i);
            // Move past ')'
            i++;
            // Call logarithm function
            return logarithmFunc(arg);
        } else {
            // Error: Unexpected character
            return 0.0f;
        }
    }
};

float logarithm(float value) {
    // Simulate log() function
    return log(value); // Use the standard logarithm function
}

 float analogReadValueFunc() {
        // Simulate analogRead() function
        return analogRead(15); // Read analog pin A0
    }

void setup() {
    Serial.begin(9600);

    // Define analogReadValue function
   

    MathExpressionEvaluator evaluator(analogReadValueFunc, logarithm, 3950);
    String expression = "1 / (log(1 / (1023. / analogReadValue() - 1)) / BETA + 1.0 / 298.15) - 273.15";
    float result = evaluator.evaluate(expression);

    Serial.print("Result: ");
    Serial.println(result);
}

void loop() {
    // Not used in this example
}