use crate::winit;
use crossbeam_channel::Sender;
use cyborg::camera::Flycam;
use std::path::PathBuf;

#[derive(Clone, Debug)]
pub enum FileEvent {
    Save,
    SaveAs(PathBuf),
    Import(ImportKind, PathBuf),
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum ImportKind {
    Stl,
}

pub struct UserInterface {
    file_sender: Sender<FileEvent>,
    developer_mode: bool,
    show_profiler: bool,
    quit: bool,
    show_about: bool,
    log_contents: String,
}

impl UserInterface {
    pub fn new(file_sender: Sender<FileEvent>) -> Self {
        Self {
            file_sender,
            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,
        objects: &mut [ObjectWidget],
    ) {
        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() {
                        ui.close_menu();
                        self.file_sender.send(FileEvent::Save).unwrap();
                    }

                    if ui.button("Save as...").clicked() {
                        ui.close_menu();

                        let file_sender = self.file_sender.to_owned();
                        std::thread::spawn(move || {
                            if let Some(path) = rfd::FileDialog::new().save_file() {
                                file_sender.send(FileEvent::SaveAs(path)).unwrap();
                            }
                        });
                    }

                    ui.menu_button("Import...", |ui| {
                        if ui.button("STL").clicked() {
                            ui.close_menu();

                            let import_kind = ImportKind::Stl;
                            let file_sender = self.file_sender.to_owned();
                            std::thread::spawn(move || {
                                let dialog = rfd::FileDialog::new().add_filter("STL", &["stl"]);
                                if let Some(paths) = dialog.pick_files() {
                                    for path in paths.iter() {
                                        let event = FileEvent::Import(import_kind, path.into());
                                        file_sender.send(event).unwrap();
                                    }
                                }
                            });
                        }
                    });

                    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::SidePanel::left("objects_panel")
            .resizable(true)
            .show(ctx, |ui| {
                for object in objects.iter_mut() {
                    object.ui(ui);
                }
            });

        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,
    pub width: u32,
    pub height: u32,
}

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

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);

        self.width = rect.width().round() as u32;
        self.height = rect.height().round() as u32;

        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() {
            let delta = response.drag_delta();
            self.flycam.process_mouse(delta.x as f64, delta.y as f64);

            for event in ui.input().events.iter() {
                match event {
                    egui::Event::Key { key, pressed, .. } => {
                        use winit::event::{ElementState, VirtualKeyCode};

                        let key = match key {
                            egui::Key::W => Some(VirtualKeyCode::W),
                            egui::Key::A => Some(VirtualKeyCode::A),
                            egui::Key::S => Some(VirtualKeyCode::S),
                            egui::Key::D => Some(VirtualKeyCode::D),
                            // TODO remap from shift key somehow?
                            egui::Key::E => Some(VirtualKeyCode::E),
                            egui::Key::Q => Some(VirtualKeyCode::Q),
                            _ => None,
                        };

                        let state = if *pressed {
                            ElementState::Pressed
                        } else {
                            ElementState::Released
                        };

                        if let Some(key) = key {
                            self.flycam.process_keyboard(key, state);
                        }
                    }
                    _ => {}
                }
            }
        } else if response.drag_released() {
            self.flycam.defocus();
        }

        self.flycam.resize(self.width, self.height);
        self.flycam.update();

        response
    }
}

pub struct ObjectWidget {
    pub name: String,
    pub position: [f32; 3],
    pub rotation: [f32; 3],
    pub scale: f32,
    pub entity: legion::Entity,
    pub dirty: bool,
}

impl ObjectWidget {
    pub fn ui(&mut self, ui: &mut egui::Ui) {
        egui::CollapsingHeader::new(&self.name)
            .default_open(true)
            .show(ui, |ui| {
                self.ui_self(ui);
            });
    }

    pub fn ui_self(&mut self, ui: &mut egui::Ui) {
        egui::Grid::new("root_object")
            .num_columns(4)
            .striped(true)
            .show(ui, |ui| {
                ui.label("Position: ");
                self.ui_position(ui);
                ui.end_row();

                ui.label("Rotation: ");
                self.ui_rotation(ui);
                ui.end_row();

                ui.label("Scale: ");
                self.ui_scale(ui);
                ui.end_row();
            });
    }

    pub fn ui_position(&mut self, ui: &mut egui::Ui) {
        let speed = 0.1 * self.scale;
        for axis in self.position.iter_mut() {
            let drag = egui::DragValue::new(axis).speed(speed);
            if ui.add(drag).changed() {
                self.dirty = true;
            }
        }
    }

    pub fn ui_rotation(&mut self, ui: &mut egui::Ui) {
        for axis in self.rotation.iter_mut() {
            if ui.drag_angle(axis).changed() {
                self.dirty = true;
            }
        }
    }

    pub fn ui_scale(&mut self, ui: &mut egui::Ui) {
        let scale_speed = self.scale * 0.01;
        let drag = egui::DragValue::new(&mut self.scale)
            .clamp_range(0.0..=f32::INFINITY)
            .speed(scale_speed);
        if ui.add(drag).changed() {
            self.dirty = true;
        }
    }

    pub fn flush_dirty(&mut self, mut f: impl FnMut(&mut Self)) {
        if self.dirty {
            f(self);
            self.dirty = false;
        }
    }
}