// =============================================================================
// УПРОЩЕННАЯ УЧЕБНАЯ ПРОГРАММА: МОДЕЛИРОВАНИЕ РАСХОДА ТОПЛИВА
// =============================================================================

// Простая функция для расчета секундного расхода топлива.
// Принимает тягу двигателя и качество его настройки (эффективность).
fn calculate_flow(thrust: f64, efficiency: f64) -> f64 {
    thrust / efficiency
}

fn main() {
    println!("--- СИМУЛЯЦИЯ РАБОТЫ ДВИГАТЕЛЯ ---");

    // 1. НЕИЗМЕНЯЕМЫЕ ПЕРЕМЕННЫЕ (let)
    // Эти значения не меняются на протяжении всей работы
    let thrust = 20.0;       // Тяга двигателя (в Ньютонах)
    let efficiency = 250.0;   // Эффективность двигателя

    // Расчет секундного расхода топлива с помощью нашей функции
    let fuel_flow = calculate_flow(thrust, efficiency);
    println!("Расход топлива в секунду: {} кг/с", fuel_flow);

    // 2. ИЗМЕНЯЕМАЯ ПЕРЕМЕННАЯ (let mut)
    // Масса топлива в баке будет уменьшаться, поэтому нужен mut
    let mut fuel_mass = 50.0; // Стартовый запас топлива (в кг)
    
    // Переменная-счетчик для учета времени работы двигателя
    let mut seconds_passed = 0;

    // 3. ОБЫЧНЫЙ ЦИКЛ (while)
    // Работаем, пока в баке есть топливо (больше нуля)
    println!("\n[Запуск двигателя. Симуляция до полного опустошения бака]");
    
    while fuel_mass > 0.0 {
        // Уменьшаем запас топлива на величину секундного расхода
        fuel_mass = fuel_mass - fuel_flow;
        
        // Увеличиваем счетчик времени на 1 секунду
        seconds_passed = seconds_passed + 1;

        println!("Секунда {}: остаток топлива: {:.2} кг", seconds_passed, fuel_mass);
    }

    println!("\n[Двигатель заглох. Время работы: {} с]", seconds_passed);

    // 4. ОБЫЧНОЕ УСЛОВИЕ (if / else)
    // Проверяем, хватило ли времени работы для успешного маневра
    // Допустим, для выхода на нужную орбиту двигатель должен был отработать 500 секунд
    if seconds_passed >= 500 {
        println!("Статус: Успех! Корабль успешно вышел на заданную орбиту.");
    } else {
        println!("Статус: Отказ! Не хватило топлива для завершения маневра.");
    }

    println!("-----------------------------------");
}

// =============================================================================
// КОМПАКТНАЯ УЧЕБНАЯ ПРОГРАММА: МОДЕЛИРОВАНИЕ ОРБИТАЛЬНОГО МАНЕВРА
// =============================================================================

// 1. ДЕМОНСТРАЦИЯ: const (Константа)
// Ускорение свободного падения для расчета удельного импульса
const G0: f64 = 9.81;

// 2. ДЕМОНСТРАЦИЯ: функции (Расчет расхода топлива в кг/с)
fn calculate_fuel_flow(thrust: f64, isp: f64) -> f64 {
    thrust / (isp * G0) // Возврат значения выражением (без return и `;`)
}

// Вспомогательная функция классификации двигателя
fn get_engine_class(thrust: f64) -> &'static str {
    // 3. ДЕМОНСТРАЦИЯ: if else if else
    if thrust < 10.0 {
        "Маломощный"
    } else if thrust < 100.0 {
        "Стандартный"
    } else {
        "Мощный"
    }
}

fn main() {
    println!("--- СИСТЕМА УПРАВЛЕНИЯ МАНЕВРОМ ---");

    // 4. ДЕМОНСТРАЦИЯ: let (Неизменяемые переменные)
    let thrust = 25.0;            // Тяга двигателя (Н)
    let specific_impulse = 290.0; // Удельный импульс (с)

    // 5. ДЕМОНСТРАЦИЯ: let mut (Изменяемая переменная — бак теперь пустеет!)
    let mut fuel_mass = 120.0;     // Запас топлива (кг)
    
    // Расчет расхода топлива через функцию
    let fuel_flow = calculate_fuel_flow(thrust, specific_impulse);

    // 6. ДЕМОНСТРАЦИЯ: цикл for (Симуляция 5-секундного маневра шаг за шагом)
    println!("\n[Запуск двигателя. Длительность маневра: 5 секунд]");
    for second in 1..=5 {
        // Уменьшаем реальный запас топлива в баке каждую секунду
        fuel_mass -= fuel_flow;
        println!("Секунда {}: топливо сгорает... Остаток: {:.4} кг", second, fuel_mass);
    }

    // 7. ДЕМОНСТРАЦИЯ: цикл while (Откачка остатков газов из магистрали после отключения)
    let mut purge_time = 0.0;
    while purge_time < 3.0 {
        purge_time += 1.0;
    }
    println!("[Двигатель отключен. Продувка системы... Готово за {} с]", purge_time);

    // 8. ДЕМОНСТРАЦИЯ: цикл loop и break (Поиск резервного времени работы на остатках)
    let mut emergency_time = 0.0;
    loop {
        // Проверяем, хватит ли остатка топлива еще на один шаг
        if fuel_mass < fuel_flow {
            break; // 9. ДЕМОНСТРАЦИЯ: break (Выход из бесконечного цикла, если бак пуст)
        }
        fuel_mass -= fuel_flow;
        emergency_time += 1.0;
    }
    println!("[Анализ ЧС]: Дополнительный аварийный резерв работы: {} с", emergency_time);

    // 10. ДЕМОНСТРАЦИЯ: затенение переменных (Variable Shadowing)
    // Переводим оставшуюся массу из кг в тонны для финального отчета
    let fuel_mass = fuel_mass / 1000.0; 
    println!("\nФинальный остаток топлива в тоннах: {:.6} т", fuel_mass);

    // Превращаем тонны обратно в кг для логики ветвления (снова затенение)
    let fuel_mass = fuel_mass * 1000.0;

    // 11. ДЕМОНСТРАЦИЯ: if как выражение (Тернарный аналог в Rust)
    let status = if fuel_mass > 10.0 {
        "Маневр успешен. Корабль на заданной орбите."
    } else {
        "Внимание! Критический остаток топлива!"
    };
    println!("Статус миссии: {}", status);

    // 12. ДЕМОНСТРАЦИЯ: простой if и if else
    if thrust > 20.0 {
        println!("Уведомление: Стабилизация курса выполнена штатно.");
    } else {
        println!("Уведомление: Требуется более длительный импульс.");
    }

    // 13. ДЕМОНСТРАЦИЯ: match (Сопоставление с образцом на основе класса двигателя)
    match get_engine_class(thrust) {
        "Маломощный" => println!("Конфигурация: Подходит для точной ориентации спутников."),
        "Стандартный" => println!("Конфигурация: Оптимально для большинства легких кораблей."),
        _ => println!("Конфигурация: Требуется усиленная термозащита корпуса."),
    }

    println!("-----------------------------------");
}

use rand::Rng;
use rand::RngExt;

// Генерация случайного числа
fn random_number(min: f64, max: f64) -> f64 {
    let mut rng = rand::rng();
    rng.random_range(min..max)
}

fn main() {
    const PI: f64 = 3.14;

    let radius = random_number(1.0, 10.0);
    let pipe_thickness = random_number(1.0, 10.0);

    println!("Внутренний радиус = {}, Толщина стенки цилиндра = {}", radius, pipe_thickness);
    println!("================");
    println!("Внешний радиус: {}", radius + pipe_thickness);
    println!("Внутренний периметр цилиндра: {}", 2.0 * PI * radius);
}

use std::io;

fn main() {
    println!("=== Простой калькулятор на Rust ===");
    println!("Для выхода введите 'q' или оставьте строку пустой\n");

    loop {
        // Читаем первое число
        let num1 = match read_number("Введите первое число (или q для выхода):") {
            Some(n) => n,
            None => break,
        };

        // Читаем оператор
        let operator = read_operator();

        // Читаем второе число
        let num2 = match read_number("Введите второе число:") {
            Some(n) => n,
            None => continue,
        };

        // Выполняем вычисление
        match calculate(num1, &operator, num2) {
            Ok(result) => {
                println!("Результат: {} {} {} = {:.4}", num1, operator, num2, result);
            }
            Err(msg) => println!("Ошибка: {}", msg),
        }

        // Исправленная строка-разделитель
        println!("{}", "─".repeat(40));
    }

    println!("До свидания! 👋");
}

// ====================== ФУНКЦИИ ======================

fn read_number(prompt: &str) -> Option<f64> {
    loop {
        println!("{}", prompt);
        let mut input = String::new();
        
        if io::stdin().read_line(&mut input).is_err() {
            println!("Ошибка чтения ввода!");
            continue;
        }

        let input = input.trim();

        if input.eq_ignore_ascii_case("q") || input.is_empty() {
            return None;
        }

        match input.parse::<f64>() {
            Ok(num) => return Some(num),
            Err(_) => println!("Ошибка: введите корректное число!"),
        }
    }
}

fn read_operator() -> String {
    loop {
        println!("Введите оператор (+, -, *, /):");
        let mut input = String::new();

        if io::stdin().read_line(&mut input).is_err() {
            continue;
        }

        let op = input.trim();

        if matches!(op, "+" | "-" | "*" | "/") {
            return op.to_string();
        } else {
            println!("Ошибка: допустимы только +, -, *, /");
        }
    }
}

fn calculate(a: f64, op: &str, b: f64) -> Result<f64, String> {
    match op {
        "+" => Ok(a + b),
        "-" => Ok(a - b),
        "*" => Ok(a * b),
        "/" => {
            if b == 0.0 {
                Err("Деление на ноль!".to_string())
            } else {
                Ok(a / b)
            }
        }
        _ => Err("Неизвестный оператор".to_string()),
    }
}

use std::io;

fn read_number(prompt: &str) -> f64 {
    println!("{}", prompt);

    let mut input = String::new();

    io::stdin()
        .read_line(&mut input)
        .expect("Ошибка чтения");

    input
        .trim()
        .parse()
        .expect("Это не число")
}

fn main() {
    println!("--- Простой калькулятор (сложение) ---");

    let num1 = read_number("Введите первое число:");
    let num2 = read_number("Введите второе число:");

    let result = num1 + num2;

    println!("Результат: {} + {} = {}", num1, num2, result);
}

use std::io;

fn main() {
    println!("--- Простой калькулятор (сложение) ---");

    println!("Введите первое число:");
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Ошибка чтения");
    let num1: f64 = input1.trim().parse().expect("Это не число");

    println!("Введите второе число:");
    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Ошибка чтения");
    let num2: f64 = input2.trim().parse().expect("Это не число");

    let result = num1 + num2;
    println!("Результат: {} + {} = {}", num1, num2, result);
}

use std::io;

fn read_number(prompt: &str) -> f64 {
    println!("{}", prompt);

    let mut input = String::new();

    io::stdin().read_line(&mut input).unwrap();

    input.trim().parse().unwrap()
}

fn main() {
    let a = read_number("Введите первое число:");
    let b = read_number("Введите второе число:");

    println!("Результат: {}", a + b);
}