import re
import sympy as sp
import random

class LinearSolverEngine:
    def __init__(self, lhs, rhs, n=3):
        self.lhs_raw = lhs
        self.rhs_raw = rhs
        self.n = n

    def _clean_string(self, text):
        text = text.lower().replace(" ", "")
        text = re.sub(r'(\d)([a-z])', r'\1*\2', text)
        return text

    def run(self):
        lhs_c = self._clean_string(self.lhs_raw)
        rhs_c = self._clean_string(self.rhs_raw)
        lhs_expr = sp.sympify(lhs_c)
        rhs_expr = sp.sympify(rhs_c)

        full_eq = sp.Eq(lhs_expr, rhs_expr)
        vars_found = sorted(list(full_eq.free_symbols), key=lambda x: x.name)

        if len(vars_found) < 2:
            return "Please enter an equation with 2 variables (e.g., x - v = 6)", [], "N/A"

        input_var = vars_found[0] 
        target_var = vars_found[1] 

        points = [1, 3, 5]
        random.shuffle(points)

        solutions_data = []
        steps = f"Given equation: {self.lhs_raw} = {self.rhs_raw}\n\n"

        for i, val in enumerate(points, 1):

            subbed_eq = full_eq.subs(input_var, val)
            
            plugged_in_str = re.sub(rf'\b{input_var}\b', f"({val})", lhs_c)
            

            target_value = sp.solve(subbed_eq, target_var)[0]
            
            isolated_rhs = sp.solve(subbed_eq, target_var, dict=True)[0][target_var]
            
            steps += f"Solution number {i}:\n"
            steps += f"Step A: Let's take {input_var} as {val}\n"
            steps += f"Step B: Plug it in: {plugged_in_str} = {rhs_c}\n"
            steps += f"Step C: Simplify and solve for {target_var}...\n"
            
            # The "Human-like" math breakdown
            steps += f"{target_var} = {isolated_rhs}\n" 
            steps += f"Result: When {input_var} = {val}, then {target_var} = {target_value}\n"
            steps += f"Point: ({val}, {target_value})\n\n"

            solutions_data.append((float(val), float(target_value)))

        return steps, solutions_data, input_var