use eframe::egui;

fn main() {
    let options = eframe::NativeOptions::default();
    eframe::run_native(
        "Криптографические методы защиты информации",
        options,
        Box::new(|_cc| Box::new(MyApp::default())),
    );
}

struct MyApp {
    order: u32,
    lastorder: u32,
    elements: Vec<u32>,
    computing: bool,
    current: u32,
    error: bool,
}

impl Default for MyApp {
    fn default() -> Self {
        Self {
            order: 29,
            lastorder: 0,
            elements: Vec::new(),
            computing: false,
            current: 1,
            error: false,
        }
    }
}

fn modpow(x: u32, e: u32, m: u32) -> u32 {
    let mut pow = x;
    for _ in 1..e {
        pow = (pow * x) % m;
    }
    return pow;
}

fn is_prime(x: u32) -> bool {
    if x <= 1 {
        return false;
    }
    for i in 2..x / 2 + 1 {
        if x % i == 0 {
            return false;
        }
    }
    return true;
}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        if self.lastorder != self.order {
            self.lastorder = 0;
            self.computing = false;
            self.error = false;
        }
        egui::Window::new("Задача №1").show(ctx, |ui| {
            ui.add(egui::Slider::new(&mut self.order, 1..=4294967295).text("порядок поля"));
            if ui.button("Рассчитать порождающие элементы").clicked() {
                self.elements.clear();
                if is_prime(self.order) {
                    self.computing = true;
                    self.current = 1;
                }
                else {
                    self.error = true;
                }
                self.lastorder = self.order;
            }
            if self.computing {
                ui.label("Вычисление...");
                let mut min = 0;
                for power in 1..self.order {
                    let pow = modpow(self.current, power, self.order);
                    if pow == 1 {
                        min = power;
                        break;
                    }
                }
                if min == self.order - 1 {
                    self.elements.push(self.current);
                }
                if self.current == self.order - 1 {
                    self.computing = false;
                }
                else {
                    self.current += 1;
                }
            }
            else if self.lastorder == self.order {
                if self.error {
                    ui.label("Можно указать только простое число!");
                }
                else {
                    ui.label(format!("Порождающие элементы поля F_{}: {:?}", self.order, self.elements));
                }
            }
        });
    }
}