use cyborg::camera::Flycam;

pub struct UserInterface {
    developer_mode: bool,
    show_profiler: bool,
    quit: bool,
    show_about: bool,
    log_contents: String,
}

impl UserInterface {
    pub fn new() -> Self {
        Self {
            developer_mode: true,
            show_profiler: false,
            quit: false,
            show_about: false,
            log_contents: "Hello logging!\n".to_string(),
        }
    }

    pub fn should_quit(&self) -> bool {
        self.quit
    }

    pub fn run(&mut self, ctx: &egui::Context, viewport: &mut ViewportWidget) {
        egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
            egui::menu::bar(ui, |ui| {
                ui.menu_button("File", |ui| {
                    if self.developer_mode {
                        if ui.button("fuck").clicked() {
                            println!("fuck");
                        }
                    }

                    if ui.button("Save").clicked() {
                        println!("Saving!");
                        ui.close_menu();
                    }

                    if ui.button("Save as...").clicked() {
                        println!("Saving as!");
                        ui.close_menu();
                    }

                    if ui.button("Open...").clicked() {
                        println!("Opening!");
                        ui.close_menu();
                    }

                    if ui.button("Quit").clicked() {
                        println!("Quitting!");
                        ui.close_menu();
                        self.quit = true;
                    }
                });

                ui.menu_button("Edit", |ui| {
                    if ui.button("Undo").clicked() {
                        println!("Undoing!");
                    }

                    if ui.button("Redo").clicked() {
                        println!("Redoing!");
                    }
                });

                ui.menu_button("View", |ui| {
                    ui.checkbox(&mut self.developer_mode, "Developer mode");

                    if ui.checkbox(&mut self.show_profiler, "Profiler").changed() {
                        puffin_egui::puffin::set_scopes_on(self.show_profiler);
                    }
                });

                ui.menu_button("Help", |ui| {
                    if ui.button("About").clicked() {
                        self.show_about = true;
                        ui.close_menu();
                    }
                });
            })
        });

        egui::Window::new("example_window").show(ctx, |ui| {
            ui.heading("Hello world!");
        });

        if self.show_profiler {
            self.show_profiler = puffin_egui::profiler_window(ctx);
        }

        if self.show_about {
            egui::Window::new("About")
                .open(&mut self.show_about)
                .resizable(false)
                .collapsible(false)
                .show(ctx, |ui| {
                    ui.vertical_centered(|ui| {
                        ui.heading("Cyborg Editor");
                    });
                });
        }

        egui::TopBottomPanel::bottom("info_panel")
            .resizable(true)
            .show(ctx, |ui| {
                ui.heading("Log Output");

                egui::containers::ScrollArea::vertical()
                    .auto_shrink([false, false])
                    .max_width(f32::INFINITY)
                    .max_height(f32::INFINITY)
                    .show(ui, |ui| {
                        let text_edit = egui::TextEdit::multiline(&mut self.log_contents)
                            .desired_width(f32::INFINITY)
                            .frame(false);
                        ui.add(text_edit);
                    });
            });

        egui::CentralPanel::default().show(ctx, |ui| {
            ui.add(viewport);
            ui.heading("Viewport");
        });
    }
}

pub struct ViewportWidget {
    pub texture: egui::TextureId,
    pub flycam: Flycam,
}

impl ViewportWidget {
    pub fn new(texture: egui::TextureId) -> Self {
        Self {
            texture,
            flycam: Flycam::new(0.002, 10.0, 0.25),
        }
    }
}

impl egui::Widget for &mut ViewportWidget {
    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
        ui.style_mut().spacing.window_margin = egui::style::Margin::same(0.0);
        let rect = ui.max_rect();
        let id = egui::Id::new("viewport_widget");
        let sense = egui::Sense::click_and_drag();
        let response = ui.interact(rect, id, sense);

        use egui::{pos2, Color32, Mesh, Rect, Shape};
        let mut mesh = Mesh::with_texture(self.texture);
        let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
        let tint = Color32::WHITE;
        mesh.add_rect_with_uv(rect, uv, tint);
        ui.painter().add(Shape::mesh(mesh));

        if response.dragged() {
            println!("dragging");
            let delta = response.drag_delta();
            self.flycam.process_mouse(delta.x as f64, delta.y as f64);
        }

        println!("{:#?}", self.flycam);

        self.flycam.update();

        response
    }
}