calculator.js

// Убираем require для браузерной совместимости и используем альтернативы
// const math = require('mathjs');
// const Fraction = require('fraction.js');

// Продвинутый математический движок с мощным парсером выражений
const AdvancedMathEngine = {
    // Константы
    constants: {
        'pi': Math.PI,
        'e': Math.E,
        'phi': (1 + Math.sqrt(5)) / 2, // Золотое сечение
        'ln2': Math.LN2,
        'ln10': Math.LN10,
        'log2e': Math.LOG2E,
        'log10e': Math.LOG10E,
        'sqrt1_2': Math.SQRT1_2,
        'sqrt2': Math.SQRT2,
        'infinity': Infinity,
        'inf': Infinity
    },

    // Расширенные функции
    functions: {
        // Тригонометрия
        'sin': Math.sin,
        'cos': Math.cos,
        'tan': Math.tan,
        'asin': Math.asin,
        'acos': Math.acos,
        'atan': Math.atan,
        'atan2': Math.atan2,
        'sinh': Math.sinh,
        'cosh': Math.cosh,
        'tanh': Math.tanh,
        'asinh': Math.asinh,
        'acosh': Math.acosh,
        'atanh': Math.atanh,

        // Логарифмы и экспоненты
        'log': Math.log10,
        'ln': Math.log,
        'log2': Math.log2,
        'exp': Math.exp,
        'expm1': Math.expm1,
        'log1p': Math.log1p,

        // Степени и корни
        'sqrt': Math.sqrt,
        'cbrt': Math.cbrt,
        'pow': Math.pow,
        'root': function(n, x) { return Math.pow(x, 1/n); },

        // Округление
        'abs': Math.abs,
        'sign': Math.sign,
        'floor': Math.floor,
        'ceil': Math.ceil,
        'round': Math.round,
        'trunc': Math.trunc,
        'frac': function(x) { return x - Math.trunc(x); },

        // Минимум и максимум
        'min': Math.min,
        'max': Math.max,

        // Случайные числа
        'random': Math.random,
        'randomInt': function(min, max) { 
            return Math.floor(Math.random() * (max - min + 1)) + min; 
        },

        // Дополнительные функции
        'factorial': function(n) {
            if (n < 0 || !Number.isInteger(n)) return NaN;
            if (n <= 1) return 1;
            let result = 1;
            for (let i = 2; i <= n; i++) {
                result *= i;
                if (!isFinite(result)) return Infinity;
            }
            return result;
        },

        'gcd': function(a, b) {
            a = Math.abs(Math.trunc(a));
            b = Math.abs(Math.trunc(b));
            while (b !== 0) {
                [a, b] = [b, a % b];
            }
            return a;
        },

        'lcm': function(a, b) {
            return Math.abs(a * b) / this.gcd(a, b);
        },

        'deg': function(rad) {
            return rad * 180 / Math.PI;
        },

        'rad': function(deg) {
            return deg * Math.PI / 180;
        },

        'mod': function(a, b) {
            return ((a % b) + b) % b;
        },

        'isPrime': function(n) {
            n = Math.trunc(n);
            if (n <= 1) return false;
            if (n <= 3) return true;
            if (n % 2 === 0 || n % 3 === 0) return false;
            for (let i = 5; i * i <= n; i += 6) {
                if (n % i === 0 || n % (i + 2) === 0) return false;
            }
            return true;
        },

        'fibonacci': function(n) {
            n = Math.trunc(n);
            if (n <= 0) return 0;
            if (n === 1) return 1;
            let a = 0, b = 1;
            for (let i = 2; i <= n; i++) {
                [a, b] = [b, a + b];
            }
            return b;
        },

        'combinations': function(n, r) {
            n = Math.trunc(n);
            r = Math.trunc(r);
            if (r > n || r < 0) return 0;
            if (r === 0 || r === n) return 1;
            r = Math.min(r, n - r);
            let result = 1;
            for (let i = 0; i < r; i++) {
                result *= (n - i) / (i + 1);
            }
            return Math.round(result);
        },

        'permutations': function(n, r) {
            n = Math.trunc(n);
            r = Math.trunc(r);
            if (r > n || r < 0) return 0;
            let result = 1;
            for (let i = 0; i < r; i++) {
                result *= (n - i);
            }
            return result;
        },

        // Дроби
        'toFraction': function(decimal, tolerance = 1e-10) {
            let h1 = 1, h2 = 0, k1 = 0, k2 = 1;
            let b = decimal;
            do {
                let a = Math.floor(b);
                let aux = h1; h1 = a * h1 + h2; h2 = aux;
                aux = k1; k1 = a * k1 + k2; k2 = aux;
                b = 1 / (b - a);
            } while (Math.abs(decimal - h1/k1) > tolerance && k1 < 1000000);
            return {numerator: h1, denominator: k1, string: h1 + '/' + k1};
        }
    },

    // Улучшенная токенизация с поддержкой дробей, процентов, модулей и Unicode символов
    tokenize: function(expr) {
        // Нормализация Unicode математических символов
        expr = expr
            .replace(/−/g, '-')  // Unicode минус → обычный минус
            .replace(/×/g, '*')  // Unicode умножение → звездочка
            .replace(/÷/g, '/')  // Unicode деление → слэш
            .replace(/π/g, 'pi') // Unicode пи → pi
            .replace(/∞/g, 'Infinity') // Unicode бесконечность
            .replace(/√/g, 'sqrt') // Unicode корень → sqrt
            .replace(/²/g, '^2') // Unicode степень 2
            .replace(/³/g, '^3') // Unicode степень 3
            .replace(/⁻¹/g, '^(-1)') // Unicode обратная степень
            .replace(/∑/g, 'sum') // Unicode сумма
            .replace(/∏/g, 'product') // Unicode произведение
            .replace(/∫/g, 'integral') // Unicode интеграл
            .replace(/≈/g, '~') // Unicode приблизительно равно
            .replace(/≠/g, '!=') // Unicode не равно
            .replace(/≤/g, '<=') // Unicode меньше или равно
            .replace(/≥/g, '>=') // Unicode больше или равно
            .replace(/⋅/g, '*') // Unicode точка умножения
            .replace(/∘/g, '*') // Unicode композиция функций
            .replace(/∙/g, '*'); // Unicode bullet operator
        
        const tokens = [];
        let i = 0;
        
        while (i < expr.length) {
            const char = expr[i];
            
            // Пропускаем пробелы
            if (/\s/.test(char)) {
                i++;
                continue;
            }
            
            // Обработка модуля |...| 
            if (char === '|') {
                // Проверяем, это открывающий или закрывающий модуль
                // Ищем предыдущий незакрытый ABS_START
                let hasOpenAbs = false;
                for (let j = tokens.length - 1; j >= 0; j--) {
                    if (tokens[j].type === 'ABS_END') {
                        break; // Найден закрывающий, значит предыдущий ABS_START уже закрыт
                    }
                    if (tokens[j].type === 'ABS_START') {
                        hasOpenAbs = true;
                        break;
                    }
                }
                
                if (hasOpenAbs) {
                    tokens.push({ type: 'ABS_END' });
                } else {
                    tokens.push({ type: 'ABS_START' });
                }
                i++;
                continue;
            }
            
            // Обработка квадратного корня √
            if (char === '√') {
                tokens.push({ type: 'FUNCTION', value: 'sqrt' });
                i++;
                continue;
            }
            
            // Числа с поддержкой дробей a/b
            if (/\d/.test(char) || (char === '.' && i + 1 < expr.length && /\d/.test(expr[i + 1]))) {
                let num = '';
                let j = i;
                
                // Читаем первое число
                while (j < expr.length && (/\d/.test(expr[j]) || expr[j] === '.')) {
                    num += expr[j++];
                }
                
                // Проверяем, есть ли дробь
                if (j < expr.length && expr[j] === '/' && j + 1 < expr.length && /\d/.test(expr[j + 1])) {
                    num += '/';
                    j++;
                    while (j < expr.length && /\d/.test(expr[j])) {
                        num += expr[j++];
                    }
                    
                    // Парсим дробь
                    const parts = num.split('/');
                    const numerator = parseFloat(parts[0]);
                    const denominator = parseFloat(parts[1]);
                    
                    if (denominator === 0) throw new Error('Деление на ноль в дроби');
                    
                    tokens.push({ type: 'NUMBER', value: numerator / denominator, original: num });
                    i = j;
                    continue;
                }
                
                // Проверяем научную нотацию
                if (j < expr.length && (expr[j] === 'e' || expr[j] === 'E')) {
                    num += expr[j++];
                    if (j < expr.length && (expr[j] === '+' || expr[j] === '-')) {
                        num += expr[j++];
                    }
                    while (j < expr.length && /\d/.test(expr[j])) {
                        num += expr[j++];
                    }
                }
                
                const numValue = parseFloat(num);
                if (isNaN(numValue)) {
                    throw new Error(`Некорректное число: ${num}`);
                }
                tokens.push({ type: 'NUMBER', value: numValue });
                i = j;
                continue;
            }
            
            // Процент %
            if (char === '%') {
                // Если это оператор процента (после числа)
                if (tokens.length > 0 && tokens[tokens.length - 1].type === 'NUMBER') {
                    tokens.push({ type: 'PERCENT' });
                } else {
                    // Это модуло оператор
                    tokens.push({ type: 'OPERATOR', value: '%' });
                }
                i++;
                continue;
            }
            
            // Операторы и символы (поддержка Unicode)
            if ('+-*/^()'.includes(char) || char === '−' || char === '×' || char === '÷') {
                // Нормализуем Unicode символы
                let normalizedChar = char;
                if (char === '−') normalizedChar = '-';
                if (char === '×') normalizedChar = '*';
                if (char === '÷') normalizedChar = '/';
                
                tokens.push({ type: 'OPERATOR', value: normalizedChar });
                i++;
                continue;
            }
            
            // Двойная звездочка ** для степени
            if (char === '*' && i + 1 < expr.length && expr[i + 1] === '*') {
                tokens.push({ type: 'OPERATOR', value: '^' });
                i += 2;
                continue;
            }
            
            // Запятая как разделитель аргументов функций
            if (char === ',') {
                tokens.push({ type: 'COMMA' });
                i++;
                continue;
            }
            
            // Функции и константы
            if (/[a-zA-Z_]/.test(char)) {
                let name = '';
                while (i < expr.length && (/[a-zA-Z_0-9]/.test(expr[i]))) {
                    name += expr[i++];
                }
                
                if (this.functions[name]) {
                    tokens.push({ type: 'FUNCTION', value: name });
                } else if (this.constants[name]) {
                    tokens.push({ type: 'NUMBER', value: this.constants[name] });
                } else {
                    throw new Error(`Неизвестная функция или константа: ${name}`);
                }
                continue;
            }
            
            // Факториал
            if (char === '!') {
                tokens.push({ type: 'FACTORIAL' });
                i++;
                continue;
            }
            
            throw new Error(`Неожиданный символ: ${char} на позиции ${i}`);
        }
        
        return tokens;
    },

    // Улучшенный парсинг в обратную польскую нотацию с поддержкой модулей и процентов
    toRPN: function(tokens) {
        const output = [];
        const operators = [];
        const precedence = { 
            '+': 1, '-': 1, 
            '*': 2, '/': 2, '%': 2, 
            '^': 4,
            'u-': 5,  // унарный минус
            'u+': 5   // унарный плюс
        };
        const rightAssoc = { '^': true };
        const argCounts = []; // Стек для подсчета аргументов функций
        let absStack = []; // Стек для отслеживания модулей
        
        // Предварительная обработка для унарных операторов
        for (let i = 0; i < tokens.length; i++) {
            const token = tokens[i];
            const prevToken = i > 0 ? tokens[i - 1] : null;
            
            // Определяем унарный минус и плюс
            if (token.type === 'OPERATOR' && (token.value === '-' || token.value === '+')) {
                if (i === 0 || 
                    (prevToken && (prevToken.type === 'OPERATOR' && prevToken.value === '(' ||
                     prevToken.type === 'COMMA' ||
                     (prevToken.type === 'OPERATOR' && prevToken.value !== ')')))) {
                    token.value = 'u' + token.value;
                    token.unary = true;
                }
            }
        }
        
        for (let i = 0; i < tokens.length; i++) {
            const token = tokens[i];
            
            if (token.type === 'NUMBER') {
                output.push(token);
                // Увеличиваем счетчик аргументов для текущей функции
                if (argCounts.length > 0) {
                    argCounts[argCounts.length - 1]++;
                }
            } else if (token.type === 'ABS_START') {
                // Начало модуля - добавляем как функцию abs
                operators.push({ type: 'FUNCTION', value: 'abs' });
                operators.push({ type: 'OPERATOR', value: '(' });
                argCounts.push(0);
                absStack.push(operators.length - 1);
            } else if (token.type === 'ABS_END') {
                // Конец модуля - закрываем функцию abs
                while (operators.length && operators[operators.length - 1].value !== '(') {
                    output.push(operators.pop());
                }
                if (operators.length && operators[operators.length - 1].value === '(') {
                    operators.pop(); // Убираем '('
                    
                    // Добавляем функцию abs
                    if (operators.length && operators[operators.length - 1].type === 'FUNCTION') {
                        const func = operators.pop();
                        output.push(func);
                        argCounts.pop();
                    }
                }
                if (absStack.length > 0) {
                    absStack.pop();
                }
            } else if (token.type === 'FUNCTION') {
                operators.push(token);
                argCounts.push(0); // Начинаем подсчет аргументов для новой функции
            } else if (token.type === 'COMMA') {
                // Обрабатываем запятую как разделитель аргументов
                while (operators.length && operators[operators.length - 1].value !== '(') {
                    output.push(operators.pop());
                }
                if (argCounts.length > 0) {
                    argCounts[argCounts.length - 1]++;
                }
            } else if (token.type === 'PERCENT') {
                // Преобразуем последнее число в проценты (делим на 100)
                if (output.length > 0 && output[output.length - 1].type === 'NUMBER') {
                    output[output.length - 1].value = output[output.length - 1].value / 100;
                }
            } else if (token.type === 'OPERATOR') {
                if (token.value === '(') {
                    operators.push(token);
                } else if (token.value === ')' || token.value === '|') {
                    // Закрытие скобки или модуля
                    while (operators.length && operators[operators.length - 1].value !== '(') {
                        output.push(operators.pop());
                    }
                    if (operators.length) {
                        operators.pop(); // Убираем '('
                    }
                    
                    // Если это было закрытие модуля
                    if (token.value === '|' && absStack.length > 0) {
                        absStack.pop();
                    }
                    
                    if (operators.length && operators[operators.length - 1].type === 'FUNCTION') {
                        const func = operators.pop();
                        const argCount = argCounts.length > 0 ? argCounts.pop() : 1;
                        func.argCount = argCount || 1;
                        output.push(func);
                    }
                } else if (token.unary) {
                    // Унарные операторы имеют высокий приоритет
                    operators.push(token);
                } else {
                    // Бинарные операторы
                    while (operators.length && 
                           operators[operators.length - 1].value !== '(' &&
                           operators[operators.length - 1].type !== 'FUNCTION' &&
                           !operators[operators.length - 1].unary &&
                           ((precedence[operators[operators.length - 1].value] || 0) > precedence[token.value] ||
                            (precedence[operators[operators.length - 1].value] === precedence[token.value] && !rightAssoc[token.value]))) {
                        output.push(operators.pop());
                    }
                    operators.push(token);
                }
            } else if (token.type === 'FACTORIAL') {
                output.push(token);
            }
        }
        
        while (operators.length) {
            const op = operators.pop();
            if (op.type === 'FUNCTION') {
                op.argCount = op.argCount || 1; // Функция без скобок имеет 1 аргумент
            }
            output.push(op);
        }
        
        return output;
    },

    // Улучшенное вычисление RPN с поддержкой всех операций
    evaluateRPN: function(rpn) {
        const stack = [];
        
        for (const token of rpn) {
            if (token.type === 'NUMBER') {
                stack.push(token.value);
            } else if (token.type === 'OPERATOR') {
                if (token.unary) {
                    // Унарные операторы
                    const a = stack.pop();
                    if (a === undefined) throw new Error(`Недостаточно операндов для унарного ${token.value}`);
                    
                    if (token.value === 'u-') {
                        stack.push(-a);
                    } else if (token.value === 'u+') {
                        stack.push(+a);
                    }
                } else {
                    // Бинарные операторы
                    const b = stack.pop();
                    const a = stack.pop();
                    if (a === undefined || b === undefined) {
                        throw new Error(`Недостаточно операндов для ${token.value}`);
                    }
                    
                    switch (token.value) {
                        case '+':
                            stack.push(a + b);
                            break;
                        case '-':
                            stack.push(a - b);
                            break;
                        case '*':
                            stack.push(a * b);
                            break;
                        case '/':
                            if (b === 0) throw new Error('Деление на ноль');
                            stack.push(a / b);
                            break;
                        case '%':
                            if (b === 0) throw new Error('Деление на ноль в операции модуло');
                            stack.push(a % b);
                            break;
                        case '^':
                            stack.push(Math.pow(a, b));
                            break;
                        default:
                            throw new Error(`Неизвестный оператор: ${token.value}`);
                    }
                }
            } else if (token.type === 'FUNCTION') {
                const func = this.functions[token.value];
                if (!func) throw new Error(`Неизвестная функция: ${token.value}`);
                
                const argCount = token.argCount || 1;
                const args = [];
                
                for (let i = 0; i < argCount; i++) {
                    const arg = stack.pop();
                    if (arg === undefined) {
                        throw new Error(`Недостаточно аргументов для функции ${token.value}`);
                    }
                    args.unshift(arg);
                }
                
                try {
                    const result = func.apply(this.functions, args);
                    if (typeof result !== 'number' || !isFinite(result)) {
                        if (token.value === 'factorial' && !isFinite(result)) {
                            stack.push(Infinity);
                        } else {
                            throw new Error(`Функция ${token.value} вернула некорректный результат`);
                        }
                    } else {
                        stack.push(result);
                    }
                } catch (error) {
                    throw new Error(`Ошибка в функции ${token.value}: ${error.message}`);
                }
            } else if (token.type === 'FACTORIAL') {
                const a = stack.pop();
                if (a === undefined) throw new Error('Недостаточно операндов для факториала');
                const result = this.functions.factorial(a);
                stack.push(result);
            }
        }
        
        if (stack.length !== 1) {
            throw new Error('Некорректное выражение: неверный баланс операций');
        }
        
        return stack[0];
    },

    // Основная функция вычисления - самый мощный движок!
    evaluate: function(expression) {
        try {
            // Предварительная обработка
            let expr = expression.toString()
                .replace(/\s+/g, ' ')
                .trim();
            
            if (!expr) throw new Error('Пустое выражение');
            
            // Заменяем альтернативные символы и нотации
            expr = expr.replace(/\*\*/g, '^')         // ** → ^
                      .replace(/×/g, '*')             // × → *
                      .replace(/÷/g, '/')             // ÷ → /
                      .replace(/√/g, 'sqrt')          // √ → sqrt
                      .replace(/π/g, 'pi')            // π → pi  
                      .replace(/∞/g, 'infinity')      // ∞ → infinity
                      .replace(/±/g, '+/-')           // ± → +/-
                      .replace(/∓/g, '-/+')           // ∓ → -/+
                      .replace(/≠/g, '!=')            // ≠ → !=
                      .replace(/≤/g, '<=')            // ≤ → <=
                      .replace(/≥/g, '>=')            // ≥ → >=
                      .replace(/∑/g, 'sum')           // ∑ → sum
                      .replace(/∏/g, 'product')       // ∏ → product
                      .replace(/∫/g, 'integral')      // ∫ → integral
                      .replace(/∂/g, 'partial')       // ∂ → partial
                      .replace(/∇/g, 'nabla')         // ∇ → nabla
                      .replace(/∀/g, 'forall')        // ∀ → forall
                      .replace(/∃/g, 'exists')        // ∃ → exists
                      .replace(/∈/g, 'in')            // ∈ → in
                      .replace(/∉/g, 'notin')         // ∉ → notin
                      .replace(/⊂/g, 'subset')        // ⊂ → subset
                      .replace(/⊃/g, 'superset')      // ⊃ → superset
                      .replace(/∪/g, 'union')         // ∪ → union
                      .replace(/∩/g, 'intersection'); // ∩ → intersection
            
            // Обработка процентов в контексте (50% от 200 = 50/100 * 200)
            expr = expr.replace(/(\d+(?:\.\d+)?)\s*%\s*от\s*(\d+(?:\.\d+)?)/gi, '($1/100)*$2');
            expr = expr.replace(/(\d+(?:\.\d+)?)\s*%\s*of\s*(\d+(?:\.\d+)?)/gi, '($1/100)*$2');
            
            // Обработка смешанных чисел (2 3/4 = 2 + 3/4)
            expr = expr.replace(/(\d+)\s+(\d+\/\d+)/g, '($1+$2)');
            
            // Добавляем поддержку неявного умножения
            expr = expr.replace(/(\d)([a-z])/gi, '$1*$2');        // 2x → 2*x
            expr = expr.replace(/([a-z])(\d)/gi, '$1*$2');        // x2 → x*2
            expr = expr.replace(/(\))(\d)/g, '$1*$2');            // )2 → )*2
            expr = expr.replace(/(\d)(\()/g, '$1*$2');            // 2( → 2*(
            expr = expr.replace(/(\))(\()/g, '$1*$2');            // )( → )*(
            expr = expr.replace(/([a-z])(\()/gi, '$1*$2');        // x( → x*(
            expr = expr.replace(/(\d)(sqrt|sin|cos|tan|log|ln)/gi, '$1*$2'); // 2sin → 2*sin
            
            // Обработка модулей |...| 
            let absCount = 0;
            expr = expr.replace(/\|/g, () => {
                absCount++;
                return absCount % 2 === 1 ? '|' : '|';
            });
            
            // Проверяем парность модулей
            if (absCount % 2 !== 0) {
                throw new Error('Несбалансированные модули |...|');
            }
            
            // Обрабатываем унарный минус и плюс в начале и после операторов
            expr = expr.replace(/^-/, '0-');                       // Начальный минус
            expr = expr.replace(/^\\+/, '0+');                     // Начальный плюс
            expr = expr.replace(/\(-/g, '(0-');                    // После (
            expr = expr.replace(/\(\\+/g, '(0+');                 // После (
            expr = expr.replace(/([+\-*/^%,])\s*-/g, '$10-');     // После операторов
            expr = expr.replace(/([+\-*/^%,])\s*\\+/g, '$10+');   // После операторов
            
            // Проверяем баланс скобок
            let openParens = 0;
            for (let char of expr) {
                if (char === '(') openParens++;
                else if (char === ')') openParens--;
                if (openParens < 0) throw new Error('Несбалансированные скобки');
            }
            if (openParens !== 0) throw new Error('Несбалансированные скобки');
            
            // Токенизация
            const tokens = this.tokenize(expr);
            if (tokens.length === 0) throw new Error('Пустое выражение');
            
            // Преобразование в RPN
            const rpn = this.toRPN(tokens);
            
            // Вычисление
            let result = this.evaluateRPN(rpn);
            
            // Проверка результата
            if (!isFinite(result)) {
                if (result === Infinity) return '∞';
                if (result === -Infinity) return '-∞';
                throw new Error('Результат не является конечным числом');
            }
            
            // Форматирование результата с точностью до 10 знаков
            if (Number.isInteger(result)) {
                return result;
            } else {
                // Убираем лишние нули и ограничиваем точность
                let formatted = parseFloat(result.toFixed(10));
                
                // Проверяем, можно ли представить как простую дробь
                if (Math.abs(formatted) < 1000000) {
                    const fraction = this.functions.toFraction(formatted, 1e-8);
                    if (fraction.denominator <= 1000 && 
                        Math.abs(formatted - fraction.numerator/fraction.denominator) < 1e-10) {
                        return `${formatted} (${fraction.string})`;
                    }
                }
                
                return formatted;
            }
            
        } catch (error) {
            throw new Error(`Ошибка вычисления: ${error.message}`);
        }
    },

    // Дополнительные утилиты для мощного движка
    formatResult: function(value, options = {}) {
        const { precision = 10, showFraction = true, scientific = false } = options;
        
        if (!isFinite(value)) {
            if (value === Infinity) return '∞';
            if (value === -Infinity) return '-∞';
            return 'NaN';
        }
        
        if (Number.isInteger(value)) {
            return value.toString();
        }
        
        if (scientific && (Math.abs(value) >= 1e15 || Math.abs(value) <= 1e-5)) {
            return value.toExponential(precision);
        }
        
        let result = parseFloat(value.toFixed(precision)).toString();
        
        if (showFraction && Math.abs(value) < 1000) {
            const fraction = this.functions.toFraction(value);
            if (fraction.denominator <= 100) {
                result += ` (${fraction.string})`;
            }
        }
        
        return result;
    },

    // Проверка корректности выражения
    validate: function(expression) {
        try {
            this.tokenize(expression);
            return { valid: true, error: null };
        } catch (error) {
            return { valid: false, error: error.message };
        }
    },

    // Получение информации о функциях и константах
    getHelp: function() {
        return {
            constants: Object.keys(this.constants),
            functions: Object.keys(this.functions),
            operators: ['+', '-', '*', '/', '^', '%', '!', '|...|'],
            examples: [
                'sqrt(25) = 5',
                '2^3 = 8',
                'sin(pi/2) = 1',
                '5! = 120',
                '|3-7| = 4',
                '50% = 0.5',
                '1/2 + 1/3 = 0.833333 (5/6)',
                'gcd(12, 18) = 6',
                'combinations(5, 2) = 10'
            ]
        };
    }
};

// Простая реализация математических операций (заменяем на новый движок)
const MathUtils = {
    evaluate: function(expr) {
        return AdvancedMathEngine.evaluate(expr);
    },
    
    gcd: function(a, b) {
        while (b !== 0) {
            let temp = b;
            b = a % b;
            a = temp;
        }
        return Math.abs(a);
    },
    
    lcm: function(a, b) {
        return Math.abs(a * b) / this.gcd(a, b);
    },

    // Дополнительные математические функции
    isPrime: function(n) {
        if (n < 2) return false;
        if (n === 2) return true;
        if (n % 2 === 0) return false;
        for (let i = 3; i <= Math.sqrt(n); i += 2) {
            if (n % i === 0) return false;
        }
        return true;
    },

    fibonacci: function(n) {
        if (n <= 0) return 0;
        if (n === 1) return 1;
        let a = 0, b = 1;
        for (let i = 2; i <= n; i++) {
            [a, b] = [b, a + b];
        }
        return b;
    },

    factorial: function(n) {
        if (n < 0 || !Number.isInteger(n)) throw new Error('Неверные данные');
        if (n === 0 || n === 1) return 1;
        let result = 1;
        for (let i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    },

    combinations: function(n, r) {
        if (r > n || r < 0) return 0;
        return this.factorial(n) / (this.factorial(r) * this.factorial(n - r));
    },

    permutations: function(n, r) {
        if (r > n || r < 0) return 0;
        return this.factorial(n) / this.factorial(n - r);
    },

    degToRad: function(deg) {
        return deg * Math.PI / 180;
    },

    radToDeg: function(rad) {
        return rad * 180 / Math.PI;
    },

    quadraticSolver: function(a, b, c) {
        const discriminant = b * b - 4 * a * c;
        if (discriminant < 0) {
            return { real: false, roots: [] };
        } else if (discriminant === 0) {
            return { real: true, roots: [-b / (2 * a)] };
        } else {
            const sqrtDisc = Math.sqrt(discriminant);
            return {
                real: true,
                roots: [(-b + sqrtDisc) / (2 * a), (-b - sqrtDisc) / (2 * a)]
            };
        }
    },

    mean: function(numbers) {
        return numbers.reduce((a, b) => a + b, 0) / numbers.length;
    },

    median: function(numbers) {
        const sorted = [...numbers].sort((a, b) => a - b);
        const mid = Math.floor(sorted.length / 2);
        return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
    },

    mode: function(numbers) {
        const frequency = {};
        numbers.forEach(num => frequency[num] = (frequency[num] || 0) + 1);
        const maxFreq = Math.max(...Object.values(frequency));
        return Object.keys(frequency).filter(key => frequency[key] === maxFreq).map(Number);
    },

    standardDeviation: function(numbers) {
        const avg = this.mean(numbers);
        const variance = numbers.reduce((sum, num) => sum + Math.pow(num - avg, 2), 0) / numbers.length;
        return Math.sqrt(variance);
    },

    // Конвертация единиц измерения
    convertTemperature: function(value, from, to) {
        let celsius;
        switch(from) {
            case 'F': celsius = (value - 32) * 5/9; break;
            case 'K': celsius = value - 273.15; break;
            default: celsius = value;
        }
        
        switch(to) {
            case 'F': return celsius * 9/5 + 32;
            case 'K': return celsius + 273.15;
            default: return celsius;
        }
    },

    convertLength: function(value, from, to) {
        const toMeters = {
            'mm': 0.001, 'cm': 0.01, 'm': 1, 'km': 1000,
            'in': 0.0254, 'ft': 0.3048, 'yd': 0.9144, 'mi': 1609.34
        };
        return value * toMeters[from] / toMeters[to];
    },

    convertWeight: function(value, from, to) {
        const toKg = {
            'mg': 0.000001, 'g': 0.001, 'kg': 1, 't': 1000,
            'oz': 0.0283495, 'lb': 0.453592
        };
        return value * toKg[from] / toKg[to];
    }
};

// Простая реализация дробей
class SimpleFraction {
    constructor(numerator, denominator = 1) {
        if (typeof numerator === 'string') {
            const parts = numerator.split('/');
            this.n = parseInt(parts[0]);
            this.d = parseInt(parts[1]) || 1;
        } else {
            this.n = numerator;
            this.d = denominator;
        }
        this.simplify();
    }
    
    simplify() {
        const gcd = MathUtils.gcd(this.n, this.d);
        this.n /= gcd;
        this.d /= gcd;
        if (this.d < 0) {
            this.n *= -1;
            this.d *= -1;
        }
    }
    
    valueOf() {
        return this.n / this.d;
    }
    
    toString() {
        return this.d === 1 ? this.n.toString() : `${this.n}/${this.d}`;
    }
}

// Переводы
const translations = {
    ru: {
        'app-title': 'Advanced Calculator',
        'history': 'История',
        'settings': 'Настройки',
        'basic-mode': 'Основной',
        'scientific-mode': 'Научный',
        'fraction-mode': 'Дроби',
        'advanced-mode': 'Расширенный',
        'clear-history': 'Очистить всё',
        'language': 'Язык',
        'theme': 'Тема',
        'decimal-places': 'Знаков после запятой',
        'dark-theme': 'Тёмная',
        'black-theme': 'Чёрная',
        'simplify': 'Упрост.',
        'improper': 'Неправ.',
        
        // Модальные окна
        'modal-title-fraction': 'Ввод дроби',
        'modal-message-fraction': 'Введите дробь в формате "числитель/знаменатель":',
        'modal-title-mixed': 'Смешанная дробь',
        'modal-message-mixed': 'Введите смешанную дробь в формате "целое числитель/знаменатель":',
        'modal-title-gcd': 'НОД (Наибольший общий делитель)',
        'modal-message-gcd': 'Введите два числа через запятую:',
        'modal-title-lcm': 'НОК (Наименьшее общее кратное)',
        'modal-message-lcm': 'Введите два числа через запятую:',
        'modal-title-fibonacci': 'Числа Фибоначчи',
        'modal-message-fibonacci': 'Введите номер числа Фибоначчи (0-100):',
        'modal-title-combinations': 'Сочетания C(n,r)',
        'modal-message-combinations': 'Введите n,r для C(n,r):',
        'modal-title-permutations': 'Размещения P(n,r)',
        'modal-message-permutations': 'Введите n,r для P(n,r):',
        'modal-title-quadratic': 'Квадратное уравнение',
        'modal-message-quadratic': 'Введите коэффициенты a,b,c для ax²+bx+c=0:',
        'modal-title-statistics': 'Статистика',
        'modal-message-statistics': 'Введите числа через запятую:',
        'modal-title-temperature': 'Конвертация температуры',
        'modal-message-temperature': 'Введите: значение,из,в (C/F/K):',
        'modal-title-length': 'Конвертация длины',
        'modal-message-length': 'Введите: значение,из,в (mm,cm,m,km,in,ft,yd,mi):',
        'modal-title-weight': 'Конвертация веса',
        'modal-message-weight': 'Введите: значение,из,в (mg,g,kg,t,oz,lb):',
        'modal-cancel': 'Отмена',
        'modal-confirm': 'ОК',
        'auto-calc-title': 'Автоматические вычисления',
        'prime-yes': 'Простое',
        'prime-no': 'Составное',
        'no-real-roots': 'Нет действительных корней',
        'average': 'Среднее',
        'median': 'Медиана',
        'std-dev': 'СКО',
        'statistics-count': 'чисел',
        
        // Автоматические вычисления
        'auto-calc-square': 'Квадрат',
        'auto-calc-cube': 'Куб',
        'auto-calc-sqrt': 'Квадратный корень',
        'auto-calc-cbrt': 'Кубический корень',
        'auto-calc-reciprocal': 'Обратное',
        'auto-calc-percent': 'Процент',
        'auto-calc-factorial': 'Факториал',
        'auto-calc-sin': 'Синус',
        'auto-calc-cos': 'Косинус',
        'auto-calc-tan': 'Тангенс',
        'auto-calc-ln': 'Натуральный логарифм',
        'auto-calc-log': 'Десятичный логарифм',
        'auto-calc-unavailable': 'Недоступно',
        'auto-calc-div-zero': 'Деление на ноль',
        'auto-calc-button': 'Авто-вычисления',
        'beta-badge': 'БЕТА',
        'expression-editor': 'Редактор выражений',
        'expression-editor-title': 'Умный ввод выражений',
        'expression-placeholder': 'Введите математическое выражение...',
        'expression-help': 'Примеры: 2+3*4, sin(45), sqrt(16), 2^3, log(100), 5!, gcd(12,8), fibonacci(10), combinations(10,3)',
        'calculate': 'Вычислить',
        'expression-result': 'Результат',
        'expression-error': 'Ошибка в выражении',
        'insert-result': 'Вставить в калькулятор',
        'modal-input-placeholder': 'Введите данные...',
        'fullscreen-mode': '🖥️ Полноэкранный режим',
        
        // Расширенные функции
        'prime-check': 'Простое?',
        'fibonacci': 'Фиб',
        'combinations': 'C(n,r)',
        'permutations': 'P(n,r)',
        'quadratic': 'ax²+bx+c',
        'statistics': 'Статистика',
        'deg-rad': 'DEG/RAD',
        'convert-temp': '°C/°F/K',
        'convert-length': 'Длина',
        'convert-weight': 'Вес',
        'memory-store': 'MS',
        'memory-recall': 'MR',
        
        // Установщик
        'download-installer': 'Скачать установщик',
        'download-installer-title': 'Скачать установщик калькулятора',
        'app-name': 'Продвинутый Калькулятор',
        'app-version': 'Версия 2.0.0',
        'app-description': 'Продвинутый калькулятор с поддержкой сложных математических выражений',
        'portable-version': '📱 Портативная версия',
        'portable-description': 'Не требует установки, запускается сразу',
        'download-portable': 'Скачать Portable (5 МБ)',
        'installer-version': '💾 Установщик Windows',
        'installer-description': 'Полная установка с ярлыками в меню',
        'download-installer-exe': 'Скачать установщик (7 МБ)',
        'system-req': 'Системные требования:',
        'req-windows': 'Windows 7/8/10/11 (64-bit)',
        'req-memory': 'Минимум 100 МБ свободного места',
        'req-features': 'Поддержка научных вычислений'
    },
    en: {
        'app-title': 'Advanced Calculator',
        'history': 'History',
        'settings': 'Settings',
        'basic-mode': 'Basic',
        'scientific-mode': 'Scientific',
        'fraction-mode': 'Fractions',
        'advanced-mode': 'Advanced',
        'clear-history': 'Clear All',
        'language': 'Language',
        'theme': 'Theme',
        'decimal-places': 'Decimal Places',
        'dark-theme': 'Dark',
        'black-theme': 'Black',
        'simplify': 'Simplify',
        'improper': 'Improper',
        
        // Modal windows
        'modal-title-fraction': 'Enter Fraction',
        'modal-message-fraction': 'Enter fraction in format "numerator/denominator":',
        'modal-title-mixed': 'Mixed Fraction',
        'modal-message-mixed': 'Enter mixed fraction in format "whole numerator/denominator":',
        'modal-title-gcd': 'GCD (Greatest Common Divisor)',
        'modal-message-gcd': 'Enter two numbers separated by comma:',
        'modal-title-lcm': 'LCM (Least Common Multiple)',
        'modal-message-lcm': 'Enter two numbers separated by comma:',
        'modal-title-fibonacci': 'Fibonacci Numbers',
        'modal-message-fibonacci': 'Enter Fibonacci number position (0-100):',
        'modal-title-combinations': 'Combinations C(n,r)',
        'modal-message-combinations': 'Enter n,r for C(n,r):',
        'modal-title-permutations': 'Permutations P(n,r)',
        'modal-message-permutations': 'Enter n,r for P(n,r):',
        'modal-title-quadratic': 'Quadratic Equation',
        'modal-message-quadratic': 'Enter coefficients a,b,c for ax²+bx+c=0:',
        'modal-title-statistics': 'Statistics',
        'modal-message-statistics': 'Enter numbers separated by comma:',
        'modal-title-temperature': 'Temperature Conversion',
        'modal-message-temperature': 'Enter: value,from,to (C/F/K):',
        'modal-title-length': 'Length Conversion',
        'modal-message-length': 'Enter: value,from,to (mm,cm,m,km,in,ft,yd,mi):',
        'modal-title-weight': 'Weight Conversion',
        'modal-message-weight': 'Enter: value,from,to (mg,g,kg,t,oz,lb):',
        'modal-cancel': 'Cancel',
        'modal-confirm': 'OK',
        'auto-calc-title': 'Automatic Calculations',
        'prime-yes': 'Prime',
        'prime-no': 'Composite',
        'no-real-roots': 'No real roots',
        'average': 'Average',
        'median': 'Median',
        'std-dev': 'Std Dev',
        'statistics-count': 'numbers',
        
        // Automatic calculations
        'auto-calc-square': 'Square',
        'auto-calc-cube': 'Cube',
        'auto-calc-sqrt': 'Square root',
        'auto-calc-cbrt': 'Cube root',
        'auto-calc-reciprocal': 'Reciprocal',
        'auto-calc-percent': 'Percent',
        'auto-calc-factorial': 'Factorial',
        'auto-calc-sin': 'Sine',
        'auto-calc-cos': 'Cosine',
        'auto-calc-tan': 'Tangent',
        'auto-calc-ln': 'Natural logarithm',
        'auto-calc-log': 'Common logarithm',
        'auto-calc-unavailable': 'Unavailable',
        'auto-calc-div-zero': 'Division by zero',
        'auto-calc-button': 'Auto-calc',
        'beta-badge': 'BETA',
        'expression-editor': 'Expression Editor',
        'expression-editor-title': 'Smart Expression Input',
        'expression-placeholder': 'Enter mathematical expression...',
        'expression-help': 'Examples: 2+3*4, sin(45), sqrt(16), 2^3, log(100), 5!, gcd(12,8), fibonacci(10), combinations(10,3)',
        'calculate': 'Calculate',
        'expression-result': 'Result',
        'expression-error': 'Expression error',
        'insert-result': 'Insert to calculator',
        'modal-input-placeholder': 'Enter data...',
        'fullscreen-mode': '🖥️ Fullscreen Mode',
        
        // Advanced functions
        'prime-check': 'Prime?',
        'fibonacci': 'Fib',
        'combinations': 'C(n,r)',
        'permutations': 'P(n,r)',
        'quadratic': 'ax²+bx+c',
        'statistics': 'Statistics',
        'deg-rad': 'DEG/RAD',
        'convert-temp': '°C/°F/K',
        'convert-length': 'Length',
        'convert-weight': 'Weight',
        'memory-store': 'MS',
        'memory-recall': 'MR',
        
        // Installer
        'download-installer': 'Download Installer',
        'download-installer-title': 'Download Calculator Installer',
        'app-name': 'Advanced Calculator',
        'app-version': 'Version 2.0.0',
        'app-description': 'Advanced calculator with complex mathematical expressions support',
        'portable-version': '📱 Portable Version',
        'portable-description': 'No installation required, runs immediately',
        'download-portable': 'Download Portable (5 MB)',
        'installer-version': '💾 Windows Installer',
        'installer-description': 'Full installation with menu shortcuts',
        'download-installer-exe': 'Download Installer (7 MB)',
        'system-req': 'System Requirements:',
        'req-windows': 'Windows 7/8/10/11 (64-bit)',
        'req-memory': 'Minimum 100 MB free space',
        'req-features': 'Scientific calculations support'
    },
    no: {
        'app-title': 'Avansert Kalkulator',
        'history': 'Historie',
        'settings': 'Innstillinger',
        'basic-mode': 'Grunnleggende',
        'scientific-mode': 'Vitenskapelig',
        'fraction-mode': 'Brøker',
        'advanced-mode': 'Avansert',
        'clear-history': 'Tøm Alt',
        'language': 'Språk',
        'theme': 'Tema',
        'decimal-places': 'Desimalplasser',
        'dark-theme': 'Mørk',
        'black-theme': 'Svart',
        'simplify': 'Forenkle',
        'improper': 'Uekte',
        
        // Modale vinduer
        'modal-title-fraction': 'Skriv inn Brøk',
        'modal-message-fraction': 'Skriv inn brøk i format "teller/nevner":',
        'modal-title-mixed': 'Blandet Brøk',
        'modal-message-mixed': 'Skriv inn blandet brøk i format "hel teller/nevner":',
        'modal-title-gcd': 'SFF (Største Felles Faktor)',
        'modal-message-gcd': 'Skriv inn to tall atskilt med komma:',
        'modal-title-lcm': 'MFF (Minste Felles Multiplum)',
        'modal-message-lcm': 'Skriv inn to tall atskilt med komma:',
        'modal-title-fibonacci': 'Fibonacci Tall',
        'modal-message-fibonacci': 'Skriv inn Fibonacci tallposisjon (0-100):',
        'modal-title-combinations': 'Kombinasjoner C(n,r)',
        'modal-message-combinations': 'Skriv inn n,r for C(n,r):',
        'modal-title-permutations': 'Permutasjoner P(n,r)',
        'modal-message-permutations': 'Skriv inn n,r for P(n,r):',
        'modal-title-quadratic': 'Kvadratisk Ligning',
        'modal-message-quadratic': 'Skriv inn koeffisienter a,b,c for ax²+bx+c=0:',
        'modal-title-statistics': 'Statistikk',
        'modal-message-statistics': 'Skriv inn tall atskilt med komma:',
        'modal-title-temperature': 'Temperaturkonvertering',
        'modal-message-temperature': 'Skriv inn: verdi,fra,til (C/F/K):',
        'modal-title-length': 'Lengdekonvertering',
        'modal-message-length': 'Skriv inn: verdi,fra,til (mm,cm,m,km,in,ft,yd,mi):',
        'modal-title-weight': 'Vektkonvertering',
        'modal-message-weight': 'Skriv inn: verdi,fra,til (mg,g,kg,t,oz,lb):',
        'modal-cancel': 'Avbryt',
        'modal-confirm': 'OK',
        'auto-calc-title': 'Automatiske Beregninger',
        'prime-yes': 'Primtall',
        'prime-no': 'Sammensatt',
        'no-real-roots': 'Ingen reelle røtter',
        'average': 'Gjennomsnitt',
        'median': 'Median',
        'std-dev': 'Std Avvik',
        'statistics-count': 'tall',
        
        // Automatiske beregninger
        'auto-calc-square': 'Kvadrat',
        'auto-calc-cube': 'Kubikk',
        'auto-calc-sqrt': 'Kvadratrot',
        'auto-calc-cbrt': 'Kubikkrot',
        'auto-calc-reciprocal': 'Resiprok',
        'auto-calc-percent': 'Prosent',
        'auto-calc-factorial': 'Fakultet',
        'auto-calc-sin': 'Sinus',
        'auto-calc-cos': 'Cosinus',
        'auto-calc-tan': 'Tangens',
        'auto-calc-ln': 'Naturlig logaritme',
        'auto-calc-log': 'Vanlig logaritme',
        'auto-calc-unavailable': 'Ikke tilgjengelig',
        'auto-calc-div-zero': 'Deling med null',
        'auto-calc-button': 'Auto-beregn',
        'beta-badge': 'BETA',
        'expression-editor': 'Uttrykkssrediger',
        'expression-editor-title': 'Smart uttrykksinntasting',
        'expression-placeholder': 'Skriv inn matematisk uttrykk...',
        'expression-help': 'Eksempler: 2+3*4, sin(45), sqrt(16), 2^3, log(100), 5!, gcd(12,8), fibonacci(10), combinations(10,3)',
        'calculate': 'Beregn',
        'expression-result': 'Resultat',
        'expression-error': 'Uttrykksfeil',
        'insert-result': 'Sett inn i kalkulator',
        'modal-input-placeholder': 'Skriv inn data...',
        'fullscreen-mode': '🖥️ Fullskjerm-modus',
        
        // Avanserte funksjoner
        'prime-check': 'Primtall?',
        'fibonacci': 'Fib',
        'combinations': 'C(n,r)',
        'permutations': 'P(n,r)',
        'quadratic': 'ax²+bx+c',
        'statistics': 'Statistikk',
        'deg-rad': 'DEG/RAD',
        'convert-temp': '°C/°F/K',
        'convert-length': 'Lengde',
        'convert-weight': 'Vekt',
        'memory-store': 'MS',
        'memory-recall': 'MR',
        
        // Installer
        'download-installer': 'Last ned Installerer',
        'download-installer-title': 'Last ned Kalkulator Installerer',
        'app-name': 'Avansert Kalkulator',
        'app-version': 'Versjon 2.0.0',
        'app-description': 'Avansert kalkulator med støtte for komplekse matematiske uttrykk',
        'portable-version': '📱 Portabel Versjon',
        'portable-description': 'Ingen installasjon nødvendig, kjører umiddelbart',
        'download-portable': 'Last ned Portabel (5 MB)',
        'installer-version': '💾 Windows Installerer',
        'installer-description': 'Full installasjon med menysnarveger',
        'download-installer-exe': 'Last ned Installerer (7 MB)',
        'system-req': 'Systemkrav:',
        'req-windows': 'Windows 7/8/10/11 (64-bit)',
        'req-memory': 'Minimum 100 MB ledig plass',
        'req-features': 'Støtte for vitenskapelige beregninger'
    },
    nl: {
        'app-title': 'Geavanceerde Calculator',
        'history': 'Geschiedenis',
        'settings': 'Instellingen',
        'basic-mode': 'Basis',
        'scientific-mode': 'Wetenschappelijk',
        'fraction-mode': 'Breuken',
        'advanced-mode': 'Geavanceerd',
        'clear-history': 'Alles wissen',
        'language': 'Taal',
        'theme': 'Thema',
        'decimal-places': 'Decimalen',
        'dark-theme': 'Donker',
        'black-theme': 'Zwart',
        'simplify': 'Vereenvoudig',
        'improper': 'Onecht',
        
        // Modale vensters
        'modal-title-fraction': 'Breuk Invoeren',
        'modal-message-fraction': 'Voer breuk in het formaat "teller/noemer" in:',
        'modal-title-mixed': 'Gemengde Breuk',
        'modal-message-mixed': 'Voer gemengde breuk in het formaat "geheel teller/noemer" in:',
        'modal-title-gcd': 'GGD (Grootste Gemene Deler)',
        'modal-message-gcd': 'Voer twee getallen gescheiden door komma in:',
        'modal-title-lcm': 'KGV (Kleinste Gemene Veelvoud)',
        'modal-message-lcm': 'Voer twee getallen gescheiden door komma in:',
        'modal-title-fibonacci': 'Fibonacci Getallen',
        'modal-message-fibonacci': 'Voer Fibonacci getalspositie in (0-100):',
        'modal-title-combinations': 'Combinaties C(n,r)',
        'modal-message-combinations': 'Voer n,r in voor C(n,r):',
        'modal-title-permutations': 'Permutaties P(n,r)',
        'modal-message-permutations': 'Voer n,r in voor P(n,r):',
        'modal-title-quadratic': 'Kwadratische Vergelijking',
        'modal-message-quadratic': 'Voer coëfficiënten a,b,c in voor ax²+bx+c=0:',
        'modal-title-statistics': 'Statistieken',
        'modal-message-statistics': 'Voer getallen gescheiden door komma in:',
        'modal-title-temperature': 'Temperatuurconversie',
        'modal-message-temperature': 'Voer in: waarde,van,naar (C/F/K):',
        'modal-title-length': 'Lengteconversie',
        'modal-message-length': 'Voer in: waarde,van,naar (mm,cm,m,km,in,ft,yd,mi):',
        'modal-title-weight': 'Gewichtconversie',
        'modal-message-weight': 'Voer in: waarde,van,naar (mg,g,kg,t,oz,lb):',
        'modal-cancel': 'Annuleren',
        'modal-confirm': 'OK',
        'auto-calc-title': 'Automatische Berekeningen',
        'prime-yes': 'Priemgetal',
        'prime-no': 'Samengesteld',
        'no-real-roots': 'Geen reële wortels',
        'average': 'Gemiddelde',
        'median': 'Mediaan',
        'std-dev': 'Std Afw',
        'statistics-count': 'getallen',
        
        // Automatische berekeningen
        'auto-calc-square': 'Kwadraat',
        'auto-calc-cube': 'Kubus',
        'auto-calc-sqrt': 'Vierkantswortel',
        'auto-calc-cbrt': 'Kubuswortel',
        'auto-calc-reciprocal': 'Reciprook',
        'auto-calc-percent': 'Procent',
        'auto-calc-factorial': 'Faculteit',
        'auto-calc-sin': 'Sinus',
        'auto-calc-cos': 'Cosinus',
        'auto-calc-tan': 'Tangens',
        'auto-calc-ln': 'Natuurlijke logaritme',
        'auto-calc-log': 'Gewone logaritme',
        'auto-calc-unavailable': 'Niet beschikbaar',
        'auto-calc-div-zero': 'Deling door nul',
        'auto-calc-button': 'Auto-berekening',
        'beta-badge': 'BETA',
        'expression-editor': 'Uitdrukkingseditor',
        'expression-editor-title': 'Slimme uitdrukkingsinvoer',
        'expression-placeholder': 'Voer wiskundige uitdrukking in...',
        'expression-help': 'Voorbeelden: 2+3*4, sin(45), sqrt(16), 2^3, log(100), 5!, gcd(12,8), fibonacci(10), combinations(10,3)',
        'calculate': 'Berekenen',
        'expression-result': 'Resultaat',
        'expression-error': 'Uitdrukkingsfout',
        'insert-result': 'Invoegen in calculator',
        'modal-input-placeholder': 'Voer gegevens in...',
        'fullscreen-mode': '🖥️ Volledig scherm',
        
        // Geavanceerde functies
        'prime-check': 'Priemgetal?',
        'fibonacci': 'Fib',
        'combinations': 'C(n,r)',
        'permutations': 'P(n,r)',
        'quadratic': 'ax²+bx+c',
        'statistics': 'Statistieken',
        'deg-rad': 'DEG/RAD',
        'convert-temp': '°C/°F/K',
        'convert-length': 'Lengte',
        'convert-weight': 'Gewicht',
        'memory-store': 'MS',
        'memory-recall': 'MR',
        
        // Installer
        'download-installer': 'Download Installatie',
        'download-installer-title': 'Download Calculator Installatie',
        'app-name': 'Geavanceerde Calculator',
        'app-version': 'Versie 2.0.0',
        'app-description': 'Geavanceerde calculator met ondersteuning voor complexe wiskundige expressies',
        'portable-version': '📱 Draagbare Versie',
        'portable-description': 'Geen installatie vereist, start direct',
        'download-portable': 'Download Draagbaar (5 MB)',
        'installer-version': '💾 Windows Installatie',
        'installer-description': 'Volledige installatie met menu snelkoppelingen',
        'download-installer-exe': 'Download Installatie (7 MB)',
        'system-req': 'Systeemvereisten:',
        'req-windows': 'Windows 7/8/10/11 (64-bit)',
        'req-memory': 'Minimaal 100 MB vrije ruimte',
        'req-features': 'Ondersteuning voor wetenschappelijke berekeningen'
    }
};

class AdvancedCalculator {
    constructor() {
        this.display = document.getElementById('result');
        this.expression = document.getElementById('expression');
        this.currentExpression = '';
        this.currentResult = '0';
        this.history = [];
        this.currentMode = 'basic';
        this.lastAnswer = 0;
        this.angleMode = 'deg';
        this.currentLanguage = 'ru';
        this.currentTheme = 'black';
        this.decimalPlaces = 10;
        this.memory = 0; // Память калькулятора
        this.autoCalcEnabled = true; // Автоматические вычисления
        this.modalPromiseResolve = null; // Для обработки модальных окон
        this.lastExpressionResult = null; // Последний результат из редактора выражений
        this.lastExpression = ''; // Последнее выражение из редактора
        
        this.loadSettings();
        this.init();
    }

    init() {
        this.setupEventListeners();
        this.loadHistory();
        this.updateDisplay();
        this.applyLanguage();
        this.applyTheme();
        this.handleResize(); // Начальная адаптация под размер экрана
        this.updateMemoryIndicator(); // Инициализация индикатора памяти
        this.setupModalHandlers(); // Инициализация модальных окон
        this.setupAutoCalc(); // Инициализация автоматических вычислений
        this.setupSmartExpressionEditor(); // Инициализация умного редактора
        
        // Инициализация индикатора углов
        const angleIndicator = document.querySelector('.angle-mode-indicator');
        if (angleIndicator) {
            angleIndicator.textContent = this.angleMode.toUpperCase();
        }
    }

    loadSettings() {
        const savedSettings = localStorage.getItem('calculator-settings');
        if (savedSettings) {
            const settings = JSON.parse(savedSettings);
            this.currentLanguage = settings.language || 'ru';
            this.currentTheme = settings.theme || 'black';
            this.decimalPlaces = settings.decimalPlaces || 10;
        }
    }

    saveSettings() {
        const settings = {
            language: this.currentLanguage,
            theme: this.currentTheme,
            decimalPlaces: this.decimalPlaces
        };
        localStorage.setItem('calculator-settings', JSON.stringify(settings));
    }

    toggleFullscreen() {
        if (!document.fullscreenElement) {
            // Войти в полноэкранный режим
            if (document.documentElement.requestFullscreen) {
                document.documentElement.requestFullscreen();
            } else if (document.documentElement.mozRequestFullScreen) {
                document.documentElement.mozRequestFullScreen();
            } else if (document.documentElement.webkitRequestFullscreen) {
                document.documentElement.webkitRequestFullscreen();
            } else if (document.documentElement.msRequestFullscreen) {
                document.documentElement.msRequestFullscreen();
            }
        } else {
            // Выйти из полноэкранного режима
            if (document.exitFullscreen) {
                document.exitFullscreen();
            } else if (document.mozCancelFullScreen) {
                document.mozCancelFullScreen();
            } else if (document.webkitExitFullscreen) {
                document.webkitExitFullscreen();
            } else if (document.msExitFullscreen) {
                document.msExitFullscreen();
            }
        }
    }

    toggleFullscreen() {
        if (!document.fullscreenElement) {
            // Войти в полноэкранный режим
            if (document.documentElement.requestFullscreen) {
                document.documentElement.requestFullscreen();
            } else if (document.documentElement.webkitRequestFullscreen) {
                document.documentElement.webkitRequestFullscreen();
            } else if (document.documentElement.msRequestFullscreen) {
                document.documentElement.msRequestFullscreen();
            }
        } else {
            // Выйти из полноэкранного режима
            if (document.exitFullscreen) {
                document.exitFullscreen();
            } else if (document.webkitExitFullscreen) {
                document.webkitExitFullscreen();
            } else if (document.msExitFullscreen) {
                document.msExitFullscreen();
            }
        }
    }

    loadHistory() {
        const savedHistory = localStorage.getItem('calculator-history');
        if (savedHistory) {
            this.history = JSON.parse(savedHistory);
            this.updateHistoryDisplay();
        }
    }

    saveHistory() {
        localStorage.setItem('calculator-history', JSON.stringify(this.history));
    }

    applyLanguage() {
        const elements = document.querySelectorAll('[data-translate]');
        elements.forEach(element => {
            const key = element.getAttribute('data-translate');
            if (translations[this.currentLanguage] && translations[this.currentLanguage][key]) {
                element.textContent = translations[this.currentLanguage][key];
            }
        });

        // Обновляем селектор языка
        const languageSelector = document.getElementById('language-selector');
        if (languageSelector) {
            languageSelector.value = this.currentLanguage;
        }

        // Обновляем текст в модальных окнах
        const modalCancel = document.getElementById('modal-cancel');
        const modalConfirm = document.getElementById('modal-confirm');
        if (modalCancel) modalCancel.textContent = this.translate('modal-cancel');
        if (modalConfirm) modalConfirm.textContent = this.translate('modal-confirm');

        // Обновляем заголовок автоматических вычислений
        const autoCalcTitle = document.querySelector('.auto-calc-header h4');
        if (autoCalcTitle) autoCalcTitle.textContent = this.translate('auto-calc-title');

        // Обновляем автоматические вычисления
        this.updateAutoCalc();

        // Обновляем placeholder для всех полей ввода
        const expressionInput = document.getElementById('expression-input');
        if (expressionInput) {
            expressionInput.placeholder = this.translate('expression-placeholder');
        }
        
        const modalInput = document.getElementById('modal-input');
        if (modalInput) {
            modalInput.placeholder = this.translate('modal-input-placeholder');
        }
        
        // Обновляем placeholder'ы для элементов с data-translate-placeholder
        document.querySelectorAll('[data-translate-placeholder]').forEach(element => {
            const key = element.getAttribute('data-translate-placeholder');
            if (key) {
                element.placeholder = this.translate(key);
            }
        });
    }

    applyTheme() {
        document.body.className = `theme-${this.currentTheme}`;
        const themeSelector = document.getElementById('theme-selector');
        if (themeSelector) {
            themeSelector.value = this.currentTheme;
        }
    }

    setupEventListeners() {
        // Боковое меню
        const menuBtn = document.getElementById('menu-btn');
        const sidebar = document.getElementById('sidebar');
        const closeSidebar = document.getElementById('close-sidebar');
        const mainContent = document.getElementById('main-content');

        if (menuBtn && sidebar && mainContent) {
            menuBtn.addEventListener('click', () => {
                sidebar.classList.add('open');
                mainContent.classList.add('sidebar-open');
            });
        }

        if (closeSidebar && sidebar && mainContent) {
            closeSidebar.addEventListener('click', () => {
                sidebar.classList.remove('open');
                mainContent.classList.remove('sidebar-open');
            });
        }

        // Настройки
        const settingsBtn = document.getElementById('settings-btn');
        const settingsPanel = document.getElementById('settings-panel');
        const closeSettings = document.getElementById('close-settings');

        if (settingsBtn && settingsPanel && mainContent) {
            settingsBtn.addEventListener('click', () => {
                settingsPanel.classList.add('open');
                mainContent.classList.add('settings-open');
            });
        }

        if (closeSettings && settingsPanel && mainContent) {
            closeSettings.addEventListener('click', () => {
                settingsPanel.classList.remove('open');
                mainContent.classList.remove('settings-open');
            });
        }

        // Языковой селектор
        const languageSelector = document.getElementById('language-selector');
        if (languageSelector) {
            languageSelector.addEventListener('change', (e) => {
                this.currentLanguage = e.target.value;
                this.applyLanguage();
                this.saveSettings();
            });
        }

        // Селектор темы
        const themeSelector = document.getElementById('theme-selector');
        if (themeSelector) {
            themeSelector.addEventListener('change', (e) => {
                this.currentTheme = e.target.value;
                this.applyTheme();
                this.saveSettings();
            });
        }

        // Количество знаков после запятой
        const decimalPlacesInput = document.getElementById('decimal-places');
        if (decimalPlacesInput) {
            decimalPlacesInput.addEventListener('change', (e) => {
                this.decimalPlaces = parseInt(e.target.value);
                this.saveSettings();
            });
            decimalPlacesInput.value = this.decimalPlaces;
        }

        // Полноэкранный режим
        const fullscreenBtn = document.getElementById('fullscreen-btn');
        if (fullscreenBtn) {
            fullscreenBtn.addEventListener('click', () => {
                this.toggleFullscreen();
            });
        }

        // Кнопки режимов
        document.querySelectorAll('.mode-btn').forEach(btn => {
            btn.addEventListener('click', (e) => {
                this.switchMode(e.target.dataset.mode);
            });
        });

        // Кнопки калькулятора
        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('btn')) {
                this.handleButtonClick(e.target);
            }
        });

        // История
        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('history-item') || e.target.closest('.history-item')) {
                const item = e.target.closest('.history-item') || e.target;
                const result = item.querySelector('.history-result');
                if (result) {
                    this.currentExpression = '';
                    this.currentResult = result.textContent;
                    this.updateDisplay();
                    
                    // Закрываем боковое меню
                    if (sidebar && mainContent) {
                        sidebar.classList.remove('open');
                        mainContent.classList.remove('sidebar-open');
                    }
                }
            }
        });

        // Очистка всей истории
        const clearAllHistory = document.getElementById('clear-all-history');
        if (clearAllHistory) {
            clearAllHistory.addEventListener('click', () => {
                this.clearHistory();
            });
        }

        // Клавиатура
        document.addEventListener('keydown', (e) => {
            this.handleKeyboard(e);
        });

        // Закрытие панелей при клике вне их
        document.addEventListener('click', (e) => {
            if (sidebar && menuBtn && mainContent) {
                if (!sidebar.contains(e.target) && !menuBtn.contains(e.target) && sidebar.classList.contains('open')) {
                    if (!e.target.closest('.sidebar')) {
                        sidebar.classList.remove('open');
                        mainContent.classList.remove('sidebar-open');
                    }
                }
            }

            if (settingsPanel && settingsBtn && mainContent) {
                if (!settingsPanel.contains(e.target) && !settingsBtn.contains(e.target) && settingsPanel.classList.contains('open')) {
                    if (!e.target.closest('.settings-panel')) {
                        settingsPanel.classList.remove('open');
                        mainContent.classList.remove('settings-open');
                    }
                }
            }
        });

        // Автоматические вычисления
        const autoCalcBtn = document.getElementById('auto-calc-btn');
        if (autoCalcBtn) {
            autoCalcBtn.addEventListener('click', () => {
                this.autoCalcEnabled = !this.autoCalcEnabled;
                const panel = document.getElementById('auto-calc-panel');
                if (panel) {
                    if (this.autoCalcEnabled) {
                        panel.classList.add('active');
                        this.updateAutoCalc();
                        autoCalcBtn.style.background = '#4CAF50';
                    } else {
                        panel.classList.remove('active');
                        autoCalcBtn.style.background = '#666666';
                    }
                }
            });
            
            // Включаем автоматические вычисления по умолчанию
            if (this.autoCalcEnabled) {
                const panel = document.getElementById('auto-calc-panel');
                if (panel) {
                    panel.classList.add('active');
                    autoCalcBtn.style.background = '#4CAF50';
                }
            }
        }

        // Редактор выражений
        const expressionEditorBtn = document.getElementById('expression-editor-btn');
        const expressionEditorPanel = document.getElementById('expression-editor-panel');
        const closeExpressionEditor = document.getElementById('close-expression-editor');
        const calculateBtn = document.getElementById('calculate-btn');
        const insertResultBtn = document.getElementById('insert-result-btn');
        const expressionInput = document.getElementById('expression-input');
        const expressionResult = document.getElementById('expression-result');

        if (expressionEditorBtn && expressionEditorPanel) {
            expressionEditorBtn.addEventListener('click', () => {
                expressionEditorPanel.classList.add('active');
                expressionInput.focus();
            });
        }

        if (closeExpressionEditor && expressionEditorPanel) {
            closeExpressionEditor.addEventListener('click', () => {
                expressionEditorPanel.classList.remove('active');
            });
        }

        if (calculateBtn && expressionInput && expressionResult) {
            calculateBtn.addEventListener('click', () => {
                this.calculateExpression();
            });
        }

        if (insertResultBtn) {
            insertResultBtn.addEventListener('click', () => {
                this.insertExpressionResult();
            });
        }

        // Enter для вычисления
        if (expressionInput) {
            expressionInput.addEventListener('keydown', (e) => {
                if (e.key === 'Enter' && !e.shiftKey) {
                    e.preventDefault();
                    this.calculateExpression();
                }
            });
        }

        // Закрытие редактора выражений при клике вне его
        document.addEventListener('click', (e) => {
            if (expressionEditorPanel && expressionEditorPanel.classList.contains('active')) {
                if (!expressionEditorPanel.contains(e.target) && !expressionEditorBtn.contains(e.target)) {
                    expressionEditorPanel.classList.remove('active');
                }
            }
        });

        /* Временно отключено: Модальное окно установщика
        const downloadInstallerBtn = document.getElementById('download-installer-btn');
        const downloadInstallerModal = document.getElementById('download-installer-modal');
        const installerClose = document.getElementById('installer-close');
        const downloadPortableBtn = document.getElementById('download-portable-btn');
        const downloadInstallerExeBtn = document.getElementById('download-installer-exe-btn');

        if (downloadInstallerBtn && downloadInstallerModal) {
            downloadInstallerBtn.addEventListener('click', () => {
                downloadInstallerModal.style.display = 'block';
            });
        }

        if (installerClose && downloadInstallerModal) {
            installerClose.addEventListener('click', () => {
                downloadInstallerModal.style.display = 'none';
            });
        }

        // Закрытие модального окна при клике вне его
        if (downloadInstallerModal) {
            downloadInstallerModal.addEventListener('click', (e) => {
                if (e.target === downloadInstallerModal) {
                    downloadInstallerModal.style.display = 'none';
                }
            });
        }

        // Обработчики кнопок скачивания
        if (downloadPortableBtn) {
            downloadPortableBtn.addEventListener('click', () => {
                this.downloadPortableVersion();
            });
        }

        if (downloadInstallerExeBtn) {
            downloadInstallerExeBtn.addEventListener('click', () => {
                this.downloadInstallerVersion();
            });
        }
        */
    }

    switchMode(mode) {
        this.currentMode = mode;
        
        // Обновляем активную кнопку режима
        document.querySelectorAll('.mode-btn').forEach(btn => {
            btn.classList.remove('active');
        });
        document.querySelector(`[data-mode="${mode}"]`).classList.add('active');

        // Показываем соответствующую сетку кнопок
        document.querySelectorAll('.button-grid').forEach(grid => {
            grid.classList.remove('active');
        });
        document.querySelector(`.${mode}-mode`).classList.add('active');
    }

    handleButtonClick(button) {
        const action = button.dataset.action;
        const value = button.dataset.value;

        if (value !== undefined) {
            this.appendToExpression(value);
        } else if (action) {
            this.handleAction(action);
        }
    }

    handleAction(action) {
        switch (action) {
            case 'clear':
                this.clear();
                break;
            case 'clear-entry':
                this.clearEntry();
                break;
            case 'backspace':
                this.backspace();
                break;
            case '=':
                this.calculate();
                break;
            case 'clear-history':
                this.clearHistory();
                break;
            
            // Математические операции
            case '+':
            case '-':
            case '*':
            case '/':
                this.appendOperator(action);
                break;
            
            // Научные функции
            case 'sin':
            case 'cos':
            case 'tan':
            case 'asin':
            case 'acos':
            case 'atan':
            case 'log':
            case 'ln':
            case 'sqrt':
            case 'abs':
                this.applyFunction(action);
                break;
            
            case 'pi':
                this.appendToExpression('π');
                break;
            case 'e':
                this.appendToExpression('e');
                break;
            case 'pow':
                this.appendOperator('^');
                break;
            case 'factorial':
                this.applyFunction('factorial');
                break;
            case '(':
            case ')':
                this.appendToExpression(action);
                break;
            case 'percent':
                this.applyFunction('percent');
                break;
            
            // Дроби
            case 'fraction':
                this.enterFractionMode();
                break;
            case 'mixed':
                this.enterMixedFractionMode();
                break;
            case 'to-decimal':
                this.convertToDecimal();
                break;
            case 'simplify':
                this.simplifyFraction();
                break;
            case 'gcd':
                this.calculateGCD();
                break;
            case 'lcm':
                this.calculateLCM();
                break;
            case 'reciprocal':
                this.reciprocal();
                break;
            case 'improper':
                this.convertToImproper();
                break;
            
            // Дополнительные математические функции
            case 'prime':
                this.checkPrime();
                break;
            case 'fibonacci':
                this.calculateFibonacci();
                break;
            case 'combinations':
                this.calculateCombinations();
                break;
            case 'permutations':
                this.calculatePermutations();
                break;
            case 'quadratic':
                this.solveQuadratic();
                break;
            case 'statistics':
                this.calculateStatistics();
                break;
            case 'convert-temp':
                this.convertTemperature();
                break;
            case 'convert-length':
                this.convertLength();
                break;
            case 'convert-weight':
                this.convertWeight();
                break;
            case 'deg-rad':
                this.toggleAngleMode();
                break;
            case 'memory-store':
                this.memoryStore();
                break;
            case 'memory-recall':
                this.memoryRecall();
                break;
            case 'memory-clear':
                this.memoryClear();
                break;
            case 'memory-add':
                this.memoryAdd();
                break;
        }
    }

    appendToExpression(value) {
        if (this.currentExpression === '0' || this.currentExpression === 'Error') {
            this.currentExpression = value;
        } else {
            this.currentExpression += value;
        }
        this.updateDisplay();
    }

    appendOperator(operator) {
        const lastChar = this.currentExpression.slice(-1);
        if (['+', '-', '*', '/', '^'].includes(lastChar)) {
            this.currentExpression = this.currentExpression.slice(0, -1) + operator;
        } else {
            this.currentExpression += operator;
        }
        this.updateDisplay();
    }

    applyFunction(func) {
        if (this.currentResult === '0' || this.currentResult === 'Error') return;
        
        let value = parseFloat(this.currentResult);
        let result;

        try {
            switch (func) {
                case 'sin':
                    result = this.angleMode === 'deg' ? Math.sin(value * Math.PI / 180) : Math.sin(value);
                    break;
                case 'cos':
                    result = this.angleMode === 'deg' ? Math.cos(value * Math.PI / 180) : Math.cos(value);
                    break;
                case 'tan':
                    result = this.angleMode === 'deg' ? Math.tan(value * Math.PI / 180) : Math.tan(value);
                    break;
                case 'asin':
                    result = this.angleMode === 'deg' ? Math.asin(value) * 180 / Math.PI : Math.asin(value);
                    break;
                case 'acos':
                    result = this.angleMode === 'deg' ? Math.acos(value) * 180 / Math.PI : Math.acos(value);
                    break;
                case 'atan':
                    result = this.angleMode === 'deg' ? Math.atan(value) * 180 / Math.PI : Math.atan(value);
                    break;
                case 'log':
                    result = Math.log10(value);
                    break;
                case 'ln':
                    result = Math.log(value);
                    break;
                case 'sqrt':
                    result = Math.sqrt(value);
                    break;
                case 'abs':
                    result = Math.abs(value);
                    break;
                case 'factorial':
                    result = this.factorial(value);
                    break;
                case 'percent':
                    result = value / 100;
                    break;
                default:
                    return;
            }

            this.currentExpression = `${func}(${this.currentResult})`;
            this.currentResult = this.formatResult(result);
            this.updateDisplay();
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    factorial(n) {
        if (n < 0 || !Number.isInteger(n)) throw new Error('Invalid input for factorial');
        if (n === 0 || n === 1) return 1;
        let result = 1;
        for (let i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    clear() {
        this.currentExpression = '';
        this.currentResult = '0';
        this.updateDisplay();
    }

    clearEntry() {
        this.currentResult = '0';
        this.updateDisplay();
    }

    backspace() {
        if (this.currentExpression.length > 0) {
            this.currentExpression = this.currentExpression.slice(0, -1);
            if (this.currentExpression === '') {
                this.currentResult = '0';
            }
            this.updateDisplay();
        }
    }

    calculate() {
        if (!this.currentExpression) return;

        try {
            // Заменяем символы для math.js
            let expr = this.currentExpression
                .replace(/×/g, '*')
                .replace(/÷/g, '/')
                .replace(/−/g, '-')
                .replace(/π/g, 'pi')
                .replace(/\^/g, '^');

            // Вычисляем
            const result = MathUtils.evaluate(expr);
            
            // Добавляем в историю
            this.addToHistory(this.currentExpression, this.formatResult(result));
            
            this.currentResult = this.formatResult(result);
            this.lastAnswer = result;
            this.currentExpression = '';
            this.updateDisplay();
            
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    translate(key) {
        if (translations[this.currentLanguage] && translations[this.currentLanguage][key]) {
            return translations[this.currentLanguage][key];
        }
        return key; // Возвращаем ключ, если перевод не найден
    }

    // Функции для работы с дробями
    async enterFractionMode() {
        const parts = await this.showModal(
            this.translate('modal-title-fraction'),
            this.translate('modal-message-fraction'),
            '3/4',
            ['1/2', '1/3', '2/3', '3/4', '5/6', '7/8']
        );
        
        if (parts) {
            try {
                const fraction = new SimpleFraction(parts);
                this.currentResult = `${fraction.n}/${fraction.d}`;
                this.currentExpression = '';
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async enterMixedFractionMode() {
        const parts = await this.showModal(
            this.translate('modal-title-mixed'),
            this.translate('modal-message-mixed'),
            '2 1/4',
            ['1 1/2', '2 1/3', '3 1/4', '4 2/3']
        );
        
        if (parts) {
            try {
                const match = parts.match(/(\d+)\s+(\d+)\/(\d+)/);
                if (match) {
                    const [, whole, num, den] = match;
                    const fraction = new SimpleFraction(parseInt(whole) * parseInt(den) + parseInt(num), parseInt(den));
                    this.currentResult = `${fraction.n}/${fraction.d}`;
                    this.currentExpression = '';
                    this.updateDisplay();
                    this.updateAutoCalc();
                }
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    convertToDecimal() {
        try {
            if (this.currentResult.includes('/')) {
                const fraction = new SimpleFraction(this.currentResult);
                this.currentResult = this.formatResult(fraction.valueOf());
                this.updateDisplay();
            }
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    simplifyFraction() {
        try {
            if (this.currentResult.includes('/')) {
                const fraction = new SimpleFraction(this.currentResult);
                this.currentResult = `${fraction.n}/${fraction.d}`;
                this.updateDisplay();
            }
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    async calculateGCD() {
        const numbers = await this.showModal(
            this.translate('modal-title-gcd'),
            this.translate('modal-message-gcd'),
            '12, 18',
            ['12, 18', '24, 36', '15, 25', '8, 12']
        );
        
        if (numbers) {
            try {
                const [a, b] = numbers.split(',').map(n => parseInt(n.trim()));
                const result = MathUtils.gcd(a, b);
                this.currentResult = result.toString();
                this.currentExpression = `НОД(${a}, ${b})`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async calculateLCM() {
        const numbers = await this.showModal(
            this.translate('modal-title-lcm'),
            this.translate('modal-message-lcm'),
            '4, 6',
            ['4, 6', '3, 5', '8, 12', '15, 20']
        );
        
        if (numbers) {
            try {
                const [a, b] = numbers.split(',').map(n => parseInt(n.trim()));
                const result = MathUtils.lcm(a, b);
                this.currentResult = result.toString();
                this.currentExpression = `НОК(${a}, ${b})`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    reciprocal() {
        try {
            const value = parseFloat(this.currentResult);
            if (value !== 0) {
                this.currentResult = this.formatResult(1 / value);
                this.currentExpression = `1/(${value})`;
                this.updateDisplay();
            }
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    convertToImproper() {
        try {
            if (this.currentResult.includes('/')) {
                const fraction = new SimpleFraction(this.currentResult);
                // Уже неправильная дробь
                this.currentResult = `${fraction.n}/${fraction.d}`;
                this.updateDisplay();
            }
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    formatResult(value) {
        if (typeof value === 'number') {
            if (Math.abs(value) > 1e15 || Math.abs(value) < 1e-15) {
                return value.toExponential(this.decimalPlaces);
            }
            return parseFloat(value.toPrecision(this.decimalPlaces)).toString();
        }
        return value.toString();
    }

    addToHistory(expression, result) {
        this.history.unshift({ 
            expression, 
            result, 
            timestamp: new Date().toISOString() 
        });
        if (this.history.length > 50) { // Увеличиваем лимит истории
            this.history.pop();
        }
        this.updateHistoryDisplay();
        this.saveHistory();
    }

    updateHistoryDisplay() {
        const historyList = document.getElementById('history-list');
        if (!historyList) return;
        
        historyList.innerHTML = '';
        
        this.history.forEach((item, index) => {
            const historyItem = document.createElement('div');
            historyItem.className = 'history-item';
            historyItem.innerHTML = `
                <div class="history-expression">${item.expression}</div>
                <div class="history-result">${item.result}</div>
            `;
            historyList.appendChild(historyItem);
        });
    }

    clearHistory() {
        this.history = [];
        this.updateHistoryDisplay();
        this.saveHistory();
    }

    updateDisplay() {
        this.display.textContent = this.currentResult;
        this.expression.textContent = this.currentExpression;
        
        // Обновляем автоматические вычисления при каждом изменении
        if (this.autoCalcEnabled) {
            setTimeout(() => this.updateAutoCalc(), 100);
        }
    }

    handleResize() {
        // Адаптивная логика для изменения размеров
        const windowWidth = window.innerWidth;
        const windowHeight = window.innerHeight;
        
        // Автоматически закрываем боковые панели на маленьких экранах
        if (windowWidth < 1000) {
            const sidebar = document.getElementById('sidebar');
            const settingsPanel = document.getElementById('settings-panel');
            const mainContent = document.getElementById('main-content');
            
            if (sidebar && mainContent) {
                sidebar.classList.remove('open');
                mainContent.classList.remove('sidebar-open');
            }
            
            if (settingsPanel && mainContent) {
                settingsPanel.classList.remove('open');
                mainContent.classList.remove('settings-open');
            }
        }
        
        // Адаптивные размеры шрифтов и элементов
        const calculator = document.querySelector('.calculator');
        const display = document.querySelector('.display');
        const result = document.querySelector('.result');
        const buttons = document.querySelectorAll('.btn');
        
        if (calculator && display && result && buttons) {
            // Устанавливаем размеры в зависимости от размера окна
            if (windowWidth < 600) {
                // Очень маленький экран
                result.style.fontSize = '24px';
                buttons.forEach(btn => {
                    btn.style.fontSize = '14px';
                    btn.style.padding = '8px';
                    btn.style.minHeight = '40px';
                });
                display.style.padding = '15px 20px';
                display.style.minHeight = '70px';
            } else if (windowWidth < 800) {
                // Маленький экран
                result.style.fontSize = '32px';
                buttons.forEach(btn => {
                    btn.style.fontSize = '16px';
                    btn.style.padding = '12px';
                    btn.style.minHeight = '50px';
                });
                display.style.padding = '20px 25px';
                display.style.minHeight = '90px';
            } else if (windowWidth < 1200) {
                // Средний экран
                result.style.fontSize = '40px';
                buttons.forEach(btn => {
                    btn.style.fontSize = '18px';
                    btn.style.padding = '16px';
                    btn.style.minHeight = '60px';
                });
                display.style.padding = '25px 30px';
                display.style.minHeight = '100px';
            } else {
                // Большой экран
                result.style.fontSize = '52px';
                buttons.forEach(btn => {
                    btn.style.fontSize = '22px';
                    btn.style.padding = '20px';
                    btn.style.minHeight = '70px';
                });
                display.style.padding = '35px 45px';
                display.style.minHeight = '120px';
            }
        }
    }

    handleKeyboard(e) {
        const key = e.key;
        
        if ('0123456789.'.includes(key)) {
            this.appendToExpression(key);
        } else if ('+-*/'.includes(key)) {
            this.appendOperator(key);
        } else if (key === 'Enter' || key === '=') {
            this.calculate();
        } else if (key === 'Escape') {
            this.clear();
        } else if (key === 'Backspace') {
            this.backspace();
        } else if (key === '(' || key === ')') {
            this.appendToExpression(key);
        }
    }

    // Дополнительные математические функции
    checkPrime() {
        const num = parseInt(this.currentResult);
        if (isNaN(num)) {
            this.currentResult = 'Error';
        } else {
            const isPrime = MathUtils.isPrime(num);
            this.currentResult = isPrime ? this.translate('prime-yes') : this.translate('prime-no');
            this.currentExpression = `${this.translate('prime-yes')}?(${num})`;
        }
        this.updateDisplay();
    }

    async calculateFibonacci() {
        const n = await this.showModal(
            'Числа Фибоначчи', 
            'Введите номер числа Фибоначчи (0-100):', 
            '10',
            ['5', '10', '15', '20', '25', '30']
        );
        
        if (n !== null) {
            try {
                const num = parseInt(n);
                if (num >= 0 && num <= 100) {
                    const result = MathUtils.fibonacci(num);
                    this.currentResult = result.toString();
                    this.currentExpression = `Фиб(${num})`;
                    this.updateDisplay();
                    this.updateAutoCalc();
                } else {
                    this.currentResult = 'Error';
                    this.updateDisplay();
                }
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async calculateCombinations() {
        const input = await this.showModal(
            'Сочетания C(n,r)', 
            'Введите n,r для C(n,r):', 
            '10,3',
            ['5,2', '10,3', '8,5', '12,4']
        );
        
        if (input) {
            try {
                const [n, r] = input.split(',').map(x => parseInt(x.trim()));
                const result = MathUtils.combinations(n, r);
                this.currentResult = result.toString();
                this.currentExpression = `C(${n},${r})`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async calculatePermutations() {
        const input = await this.showModal(
            'Размещения P(n,r)', 
            'Введите n,r для P(n,r):', 
            '10,3',
            ['5,2', '10,3', '8,5', '12,4']
        );
        
        if (input) {
            try {
                const [n, r] = input.split(',').map(x => parseInt(x.trim()));
                const result = MathUtils.permutations(n, r);
                this.currentResult = result.toString();
                this.currentExpression = `P(${n},${r})`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async solveQuadratic() {
        const input = await this.showModal(
            'Квадратное уравнение', 
            'Введите коэффициенты a,b,c для ax²+bx+c=0:', 
            '1,-5,6',
            ['1,-5,6', '1,0,-4', '2,4,2', '1,-3,2']
        );
        
        if (input) {
            try {
                const [a, b, c] = input.split(',').map(x => parseFloat(x.trim()));
                const solution = MathUtils.quadraticSolver(a, b, c);
                
                if (solution.real) {
                    if (solution.roots.length === 1) {
                        this.currentResult = `x = ${solution.roots[0]}`;
                    } else {
                        this.currentResult = `x₁ = ${solution.roots[0].toFixed(4)}, x₂ = ${solution.roots[1].toFixed(4)}`;
                    }
                } else {
                    this.currentResult = 'Нет действительных корней';
                }
                
                this.currentExpression = `${a}x²+${b}x+${c}=0`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async calculateStatistics() {
        const input = await this.showModal(
            'Статистика', 
            'Введите числа через запятую:', 
            '1,2,3,4,5',
            ['1,2,3,4,5', '10,20,30,40', '1.5,2.5,3.5', '100,200,300']
        );
        
        if (input) {
            try {
                const numbers = input.split(',').map(x => parseFloat(x.trim()));
                const mean = MathUtils.mean(numbers);
                const median = MathUtils.median(numbers);
                const stdDev = MathUtils.standardDeviation(numbers);
                
                this.currentResult = `Среднее: ${mean.toFixed(2)}, Медиана: ${median}, СКО: ${stdDev.toFixed(2)}`;
                this.currentExpression = `Статистика [${numbers.length} чисел]`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async convertTemperature() {
        const input = await this.showModal(
            'Конвертация температуры', 
            'Введите: значение,из,в (C/F/K):', 
            '25,C,F',
            ['25,C,F', '77,F,C', '300,K,C', '0,C,K']
        );
        
        if (input) {
            try {
                const [value, from, to] = input.split(',').map(x => x.trim());
                const result = MathUtils.convertTemperature(parseFloat(value), from.toUpperCase(), to.toUpperCase());
                this.currentResult = `${result.toFixed(2)}°${to.toUpperCase()}`;
                this.currentExpression = `${value}°${from.toUpperCase()} → ${to.toUpperCase()}`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async convertLength() {
        const input = await this.showModal(
            'Конвертация длины', 
            'Введите: значение,из,в (mm,cm,m,km,in,ft,yd,mi):', 
            '100,cm,m',
            ['100,cm,m', '1,m,ft', '5,ft,in', '1,km,mi']
        );
        
        if (input) {
            try {
                const [value, from, to] = input.split(',').map(x => x.trim());
                const result = MathUtils.convertLength(parseFloat(value), from, to);
                this.currentResult = `${result} ${to}`;
                this.currentExpression = `${value} ${from} → ${to}`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    async convertWeight() {
        const input = await this.showModal(
            'Конвертация веса', 
            'Введите: значение,из,в (mg,g,kg,t,oz,lb):', 
            '1,kg,lb',
            ['1,kg,lb', '500,g,oz', '1,t,kg', '10,lb,kg']
        );
        
        if (input) {
            try {
                const [value, from, to] = input.split(',').map(x => x.trim());
                const result = MathUtils.convertWeight(parseFloat(value), from, to);
                this.currentResult = `${result} ${to}`;
                this.currentExpression = `${value} ${from} → ${to}`;
                this.updateDisplay();
                this.updateAutoCalc();
            } catch (error) {
                this.currentResult = 'Error';
                this.updateDisplay();
            }
        }
    }

    toggleAngleMode() {
        this.angleMode = this.angleMode === 'deg' ? 'rad' : 'deg';
        this.currentResult = `Режим: ${this.angleMode === 'deg' ? 'Градусы' : 'Радианы'}`;
        this.currentExpression = 'Переключение углов';
        this.updateDisplay();
        
        // Обновляем индикатор режима
        const indicator = document.querySelector('.angle-mode-indicator');
        if (indicator) {
            indicator.textContent = this.angleMode.toUpperCase();
        }
    }

    // Функции памяти
    memoryStore() {
        try {
            this.memory = parseFloat(this.currentResult);
            this.currentResult = 'В памяти: ' + this.memory;
            this.currentExpression = 'MS';
            this.updateDisplay();
            this.updateMemoryIndicator();
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    memoryRecall() {
        this.currentResult = this.memory.toString();
        this.currentExpression = 'MR';
        this.updateDisplay();
    }

    memoryClear() {
        this.memory = 0;
        this.currentResult = 'Память очищена';
        this.currentExpression = 'MC';
        this.updateDisplay();
        this.updateMemoryIndicator();
    }

    memoryAdd() {
        try {
            this.memory += parseFloat(this.currentResult);
            this.currentResult = 'M+: ' + this.memory;
            this.currentExpression = 'M+';
            this.updateDisplay();
            this.updateMemoryIndicator();
        } catch (error) {
            this.currentResult = 'Error';
            this.updateDisplay();
        }
    }

    updateMemoryIndicator() {
        const indicator = document.querySelector('.memory-indicator');
        if (indicator) {
            indicator.textContent = this.memory !== 0 ? 'M' : '';
            indicator.style.visibility = this.memory !== 0 ? 'visible' : 'hidden';
        }
    }

    // Функции для модальных окон
    setupModalHandlers() {
        const overlay = document.getElementById('modal-overlay');
        const closeBtn = document.getElementById('modal-close');
        const cancelBtn = document.getElementById('modal-cancel');
        const confirmBtn = document.getElementById('modal-confirm');
        const input = document.getElementById('modal-input');

        if (closeBtn) {
            closeBtn.addEventListener('click', () => this.closeModal(null));
        }

        if (cancelBtn) {
            cancelBtn.addEventListener('click', () => this.closeModal(null));
        }

        if (confirmBtn) {
            confirmBtn.addEventListener('click', () => {
                const value = input ? input.value : '';
                this.closeModal(value);
            });
        }

        if (overlay) {
            overlay.addEventListener('click', (e) => {
                if (e.target === overlay) {
                    this.closeModal(null);
                }
            });
        }

        if (input) {
            input.addEventListener('keydown', (e) => {
                if (e.key === 'Enter') {
                    this.closeModal(input.value);
                } else if (e.key === 'Escape') {
                    this.closeModal(null);
                }
            });
        }
    }

    showModal(title, message, placeholder = '', suggestions = []) {
        return new Promise((resolve) => {
            this.modalPromiseResolve = resolve;
            
            const overlay = document.getElementById('modal-overlay');
            const titleElement = document.getElementById('modal-title');
            const messageElement = document.getElementById('modal-message');
            const input = document.getElementById('modal-input');
            const suggestionsContainer = document.getElementById('modal-suggestions');
            const cancelBtn = document.getElementById('modal-cancel');
            const confirmBtn = document.getElementById('modal-confirm');

            if (titleElement) titleElement.textContent = title;
            if (messageElement) messageElement.textContent = message;
            if (cancelBtn) cancelBtn.textContent = this.translate('modal-cancel');
            if (confirmBtn) confirmBtn.textContent = this.translate('modal-confirm');
            
            if (input) {
                input.value = '';
                input.placeholder = placeholder;
                setTimeout(() => input.focus(), 100);
            }

            // Добавляем подсказки
            if (suggestionsContainer) {
                suggestionsContainer.innerHTML = '';
                suggestions.forEach(suggestion => {
                    const div = document.createElement('div');
                    div.className = 'suggestion';
                    div.textContent = suggestion;
                    div.addEventListener('click', () => {
                        if (input) input.value = suggestion;
                        this.closeModal(suggestion);
                    });
                    suggestionsContainer.appendChild(div);
                });
            }

            if (overlay) {
                overlay.classList.add('active');
            }
        });
    }

    closeModal(value) {
        const overlay = document.getElementById('modal-overlay');
        if (overlay) {
            overlay.classList.remove('active');
        }

        if (this.modalPromiseResolve) {
            this.modalPromiseResolve(value);
            this.modalPromiseResolve = null;
        }
    }

    // Автоматические вычисления
    setupAutoCalc() {
        const toggle = document.getElementById('auto-calc-toggle');
        if (toggle) {
            toggle.addEventListener('click', () => {
                this.autoCalcEnabled = !this.autoCalcEnabled;
                toggle.textContent = this.autoCalcEnabled ? 'ON' : 'OFF';
                toggle.classList.toggle('off', !this.autoCalcEnabled);
                
                const panel = document.getElementById('auto-calc-panel');
                if (panel) {
                    if (this.autoCalcEnabled) {
                        panel.classList.add('active');
                        this.updateAutoCalc();
                    } else {
                        panel.classList.remove('active');
                    }
                }
            });
        }
    }

    updateAutoCalc() {
        if (!this.autoCalcEnabled) return;

        const resultsContainer = document.getElementById('auto-calc-results');
        if (!resultsContainer) return;

        resultsContainer.innerHTML = '';

        try {
            const currentValue = parseFloat(this.currentResult);
            if (isNaN(currentValue)) return;

            const calculations = [
                { 
                    label: this.translate('auto-calc-square'), 
                    value: currentValue * currentValue 
                },
                { 
                    label: this.translate('auto-calc-cube'), 
                    value: currentValue * currentValue * currentValue 
                },
                { 
                    label: this.translate('auto-calc-sqrt'), 
                    value: Math.sqrt(Math.abs(currentValue)) 
                },
                { 
                    label: this.translate('auto-calc-cbrt'), 
                    value: Math.cbrt(currentValue) 
                },
                { 
                    label: this.translate('auto-calc-reciprocal'), 
                    value: currentValue !== 0 ? 1/currentValue : this.translate('auto-calc-div-zero')
                },
                { 
                    label: this.translate('auto-calc-percent'), 
                    value: currentValue / 100 
                },
                { 
                    label: this.translate('auto-calc-factorial'), 
                    value: currentValue >= 0 && currentValue <= 20 && Number.isInteger(currentValue) ? MathUtils.factorial(currentValue) : this.translate('auto-calc-unavailable')
                },
                { 
                    label: this.translate('auto-calc-sin'), 
                    value: Math.sin(this.angleMode === 'deg' ? currentValue * Math.PI / 180 : currentValue) 
                },
                { 
                    label: this.translate('auto-calc-cos'), 
                    value: Math.cos(this.angleMode === 'deg' ? currentValue * Math.PI / 180 : currentValue) 
                },
                { 
                    label: this.translate('auto-calc-tan'), 
                    value: Math.tan(this.angleMode === 'deg' ? currentValue * Math.PI / 180 : currentValue) 
                },
                { 
                    label: this.translate('auto-calc-ln'), 
                    value: currentValue > 0 ? Math.log(currentValue) : this.translate('auto-calc-unavailable')
                },
                { 
                    label: this.translate('auto-calc-log'), 
                    value: currentValue > 0 ? Math.log10(currentValue) : this.translate('auto-calc-unavailable')
                }
            ];

            calculations.forEach(calc => {
                const item = document.createElement('div');
                item.className = 'auto-calc-item';
                
                const label = document.createElement('div');
                label.className = 'auto-calc-label';
                label.textContent = calc.label;
                
                const value = document.createElement('div');
                value.className = 'auto-calc-value';
                
                if (typeof calc.value === 'number') {
                    value.textContent = this.formatResult(calc.value);
                } else {
                    value.textContent = calc.value;
                }
                
                item.appendChild(label);
                item.appendChild(value);
                
                // Добавляем клик для копирования результата
                item.addEventListener('click', () => {
                    if (typeof calc.value === 'number') {
                        this.currentResult = this.formatResult(calc.value);
                        this.currentExpression = calc.label + '(' + currentValue + ')';
                        this.updateDisplay();
                    }
                });
                
                resultsContainer.appendChild(item);
            });

        } catch (error) {
            console.error('Ошибка автоматических вычислений:', error);
        }
    }

    // МОЩНЫЙ редактор выражений с интеллектуальным анализом
    calculateExpression() {
        const input = document.getElementById('expression-input');
        const result = document.getElementById('expression-result');
        const statusDiv = document.getElementById('expression-status') || this.createStatusElement();
        
        if (!input || !result) return;

        const expression = input.value.trim();
        if (!expression) {
            result.textContent = '';
            result.className = 'expression-result';
            statusDiv.textContent = 'Введите математическое выражение...';
            statusDiv.className = 'expression-status info';
            return;
        }

        try {
            // Показываем статус обработки
            statusDiv.textContent = '🔄 Вычисляем...';
            statusDiv.className = 'expression-status processing';
            
            // Используем наш мощный математический движок
            const calcResult = AdvancedMathEngine.evaluate(expression);
            
            // Форматируем результат с дополнительной информацией
            let formattedResult = this.formatAdvancedResult(calcResult);
            
            result.innerHTML = formattedResult;
            result.className = 'expression-result success';
            
            // Показываем дополнительную информацию
            statusDiv.innerHTML = this.generateExpressionInfo(expression, calcResult);
            statusDiv.className = 'expression-status success';
            
            // Сохраняем результат для возможной вставки
            this.lastExpressionResult = calcResult;
            this.lastExpression = expression;

        } catch (error) {
            result.textContent = error.message;
            result.className = 'expression-result error';
            
            // Показываем подсказку по исправлению ошибки
            statusDiv.innerHTML = this.generateErrorHelp(error.message, expression);
            statusDiv.className = 'expression-status error';
            
            this.lastExpressionResult = null;
        }
    }

    // Создание элемента статуса, если его нет
    createStatusElement() {
        let statusDiv = document.getElementById('expression-status');
        if (!statusDiv) {
            statusDiv = document.createElement('div');
            statusDiv.id = 'expression-status';
            statusDiv.className = 'expression-status';
            statusDiv.textContent = 'Готов к вводу...';
            
            const resultDiv = document.getElementById('expression-result');
            if (resultDiv && resultDiv.parentNode) {
                resultDiv.parentNode.insertBefore(statusDiv, resultDiv.nextSibling);
            }
        }
        return statusDiv;
    }

    // Форматирование результата с дополнительной информацией
    formatAdvancedResult(value) {
        if (!isFinite(value)) {
            if (value === Infinity) return '<span class="infinity">∞</span>';
            if (value === -Infinity) return '<span class="infinity">-∞</span>';
            return '<span class="nan">NaN</span>';
        }
        
        let result = '';
        
        // Основной результат
        if (Number.isInteger(value) && Math.abs(value) < 1e15) {
            result = `<span class="number-main">${value}</span>`;
        } else {
            const formatted = parseFloat(value.toFixed(10));
            result = `<span class="number-main">${formatted}</span>`;
        }
        
        // Дополнительные представления
        let additional = [];
        
        // Дробь (если применимо)
        if (Math.abs(value) < 1000 && !Number.isInteger(value)) {
            try {
                const fraction = AdvancedMathEngine.functions.toFraction(value);
                if (fraction.denominator <= 100) {
                    additional.push(`<span class="fraction">${fraction.string}</span>`);
                }
            } catch (e) {}
        }
        
        // Процент
        if (Math.abs(value) <= 10) {
            additional.push(`<span class="percent">${(value * 100).toFixed(2)}%</span>`);
        }
        
        // Научная нотация для больших чисел
        if (Math.abs(value) >= 1e6 || (Math.abs(value) <= 1e-4 && value !== 0)) {
            additional.push(`<span class="scientific">${value.toExponential(3)}</span>`);
        }
        
        if (additional.length > 0) {
            result += `<div class="additional-formats">${additional.join(' • ')}</div>`;
        }
        
        return result;
    }

    // Генерация информации о выражении
    generateExpressionInfo(expression, result) {
        let info = [];
        
        // Тип результата
        if (Number.isInteger(result)) {
            info.push('🔢 Целое число');
        } else {
            info.push('🔸 Десятичное число');
        }
        
        // Анализ выражения
        if (expression.includes('/')) info.push('➗ Дроби');
        if (expression.includes('^') || expression.includes('**')) info.push('🔋 Степени');
        if (/sin|cos|tan/.test(expression)) info.push('📐 Тригонометрия');
        if (/log|ln/.test(expression)) info.push('📊 Логарифмы');
        if (expression.includes('!')) info.push('❗ Факториал');
        if (expression.includes('|')) info.push('📏 Модуль');
        if (expression.includes('%')) info.push('💯 Проценты');
        
        return '✅ ' + info.join(' • ');
    }

    // Генерация помощи при ошибках
    generateErrorHelp(errorMessage, expression) {
        let help = ['❌ ' + errorMessage];
        
        // Предлагаем решения
        if (errorMessage.includes('неожиданный символ')) {
            help.push('💡 Проверьте скобки и операторы');
        }
        if (errorMessage.includes('деление на ноль')) {
            help.push('💡 Избегайте деления на ноль');
        }
        if (errorMessage.includes('функция')) {
            help.push('💡 Доступны: sin, cos, tan, log, ln, sqrt, abs...');
        }
        
        return help.join('<br>');
    }

    preprocessExpression(expr) {
        // Заменяем функции на JavaScript эквиваленты
        let processed = expr
            .replace(/\bsin\(/g, 'Math.sin(')
            .replace(/\bcos\(/g, 'Math.cos(')
            .replace(/\btan\(/g, 'Math.tan(')
            .replace(/\basin\(/g, 'Math.asin(')
            .replace(/\bacos\(/g, 'Math.acos(')
            .replace(/\batan\(/g, 'Math.atan(')
            .replace(/\bsinh\(/g, 'Math.sinh(')
            .replace(/\bcosh\(/g, 'Math.cosh(')
            .replace(/\btanh\(/g, 'Math.tanh(')
            .replace(/\babs\(/g, 'Math.abs(')
            .replace(/\bsqrt\(/g, 'Math.sqrt(')
            .replace(/\bcbrt\(/g, 'Math.cbrt(')
            .replace(/\bln\(/g, 'Math.log(')
            .replace(/\blog\(/g, 'Math.log10(')
            .replace(/\bexp\(/g, 'Math.exp(')
            .replace(/\bfloor\(/g, 'Math.floor(')
            .replace(/\bceil\(/g, 'Math.ceil(')
            .replace(/\bround\(/g, 'Math.round(')
            .replace(/\bmax\(/g, 'Math.max(')
            .replace(/\bmin\(/g, 'Math.min(')
            .replace(/\bpow\(/g, 'Math.pow(')
            .replace(/\brandom\(/g, 'Math.random(')
            .replace(/\bpi\b/g, 'Math.PI')
            .replace(/\be\b/g, 'Math.E')
            .replace(/\^/g, '**'); // Степень

        // Обрабатываем градусы для тригонометрических функций
        if (this.angleMode === 'deg') {
            processed = processed
                .replace(/Math\.sin\(/g, 'Math.sin(Math.PI/180*')
                .replace(/Math\.cos\(/g, 'Math.cos(Math.PI/180*')
                .replace(/Math\.tan\(/g, 'Math.tan(Math.PI/180*');
        }

        return processed;
    }

    insertExpressionResult() {
        if (this.lastExpressionResult !== null) {
            this.currentResult = this.formatResult(this.lastExpressionResult);
            this.currentExpression = this.lastExpression || '';
            this.updateDisplay();
            
            // Закрываем редактор выражений
            const panel = document.getElementById('expression-editor-panel');
            if (panel) {
                panel.classList.remove('active');
            }

            // Очищаем поле ввода
            const input = document.getElementById('expression-input');
            if (input) {
                input.value = '';
            }

            // Очищаем результат
            const result = document.getElementById('expression-result');
            if (result) {
                result.textContent = '-';
                result.className = 'expression-result';
            }
        }
    }

    // Методы для редактора выражений
    calculateExpression() {
        const expressionInput = document.getElementById('expression-input');
        const expressionResult = document.getElementById('expression-result');
        
        if (!expressionInput || !expressionResult) return;
        
        let expression = expressionInput.value.trim();
        if (!expression) {
            expressionResult.textContent = this.translate('expression-error');
            expressionResult.className = 'expression-result error';
            return;
        }
        
        try {
            // Предварительная обработка выражения
            expression = this.preprocessExpression(expression);
            
            const result = MathUtils.evaluate(expression);
            expressionResult.textContent = this.formatResult(result);
            expressionResult.className = 'expression-result success';
            this.lastExpressionResult = result;
        } catch (error) {
            expressionResult.textContent = this.translate('expression-error') + ': ' + error.message;
            expressionResult.className = 'expression-result error';
            this.lastExpressionResult = null;
        }
    }

    preprocessExpression(expr) {
        // Заменяем функции и константы
        expr = expr.replace(/π/g, 'Math.PI')
                  .replace(/pi/gi, 'Math.PI')
                  .replace(/\be\b/gi, 'Math.E')
                  .replace(/\^/g, '**')
                  .replace(/×/g, '*')
                  .replace(/÷/g, '/')
                  .replace(/√/g, 'Math.sqrt');

        // Добавляем символы умножения где нужно
        expr = expr.replace(/(\d)(\()/g, '$1*$2') // 2(3) -> 2*(3)
                  .replace(/(\))(\d)/g, '$1*$2') // (3)2 -> (3)*2
                  .replace(/(\))(\()/g, '$1*$2'); // (3)(2) -> (3)*(2)

        // Обрабатываем тригонометрические функции в зависимости от режима углов
        if (this.angleMode === 'deg') {
            expr = expr.replace(/sin\s*\(/gi, 'Math.sin(Math.PI/180*')
                      .replace(/cos\s*\(/gi, 'Math.cos(Math.PI/180*')
                      .replace(/tan\s*\(/gi, 'Math.tan(Math.PI/180*');
        }

        return expr;
    }

    insertExpressionResult() {
        if (this.lastExpressionResult !== null && this.lastExpressionResult !== undefined) {
            this.currentResult = this.formatResult(this.lastExpressionResult);
            this.currentExpression = '';
            this.updateDisplay();
            
            // Закрываем редактор выражений
            const panel = document.getElementById('expression-editor-panel');
            if (panel) {
                panel.classList.remove('active');
            }
        }
    }

    // Вспомогательный метод для скачивания файлов в браузере
    downloadBlob(blob, filename) {
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = filename;
        a.style.display = 'none';
        
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
    }

    // Методы для скачивания установщика
    async downloadPortableVersion() {
        this.showProgressMessage('🚀 Подготавливаем портативную версию...');
        
        try {
            // Создаем инструкции для портативной версии
            const instructions = `# Advanced Calculator - Портативная версия

🚀 Полная установка:
1. Скачайте проект с GitHub: https://github.com/yourusername/advanced-calculator
2. Распакуйте архив
3. Откройте командную строку в папке проекта
4. Выполните: npm install
5. Запустите: npm start

✨ Возможности калькулятора:
- 🧮 Базовые и научные вычисления
- 📐 Работа с дробями и смешанными числами  
- 🔢 Сложные математические функции
- 🌍 Поддержка 4 языков (русский, английский, норвежский, голландский)
- 📊 Автоматические вычисления
- ⌨️ Редактор математических выражений
- 📈 История вычислений
- 🎨 Красивый современный интерфейс

📋 Системные требования:
- Windows 10/11
- Node.js 16.0.0 или выше
- npm 8.0.0 или выше

🔧 Альтернативная установка:
- Используйте встроенную систему загрузки в приложении
- Запустите npm run build-win для создания .exe файла

Версия: 2.0.0
© 2025 Advanced Calculator`;
            
            const blob = new Blob([instructions], { type: 'text/plain; charset=utf-8' });
            this.downloadBlob(blob, 'Advanced-Calculator-Portable-Instructions.txt');
            
            this.hideProgressMessage();
            this.showSuccessMessage('✅ Инструкции скачаны!', 'Следуйте инструкциям в файле для полной установки');
            
        } catch (error) {
            this.hideProgressMessage();
            this.showErrorMessage('❌ Ошибка создания портативной версии', error.message);
        }
        
        // Закрываем модальное окно (временно отключено)
        // const modal = document.getElementById('download-installer-modal');
        // if (modal) modal.style.display = 'none';
    }

    async downloadInstallerVersion() {
        this.showProgressMessage('🔧 Создаем установщик Windows...');
        
        try {
            // Создаем bat-файл установщик
            const installerScript = `@echo off
title Advanced Calculator - Установщик Windows
color 0A
cls

echo ================================================
echo    Advanced Calculator - Установщик Windows
echo ================================================
echo.
echo 🚀 Добро пожаловать в мастер установки!
echo.
echo ✨ Возможности калькулятора:
echo - 🧮 Базовые и научные вычисления
echo - 📐 Работа с дробями и смешанными числами
echo - 🔢 Сложные математические функции
echo - 🌍 Поддержка 4 языков
echo - 📊 Автоматические вычисления
echo - ⌨️ Редактор математических выражений
echo - 📈 История вычислений
echo.
echo ================================================
echo.
echo 📋 Инструкции по установке:
echo.
echo 1. Скачайте Node.js с https://nodejs.org
echo 2. Скачайте проект с GitHub
echo 3. Откройте командную строку в папке проекта
echo 4. Выполните: npm install
echo 5. Запустите: npm start
echo.
echo 🔧 Для создания .exe файла:
echo    npm run build-win
echo.
echo ================================================
echo             © 2025 Advanced Calculator
echo ================================================
echo.
echo Нажмите любую клавишу для завершения...
pause >nul
cls
echo Спасибо за использование Advanced Calculator!
timeout /t 2 >nul`;
            
            const blob = new Blob([installerScript], { type: 'text/plain; charset=utf-8' });
            this.downloadBlob(blob, 'Advanced-Calculator-Setup.bat');
            
            this.hideProgressMessage();
            this.showSuccessMessage('✅ Установщик создан!', 'Запустите .bat файл для просмотра инструкций');
            
        } catch (error) {
            this.hideProgressMessage();
            this.showErrorMessage('❌ Ошибка создания установщика', error.message);
        }
        
        // Закрываем модальное окно (временно отключено)
        // const modal = document.getElementById('download-installer-modal');
        // if (modal) modal.style.display = 'none';
    }

    async downloadFileFromWeb(type) {
        // Для веб-версии создаем файл прямо в браузере
        const fileName = type === 'portable' ? 'Advanced-Calculator-Portable.zip' : 'Advanced-Calculator-Setup.exe';
        
        // Создаем простой файл-заглушку с инструкциями
        const content = type === 'portable' 
            ? this.createPortableInstructions()
            : this.createInstallerInstructions();
            
        const blob = new Blob([content], { type: 'text/plain' });
        const url = URL.createObjectURL(blob);
        
        const a = document.createElement('a');
        a.href = url;
        a.download = fileName.replace('.zip', '.txt').replace('.exe', '.txt');
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
        
        this.hideProgressMessage();
        this.showSuccessMessage('📄 Инструкции скачаны!', 'Файл содержит ссылки и инструкции по установке');
    }

    createPortableInstructions() {
        return `# Advanced Calculator - Портативная версия

🚀 Ссылка для скачивания портативной версии:
https://github.com/your-repo/releases/latest/download/Advanced-Calculator-Portable.zip

📱 Что это такое?
- Не требует установки
- Запускается сразу после распаковки
- Размер: ~100 МБ
- Работает на Windows 7/8/10/11

⚡ Как использовать:
1. Скачайте ZIP-архив по ссылке выше
2. Распакуйте в любую папку
3. Запустите "Advanced Calculator.exe"

✨ Возможности:
- Базовые и научные вычисления
- Работа с дробями
- 4 языка интерфейса
- История вычислений
- Автоматические вычисления

© 2024 Advanced Calculator
`;
    }

    createInstallerInstructions() {
        return `# Advanced Calculator - Установщик Windows

💾 Ссылка для скачивания установщика:
https://github.com/your-repo/releases/latest/download/Advanced-Calculator-Setup.exe

🔧 Что это такое?
- Полная установка Windows
- Создает ярлыки в меню и на рабочем столе
- Автоматическое обновление
- Размер: ~110 МБ

⚡ Как установить:
1. Скачайте .exe файл по ссылке выше
2. Запустите установщик
3. Следуйте инструкциям мастера установки
4. Найдите калькулятор в меню Пуск

✨ Возможности:
- Базовые и научные вычисления
- Работа с дробями
- 4 языка интерфейса
- История вычислений
- Автоматические вычисления

© 2024 Advanced Calculator
`;
    }

    async createPortableArchive(outputPath) {
        const archiver = window.require('archiver');
        const fs = window.require('fs');
        const path = window.require('path');
        
        return new Promise((resolve, reject) => {
            const distPath = path.join(process.cwd(), 'dist', 'win-unpacked');
            
            if (!fs.existsSync(distPath)) {
                reject(new Error('Портативная версия не найдена. Сначала выполните: npm run pack'));
                return;
            }
            
            const output = fs.createWriteStream(outputPath);
            const archive = archiver('zip', { zlib: { level: 9 } });
            
            output.on('close', () => {
                const sizeInMB = (archive.pointer() / 1024 / 1024).toFixed(2);
                resolve(`Портативная версия создана: ${outputPath} (${sizeInMB} МБ)`);
            });
            
            archive.on('error', (err) => {
                reject(err);
            });
            
            archive.pipe(output);
            archive.directory(distPath, 'Advanced-Calculator');
            archive.finalize();
        });
    }

    showProgressMessage(message) {
        // Удаляем предыдущее уведомление
        this.hideProgressMessage();
        
        // Создаем прогресс-уведомление
        const notification = document.createElement('div');
        notification.id = 'progress-notification';
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            background: linear-gradient(45deg, #4CAF50, #45a049);
            color: white;
            padding: 20px 25px;
            border-radius: 15px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
            z-index: 10000;
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif;
            font-size: 16px;
            max-width: 350px;
            animation: slideIn 0.3s ease;
            backdrop-filter: blur(10px);
        `;
        
        notification.innerHTML = `
            <div style="display: flex; align-items: center; gap: 15px;">
                <div style="
                    width: 20px;
                    height: 20px;
                    border: 3px solid rgba(255,255,255,0.3);
                    border-top: 3px solid white;
                    border-radius: 50%;
                    animation: spin 1s linear infinite;
                "></div>
                <div>${message}</div>
            </div>
        `;
        
        // Добавляем CSS анимации
        if (!document.getElementById('notification-styles')) {
            const style = document.createElement('style');
            style.id = 'notification-styles';
            style.textContent = `
                @keyframes slideIn {
                    from { transform: translateX(100%); opacity: 0; }
                    to { transform: translateX(0); opacity: 1; }
                }
                @keyframes spin {
                    0% { transform: rotate(0deg); }
                    100% { transform: rotate(360deg); }
                }
                @keyframes bounce {
                    0%, 20%, 60%, 100% { transform: translateY(0); }
                    40% { transform: translateY(-10px); }
                    80% { transform: translateY(-5px); }
                }
            `;
            document.head.appendChild(style);
        }
        
        document.body.appendChild(notification);
    }

    hideProgressMessage() {
        const notification = document.getElementById('progress-notification');
        if (notification) {
            notification.style.animation = 'slideIn 0.3s ease reverse';
            setTimeout(() => notification.remove(), 300);
        }
    }

    showSuccessMessage(title, message) {
        // Удаляем предыдущие уведомления
        this.hideProgressMessage();
        this.hideErrorMessage();
        
        const notification = document.createElement('div');
        notification.id = 'success-notification';
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            background: linear-gradient(135deg, #4CAF50, #45a049);
            color: white;
            padding: 25px;
            border-radius: 20px;
            box-shadow: 0 15px 40px rgba(76, 175, 80, 0.4);
            z-index: 10000;
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif;
            max-width: 400px;
            animation: slideIn 0.5s ease, bounce 0.6s ease 0.2s;
            backdrop-filter: blur(15px);
            border: 1px solid rgba(255,255,255,0.2);
        `;
        
        notification.innerHTML = `
            <div style="display: flex; align-items: flex-start; gap: 15px;">
                <div style="font-size: 24px; animation: bounce 0.6s ease;">✅</div>
                <div>
                    <div style="font-size: 18px; font-weight: 600; margin-bottom: 8px;">${title}</div>
                    <div style="font-size: 14px; opacity: 0.9; line-height: 1.4;">${message}</div>
                </div>
                <button onclick="this.parentElement.parentElement.remove()" style="
                    background: none;
                    border: none;
                    color: white;
                    font-size: 20px;
                    cursor: pointer;
                    opacity: 0.7;
                    margin-left: auto;
                    padding: 0;
                    width: 25px;
                    height: 25px;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                ">×</button>
            </div>
        `;
        
        document.body.appendChild(notification);
        
        // Автоматически скрываем через 8 секунд
        setTimeout(() => {
            if (notification.parentElement) {
                notification.style.animation = 'slideIn 0.3s ease reverse';
                setTimeout(() => notification.remove(), 300);
            }
        }, 8000);
    }

    showErrorMessage(title, message) {
        // Удаляем предыдущие уведомления
        this.hideProgressMessage();
        this.hideSuccessMessage();
        
        const notification = document.createElement('div');
        notification.id = 'error-notification';
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            background: linear-gradient(135deg, #f44336, #d32f2f);
            color: white;
            padding: 25px;
            border-radius: 20px;
            box-shadow: 0 15px 40px rgba(244, 67, 54, 0.4);
            z-index: 10000;
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif;
            max-width: 400px;
            animation: slideIn 0.5s ease;
            backdrop-filter: blur(15px);
            border: 1px solid rgba(255,255,255,0.2);
        `;
        
        notification.innerHTML = `
            <div style="display: flex; align-items: flex-start; gap: 15px;">
                <div style="font-size: 24px;">❌</div>
                <div>
                    <div style="font-size: 18px; font-weight: 600; margin-bottom: 8px;">${title}</div>
                    <div style="font-size: 14px; opacity: 0.9; line-height: 1.4;">${message}</div>
                </div>
                <button onclick="this.parentElement.parentElement.remove()" style="
                    background: none;
                    border: none;
                    color: white;
                    font-size: 20px;
                    cursor: pointer;
                    opacity: 0.7;
                    margin-left: auto;
                    padding: 0;
                    width: 25px;
                    height: 25px;
                    display: flex;
                    align-items: center;
                    justify-content: center;
                ">×</button>
            </div>
        `;
        
        document.body.appendChild(notification);
        
        // Автоматически скрываем через 10 секунд
        setTimeout(() => {
            if (notification.parentElement) {
                notification.style.animation = 'slideIn 0.3s ease reverse';
                setTimeout(() => notification.remove(), 300);
            }
        }, 10000);
    }

    hideSuccessMessage() {
        const notification = document.getElementById('success-notification');
        if (notification) {
            notification.remove();
        }
    }

    hideErrorMessage() {
        const notification = document.getElementById('error-notification');
        if (notification) {
            notification.remove();
        }
    }

    showDownloadInstructions(type) {
        const message = type === 'portable' 
            ? 'Портативная версия доступна в папке dist/win-unpacked/ вашего проекта.\n\nДля создания ZIP-архива выполните: npm run create-portable'
            : 'Для создания установщика выполните команду: npm run build-win\n\nУстановщик будет создан в папке dist/';
            
        if (typeof window.require !== 'undefined') {
            const { dialog } = window.require('electron');
            dialog.showMessageBox({
                type: 'info',
                title: 'Инструкции по скачиванию',
                message: message,
                buttons: ['OK']
            });
        } else {
            alert(message);
        }
    }
}

// Инициализация калькулятора при загрузке страницы
document.addEventListener('DOMContentLoaded', () => {
    new AdvancedCalculator();
});