// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AlexMathLab {
    function basicArithmetic(uint256 a, uint256 b) public pure returns (uint256, uint256, uint256, uint256, uint256) {
        uint256 sum = a + b;        // Сложение
        uint256 difference = a - b; // Вычитание
        uint256 product = a * b;    // Умножение
        uint256 quotient = a / b;   // Деление
        uint256 remainder = a % b;  // Остаток от деления

        return (sum, difference, product, quotient, remainder);
    }
}

contract AlexAdvancedMath {
    // Вычисление сложных процентов
    function calculateCompoundInterest(
        uint256 principal,      // Основная сумма
        uint256 rate,          // Процентная ставка (в базисных пунктах)
        uint256 periods        // Количество периодов
    ) public pure returns (uint256) {
        uint256 amount = principal;

        for (uint256 i = 0; i < periods; i++) {
            amount = amount + (amount * rate / 10000);  // rate в базисных пунктах
        }

        return amount;
    }

    // Вычисление среднего значения
    function calculateAverage(uint256 a, uint256 b, uint256 c) public pure returns (uint256) {
        return (a + b + c) / 3;
    }
}

contract AlexDivisionExamples {
    function demonstrateDivision() public pure returns (uint256, uint256, uint256, uint256) {
        uint256 example1 = 15 / 4;  // = 3 (не 3.75)
        uint256 example2 = 7 / 3;   // = 2 (не 2.33)
        uint256 example3 = 5 / 10;  // = 0 (не 0.5)
        uint256 example4 = 99 / 100; // = 0 (не 0.99)

        return (example1, example2, example3, example4);
    }
}

// ❌ НЕПРАВИЛЬНО - потеряем всю комиссию!
function calculateFeeBad(uint256 amount) public pure returns (uint256) {
    return amount * 25 / 1000;  // 2.5% = 25/1000, но что если amount = 30?
    // При amount = 30: 30 * 25 = 750, 750 / 1000 = 0 (потеряли комиссию!)
}
// ✅ ТАК ЛУЧШЕ - используем базисные пункты для точности
function calculateFeeBest(uint256 amount) public pure returns (uint256) {
    // 2.5% = 250 базисных пунктов (из 10000)
    return amount * 250 / 10000;  // Больше точности для малых сумм
}

if (условие) {
    // код, который выполнится, если условие истинно (true)
} else if (другое_условие) {
    // код, который выполнится, если первое условие ложно, а второе истинно
} else {
    // код, который выполнится, если все предыдущие условия ложны
}

contract IfElseExamples {
    // Простое условие if
    function simpleIf(uint256 value) public pure returns (string memory) {
        if (value > 10) {
            return "Значение больше 10";
        }
        return "Значение 10 или меньше";  // Выполнится, если условие ложно
    }

    // if-else
    function ifElse(uint256 age) public pure returns (string memory) {
        if (age >= 18) {
            return "Совершеннолетний";
        } else {
            return "Несовершеннолетний";
        }
    }

    // if-else if-else (множественные условия)
    function gradeSystem(uint256 score) public pure returns (string memory) {
        if (score >= 90) {
            return "Отлично";
        } else if (score >= 80) {
            return "Хорошо";
        } else if (score >= 70) {
            return "Удовлетворительно";
        } else if (score >= 60) {
            return "Зачёт";
        } else {
            return "Незачёт";
        }
    }

    // Вложенные условия
    function accessControl(address user, uint256 balance, bool isActive) public view returns (string memory) {
        if (isActive) {
            if (user == msg.sender) {
                if (balance >= 1000) {
                    return "Полный доступ с привилегиями";
                } else {
                    return "Базовый доступ";
                }
            } else {
                return "Доступ только для владельца";
            }
        } else {
            return "Аккаунт заблокирован";
        }
    }
}

contract AlexComparisons {
    function compareNumbers(uint256 a, uint256 b) public pure returns (string memory) {
        if (a > b) {
            return "a больше b";
        } else if (a < b) {
            return "a меньше b";
        } else if (a == b) {
            return "a равно b";
        } else {
            return "Что-то пошло не так"; // Этот случай никогда не наступит
        }
    }

    function checkRange(uint256 value, uint256 min, uint256 max) public pure returns (bool) {
        return value >= min && value <= max;  // Комбинируем операции
    }

    function isEligibleForBonus(uint256 balance, uint256 stakingTime) public pure returns (bool) {
        return balance >= 1000 && stakingTime >= 30 days;  // Логика бонуса
    }
}

contract AlexLogic {
    function checkAccess(bool isOwner, bool isAdmin, bool isActive) public pure returns (string memory) {
        if (isOwner || isAdmin) {  // ИЛИ - достаточно одного условия
            return "Полный доступ";
        } else if (isActive && !isOwner) {  // И + НЕ - комбинация условий
            return "Ограниченный доступ";
        } else {
            return "Доступ запрещен";
        }
    }

    function validateTransaction(
        uint256 amount,
        uint256 balance,
        bool isBlacklisted,
        bool isActive
    ) public pure returns (bool) {
        return amount > 0 &&           // Сумма должна быть положительной
               amount <= balance &&     // Не больше баланса
               !isBlacklisted &&        // Не в черном списке
               isActive;                // Аккаунт активен
    }
}

условие ? значение_если_true : значение_если_false

contract AlexTernaryExamples {
    // Простой пример
    function getStatus(uint256 balance) public pure returns (string memory) {
        return balance >= 1000 ? "Премиум" : "Обычный";
        // Эквивалентно:
        // if (balance >= 1000) {
        //     return "Премиум";
        // } else {
        //     return "Обычный";
        // }
    }

    // Выбор максимального значения
    function getMax(uint256 a, uint256 b) public pure returns (uint256) {
        return a > b ? a : b;
    }

    // Вычисление скидки
    function calculateDiscount(uint256 amount, bool isVip) public pure returns (uint256) {
        uint256 discount = isVip ? 20 : 5;  // 20% для VIP, 5% для обычных
        return amount * discount / 100;
    }

    // Вложенные тернарные операторы (осторожно с читаемостью!)
    function getGrade(uint256 score) public pure returns (string memory) {
        return score >= 90 ? "A" :
               score >= 80 ? "B" :
               score >= 70 ? "C" :
               score >= 60 ? "D" : "F";
    }
}

contract AlexAssignments {
    uint256 public counter = 0;
    uint256 public total = 100;
    uint256 public multiplier = 1;

    function demonstrateAssignments() public {
        // Обычное присваивание
        counter = 10;

        // Сокращенные операции присваивания
        counter += 5;    // counter = counter + 5;  (теперь 15)
        counter -= 3;    // counter = counter - 3;  (теперь 12)
        counter *= 2;    // counter = counter * 2;  (теперь 24)
        counter /= 4;    // counter = counter / 4;  (теперь 6)
        counter %= 5;    // counter = counter % 5;  (теперь 1)

        // Инкремент и декремент
        counter++;       // counter = counter + 1;  (теперь 2)
        counter--;       // counter = counter - 1;  (теперь 1)
        ++counter;       // counter = counter + 1;  (теперь 2)
        --counter;       // counter = counter - 1;  (теперь 1)
    }

    function updateBalance(uint256 deposit, uint256 withdrawal) public {
        total += deposit;     // Пополнение
        total -= withdrawal;  // Снятие
        multiplier *= 2;      // Удвоение множителя
    }
}

contract AlexIncrementDemo {
    function demonstratePrefixPostfix() public pure {
        uint256 x = 5;

        // Постфиксная форма (x++) - сначала возвращает, потом изменяет
        uint256 result1 = x++;  // result1 = 5, x становится 6
        uint256 result2 = x;    // result2 = 6

        uint256 y = 5;

        // Префиксная форма (++y) - сначала изменяет, потом возвращает
        uint256 result3 = ++y;  // y становится 6, result3 = 6
        uint256 result4 = y;    // result4 = 6

        // Декремент работает аналогично
        uint256 z = 5;
        uint256 result5 = z--;  // result5 = 5, z становится 4
        uint256 result6 = --z;  // z становится 3, result6 = 3

        // Результаты: result1 = 5, result2 = 6, result3 = 6, result4 = 6, result5 = 5, result6 = 3
    }

    // Практический пример использования
    function processArray() public pure returns (uint256[] memory) {
        uint256[] memory numbers = new uint256[](3);
        uint256 index = 0;

        // Постфиксная форма - используем текущий индекс, затем увеличиваем
        numbers[index++] = 10;  // numbers[0] = 10, index становится 1
        numbers[index++] = 20;  // numbers[1] = 20, index становится 2
        numbers[index++] = 30;  // numbers[2] = 30, index становится 3

        return numbers;  // [10, 20, 30]
    }
}

contract AlexCalculator {
    uint256 public result;
    address public lastUser;

    function add(uint256 a, uint256 b) public returns (uint256) {
        result = a + b;
        lastUser = msg.sender;
        return result;
    }

    function subtract(uint256 a, uint256 b) public returns (uint256) {
        if(a < b) {
            revert("Результат не может быть отрицательным");
        }
        result = a - b;
        lastUser = msg.sender;
        return result;
    }

    function multiply(uint256 a, uint256 b) public returns (uint256) {
        result = a * b;
        lastUser = msg.sender;
        return result;
    }

    function divide(uint256 a, uint256 b) public returns (uint256) {
        if(b == 0) {
            revert("Деление на ноль невозможно");
        }
        result = a / b;
        lastUser = msg.sender;
        return result;
    }

    function power(uint256 base, uint256 exponent) public returns (uint256) {
        result = 1;
        for (uint256 i = 0; i < exponent; i++) {
            result *= base;
        }
        lastUser = msg.sender;
        return result;
    }

    function isLastUser() public view returns (bool) {
        return msg.sender == lastUser;
    }

    function reset() public {
        if(msg.sender != lastUser) {
            revert("Только последний пользователь может сбросить");
        }
        result = 0;
    }
}