/*
ENSnano, a 3d graphical application for DNA nanostructures.
    Copyright (C) 2021  Nicolas Levy <nicolaspierrelevy@gmail.com> and Nicolas Schabanel <nicolas.schabanel@ens-lyon.fr>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
//! `ensnano` is a software for designing 3D DNA nanostructures.
//!
//! # Organization of the software
//!
//!
//! The [main](main) function owns the event_loop and the framebuffer. It recieves window events
//! and handles the framebuffer.
//!
//! ## Drawing process
//!
//! On each redraw request, the [main](main) funtion generates a new frame, and ask the
//! [Multiplexer](multiplexer) to draw on a view of that texture.
//!
//! The [Multiplexer](multiplexer) knows how the window is devided into several regions. For each
//! of these region it knows what application or gui component should draw on it.
//! For each region the [Multiplexer](multiplexer) holds a texture, and at each draw request, it
//! will request the corresponding app or gui element to possibly update the texture.
//!
//!  Applications are notified when the design that they display have been modified and may request
//!  from the [Design](design) the data that they need to display it.
//!
//!  ## Handling of events
//!
//!  Window events are recieved by the `main` function that forwards them to the
//!  [Multiplexer](multiplexer). The [Multiplexer](multiplexer) then forwards the event to the last
//!  active region (the region under the cursor). Special events like resizing of the window are
//!  handled by the multiplexer.
//!
//!  When applications and GUI component handle an event. This event might have consequences that
//!  must be known by the other components of the software.
//!
//!  In the case of an application, the
//!  consequences is transmitted to the [Mediator](mediator). The [Mediator](mediator) may then
//!  request appropriate modifications of the [Designs](design) or forward messages for the GUI
//!  components.
//!
//!  In the case of a GUI component, consequences are transmitted to the [main](main) function that
//!  will consequently send the appropriate request to the [Mediator](mediator).
use std::collections::VecDeque;
use std::env;
use std::path::PathBuf;
use std::rc::Rc;
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant};
pub type PhySize = iced_winit::winit::dpi::PhysicalSize<u32>;

use iced_native::Event as IcedEvent;
use iced_wgpu::{wgpu, Backend, Renderer, Settings, Viewport};
use iced_winit::{conversion, futures, program, winit, Debug, Size};

use futures::task::SpawnExt;
use winit::{
    dpi::{PhysicalPosition, PhysicalSize},
    event::{Event, ModifiersState, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
    window::Window,
};

#[macro_use]
extern crate serde_derive;
extern crate serde;

#[cfg(not(test))]
const MUST_TEST: bool = false;

#[cfg(test)]
const MUST_TEST: bool = true;

mod consts;
/// Design handling
mod design;
/// Graphical interface drawing
mod gui;
use design::Design;
/// Message passing between applications
mod mediator;
/// Separation of the window into drawing regions
mod multiplexer;
/// 3D scene drawing
mod scene;
use mediator::{ActionMode, Mediator, Operation, ParameterPtr, Scheduler, SelectionMode};
mod flatscene;
mod text;
mod utils;
// mod grid_panel; We don't use the grid panel atm

use flatscene::FlatScene;
use gui::{ColorOverlay, KeepProceed, OverlayType, Requests};
use multiplexer::{DrawArea, ElementType, Multiplexer, Overlay, SplitMode};
use scene::Scene;

fn convert_size(size: PhySize) -> Size<f32> {
    Size::new(size.width as f32, size.height as f32)
}

fn convert_size_u32(size: PhySize) -> Size<u32> {
    Size::new(size.width, size.height)
}

/// Main function. Runs the event loop and holds the framebuffer.
///
/// # Intialization
///
/// Before running the event loop, the main fuction do the following
///
/// * It request a connection to the GPU and crates a framebuffer
/// * It initializes a multiplexer.
/// * It initializes applications and GUI component, and associate region of the screen to these
/// components
/// * It initialized the [Mediator](mediator), the [Scheduler](mediator::Scheduler) and the [Gui
/// manager](gui::Gui)
///
/// # EventLoop
///
/// * The event loop wait for an event. If no event is recieved during 33ms, a new redraw is
/// requested.
/// * When a event is recieved, it is forwareded to the multiplexer. The Multiplexer may then
/// convert this event into a event for a specific screen region.
/// * When all window event have been handled, the main function reads messages that it recieved
/// from the [Gui Manager](gui::Gui).  The consequence of these messages are forwarded to the
/// applications.
/// * The main loops then reads the messages that it recieved from the [Mediator](mediator) and
/// forwards their consequences to the Gui components.
/// * Finally, a redraw is requested.
///
///
fn main() {
    // parse arugments, if an argument was given it is treated as a file to open
    let args: Vec<String> = env::args().collect();
    let path = if args.len() >= 2 {
        Some(PathBuf::from(&args[1]))
    } else {
        None
    };

    // Initialize winit
    let event_loop = EventLoop::new();
    let window = winit::window::Window::new(&event_loop).unwrap();
    window.set_title("ENSnano");
    window.set_min_inner_size(Some(PhySize::new(100, 100)));

    println!("scale factor {}", window.scale_factor());

    let modifiers = ModifiersState::default();

    let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
    let surface = unsafe { instance.create_surface(&window) };
    // Initialize WGPU
    let (device, queue) = futures::executor::block_on(async {
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::LowPower,
                compatible_surface: Some(&surface),
            })
            .await
            .expect("Could not get adapter\n
                This might be because gpu drivers are missing. \n
                You need Vulkan, Metal (for MacOS) or DirectX (for Windows) drivers to run this software");

        adapter
            .request_device(
                &wgpu::DeviceDescriptor {
                    features: wgpu::Features::empty(),
                    limits: wgpu::Limits::default(),
                    label: None,
                },
                None,
            )
            .await
            .expect("Request device")
    });

    let format = wgpu::TextureFormat::Bgra8UnormSrgb;

    let mut swap_chain = {
        let size = window.inner_size();

        device.create_swap_chain(
            &surface,
            &wgpu::SwapChainDescriptor {
                usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
                format,
                width: size.width,
                height: size.height,
                present_mode: wgpu::PresentMode::Mailbox,
            },
        )
    };
    let settings = Settings {
        antialiasing: Some(iced_graphics::Antialiasing::MSAAx4),
        default_text_size: gui::UiSize::Medium.main_text(),
        default_font: Some(include_bytes!("../font/ensnano2.ttf")),
        ..Default::default()
    };
    let mut renderer = Renderer::new(Backend::new(&device, settings.clone()));
    let device = Rc::new(device);
    let queue = Rc::new(queue);
    let mut resized = false;
    let mut scale_factor_changed = false;
    let mut staging_belt = wgpu::util::StagingBelt::new(5 * 1024);
    let mut local_pool = futures::executor::LocalPool::new();

    // Initialize the mediator
    let requests = Arc::new(Mutex::new(Requests::new()));
    let messages = Arc::new(Mutex::new(IcedMessages::new()));
    let computing = Arc::new(Mutex::new(false));
    let mediator = Arc::new(Mutex::new(Mediator::new(
        messages.clone(),
        computing.clone(),
    )));
    let scheduler = Arc::new(Mutex::new(Scheduler::new()));

    // Initialize the layout
    let mut multiplexer = Multiplexer::new(
        window.inner_size(),
        window.scale_factor(),
        device.clone(),
        requests.clone(),
    );
    multiplexer.change_split(SplitMode::Both);

    // Initialize the scenes
    let mut encoder =
        device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
    let scene_area = multiplexer.get_element_area(ElementType::Scene).unwrap();
    let scene = Arc::new(Mutex::new(Scene::new(
        device.clone(),
        queue.clone(),
        window.inner_size(),
        scene_area,
        mediator.clone(),
        &mut encoder,
    )));
    queue.submit(Some(encoder.finish()));
    mediator
        .lock()
        .unwrap()
        .add_application(scene.clone(), ElementType::Scene);
    scheduler
        .lock()
        .unwrap()
        .add_application(scene.clone(), ElementType::Scene);

    let flat_scene = Arc::new(Mutex::new(FlatScene::new(
        device.clone(),
        queue.clone(),
        window.inner_size(),
        scene_area,
        mediator.clone(),
    )));
    mediator
        .lock()
        .unwrap()
        .add_application(flat_scene.clone(), ElementType::FlatScene);
    scheduler
        .lock()
        .unwrap()
        .add_application(flat_scene.clone(), ElementType::FlatScene);

    // Add a design to the scene if one was given as a command line arguement
    if let Some(ref path) = path {
        let design = Design::new_with_path(0, path).unwrap_or_else(|| Design::new(0));
        if let Some(tree) = design.get_organizer_tree() {
            messages.lock().unwrap().push_new_tree(tree)
        }
        mediator
            .lock()
            .unwrap()
            .add_design(Arc::new(RwLock::new(design)));
    } else {
        let design = Design::new(0);
        mediator
            .lock()
            .unwrap()
            .add_design(Arc::new(RwLock::new(design)));
    }

    // Initialize the UI

    let mut gui = gui::Gui::new(
        device.clone(),
        &window,
        &multiplexer,
        requests.clone(),
        settings,
    );

    let mut overlay_manager = OverlayManager::new(requests.clone(), &window, &mut renderer);

    // Run event loop
    let mut last_render_time = std::time::Instant::now();
    let mut mouse_interaction = iced::mouse::Interaction::Pointer;
    let mut icon = None;

    event_loop.run(move |event, _, control_flow| {
        // Wait for event or redraw a frame every 33 ms (30 frame per seconds)
        *control_flow = ControlFlow::WaitUntil(Instant::now() + Duration::from_millis(33));
        //*control_flow = ControlFlow::Wait;

        match event {
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                ..
            } => save_before_quit(requests.clone()),
            Event::WindowEvent {
                event: WindowEvent::ModifiersChanged(modifiers),
                ..
            } => {
                multiplexer.update_modifiers(modifiers.clone());
                mediator.lock().unwrap().update_modifiers(modifiers.clone());
                messages.lock().unwrap().update_modifiers(modifiers.clone());
            }
            Event::WindowEvent {
                event: WindowEvent::KeyboardInput { .. },
                ..
            }
            | Event::WindowEvent {
                event: WindowEvent::ReceivedCharacter(_),
                ..
            } if gui.has_keyboard_priority() => {
                if let Event::WindowEvent { event, .. } = event {
                    if let Some(event) = event.to_static() {
                        let event = iced_winit::conversion::window_event(
                            &event,
                            window.scale_factor(),
                            modifiers,
                        );
                        if let Some(event) = event {
                            gui.forward_event_all(event);
                        }
                    }
                }
            }
            Event::WindowEvent { event, .. } => {
                //let modifiers = multiplexer.modifiers();
                if let Some(event) = event.to_static() {
                    // Feed the event to the multiplexer
                    let (event, icon_opt) =
                        multiplexer.event(event, &mut resized, &mut scale_factor_changed);
                    icon = icon.or(icon_opt);

                    if let Some((event, area)) = event {
                        // pass the event to the area on which it happenened
                        match area {
                            area if area.is_gui() => {
                                let event = iced_winit::conversion::window_event(
                                    &event,
                                    window.scale_factor(),
                                    modifiers,
                                );
                                if let Some(event) = event {
                                    gui.forward_event(area, event);
                                }
                            }
                            ElementType::Overlay(n) => {
                                let event = iced_winit::conversion::window_event(
                                    &event,
                                    window.scale_factor(),
                                    modifiers,
                                );
                                if let Some(event) = event {
                                    overlay_manager.forward_event(event, n);
                                }
                            }
                            area if area.is_scene() => {
                                let cursor_position = multiplexer.get_cursor_position();
                                scheduler.lock().unwrap().forward_event(
                                    &event,
                                    area,
                                    cursor_position,
                                )
                            }
                            _ => unreachable!(),
                        }
                    }
                }
            }
            Event::MainEventsCleared => {
                scale_factor_changed |= multiplexer.check_scale_factor(&window);
                let mut redraw = resized | scale_factor_changed | icon.is_some();
                redraw |= gui.fetch_change(&window, &multiplexer);

                // getting the file into which downloading the stapples must be done separatly
                // because the requests lock must first be dropped.
                let mut download_stapples = None;
                let mut set_scaffold = None;
                let mut stapples = None;
                let mut blocking_info = None;

                // When there is no more event to deal with
                if let Ok(mut requests) = requests.try_lock() {
                    if requests.fitting {
                        mediator.lock().unwrap().request_fits();
                        requests.fitting = false;
                    }

                    if let Some(ref path) = requests.file_add.take() {
                        let design = Design::new_with_path(0, path);
                        let path_end = formated_path_end(path);
                        if let Some(design) = design {
                            window.set_title(&format!("ENSnano: {}", path_end));
                            messages.lock().unwrap().notify_new_design();
                            if let Some(tree) = design.get_organizer_tree() {
                                messages.lock().unwrap().push_new_tree(tree)
                            }
                            mediator.lock().unwrap().clear_designs();
                            let design = Arc::new(RwLock::new(design));
                            mediator.lock().unwrap().add_design(design);
                        }
                    }

                    if requests.file_clear {
                        mediator.lock().unwrap().clear_designs();
                        requests.file_clear = false;
                    }

                    if let Some((path, keep_proceed)) = requests.file_save.take() {
                        let path_end = formated_path_end(&path);
                        window.set_title(&format!("ENSnano: {}", path_end));
                        mediator.lock().unwrap().save_design(&path);
                        requests.keep_proceed = keep_proceed;
                    }

                    if let Some(value) = requests.toggle_text {
                        mediator.lock().unwrap().toggle_text(value);
                        requests.toggle_text = None;
                    }

                    if let Some(value) = requests.toggle_scene {
                        multiplexer.change_split(value);
                        scheduler
                            .lock()
                            .unwrap()
                            .forward_new_size(window.inner_size(), &multiplexer);
                        gui.resize(&multiplexer, &window);
                        requests.toggle_scene = None;
                    }

                    if requests.make_grids {
                        mediator.lock().unwrap().make_grids();
                        requests.make_grids = false
                    }

                    if let Some(grid_type) = requests.new_grid.take() {
                        scene.lock().unwrap().make_new_grid(grid_type);
                    }

                    if let Some(selection_mode) = requests.selection_mode {
                        mediator
                            .lock()
                            .unwrap()
                            .change_selection_mode(selection_mode);
                        requests.selection_mode = None;
                    }

                    if let Some(action_mode) = requests.action_mode.take() {
                        println!("action mode {:?}", action_mode);
                        mediator.lock().unwrap().change_action_mode(action_mode);
                    }

                    if let Some(sequence) = requests.sequence_change.take() {
                        mediator.lock().unwrap().change_sequence(sequence);
                    }
                    if let Some(color) = requests.strand_color_change {
                        mediator.lock().unwrap().change_strand_color(color);
                        requests.strand_color_change = None;
                    }
                    if let Some(sensitivity) = requests.scroll_sensitivity.take() {
                        mediator.lock().unwrap().change_sensitivity(sensitivity);
                        //flat_scene.lock().unwrap().change_sensitivity(sensitivity);
                    }

                    if let Some(overlay_type) = requests.overlay_closed.take() {
                        overlay_manager.rm_overlay(overlay_type, &mut multiplexer);
                    }

                    if let Some(overlay_type) = requests.overlay_opened.take() {
                        overlay_manager.add_overlay(overlay_type, &mut multiplexer);
                    }

                    if let Some(op) = requests.operation_update.take() {
                        mediator.lock().unwrap().update_pending(op)
                    }

                    if let Some(b) = requests.toggle_persistent_helices.take() {
                        mediator.lock().unwrap().set_persistent_phantom(b)
                    }

                    if let Some(b) = requests.small_spheres.take() {
                        println!("requested small spheres");
                        mediator.lock().unwrap().set_small_spheres(b)
                    }

                    if let Some(point) = requests.camera_target.take() {
                        mediator.lock().unwrap().set_camera_target(point)
                    }

                    if let Some(rotation) = requests.camera_rotation.take() {
                        mediator.lock().unwrap().request_camera_rotation(rotation)
                    }

                    if let Some(scaffold_id) = requests.set_scaffold_id.take() {
                        mediator.lock().unwrap().set_scaffold(scaffold_id)
                    }

                    if let Some((sequence, shift)) = requests.scaffold_sequence.take() {
                        set_scaffold = Some((sequence, shift));
                    }

                    if requests.stapples_request {
                        requests.stapples_request = false;
                        stapples = Some(());
                    }

                    if requests.recolor_stapples {
                        requests.recolor_stapples = false;
                        mediator.lock().unwrap().recolor_stapples();
                    }

                    if requests.clean_requests {
                        requests.clean_requests = false;
                        mediator.lock().unwrap().clean_designs();
                    }

                    if let Some(roll_request) = requests.roll_request.take() {
                        mediator.lock().unwrap().roll_request(roll_request);
                    }

                    if let Some(b) = requests.show_torsion_request.take() {
                        mediator.lock().unwrap().show_torsion_request(b)
                    }

                    if let Some(fog) = requests.fog.take() {
                        scene.lock().unwrap().fog_request(fog)
                    }

                    if let Some(hyperboloid) = requests.new_hyperboloid.take() {
                        use crate::design::Hyperboloid;
                        let h = Hyperboloid {
                            radius: hyperboloid.radius,
                            length: hyperboloid.length,
                            shift: hyperboloid.shift,
                            radius_shift: hyperboloid.radius_shift,
                            forced_radius: None,
                        };
                        scene.lock().unwrap().make_hyperboloid(h)
                    }

                    if let Some(hyperboloid) = requests.hyperboloid_update.take() {
                        mediator.lock().unwrap().hyperboloid_update(hyperboloid)
                    }

                    if requests.finalize_hyperboloid {
                        requests.finalize_hyperboloid = false;
                        mediator.lock().unwrap().finalize_hyperboloid();
                    }

                    if requests.cancel_hyperboloid {
                        requests.cancel_hyperboloid = false;
                        mediator.lock().unwrap().cancel_hyperboloid();
                    }

                    if let Some(roll) = requests.helix_roll.take() {
                        mediator.lock().unwrap().roll_helix(roll)
                    }

                    if requests.copy {
                        mediator.lock().unwrap().request_copy();
                        requests.copy = false;
                    }

                    if requests.paste {
                        mediator.lock().unwrap().request_pasting_mode();
                        requests.paste = false;
                        requests.duplication = false;
                    } else if requests.duplication {
                        mediator.lock().unwrap().request_duplication();
                        requests.duplication = false;
                    }

                    if let Some(b) = requests.rigid_grid_simulation.take() {
                        mediator.lock().unwrap().rigid_grid_request(b);
                    }

                    if let Some(b) = requests.rigid_helices_simulation.take() {
                        mediator.lock().unwrap().rigid_helices_request(b);
                    }

                    if let Some(p) = requests.rigid_body_parameters.take() {
                        mediator.lock().unwrap().rigid_parameters_request(p);
                    }

                    if requests.anchor {
                        mediator.lock().unwrap().request_anchor();
                        requests.anchor = false;
                    }
                    if let Some(proceed) = requests.keep_proceed.take() {
                        match proceed {
                            KeepProceed::CustomScaffold => {
                                messages.lock().unwrap().push_custom_scaffold()
                            }
                            KeepProceed::DefaultScaffold => {
                                messages.lock().unwrap().push_default_scaffold()
                            }
                            KeepProceed::OptimizeShift(d_id) => {
                                mediator.lock().unwrap().optimize_shift(d_id);
                            }
                            KeepProceed::Stapples(d_id) => {
                                download_stapples = Some(d_id);
                            }
                            KeepProceed::Quit => {
                                *control_flow = ControlFlow::Exit;
                            }
                            KeepProceed::SaveBeforeOpen => {
                                messages
                                    .lock()
                                    .unwrap()
                                    .push_save(Some(KeepProceed::LoadDesignAfterSave));
                            }
                            KeepProceed::SaveBeforeNew => {
                                messages
                                    .lock()
                                    .unwrap()
                                    .push_save(Some(KeepProceed::NewDesignAfterSave));
                            }
                            KeepProceed::SaveBeforeQuit => {
                                messages.lock().unwrap().push_save(Some(KeepProceed::Quit));
                            }
                            KeepProceed::LoadDesign => {
                                messages.lock().unwrap().push_open();
                            }
                            KeepProceed::LoadDesignAfterSave => {
                                blocking_info =
                                    Some(("Save successfully", KeepProceed::LoadDesign));
                            }
                            KeepProceed::NewDesign => {
                                let design = Design::new(0);
                                messages.lock().unwrap().notify_new_design();
                                mediator.lock().unwrap().clear_designs();
                                mediator
                                    .lock()
                                    .unwrap()
                                    .add_design(Arc::new(RwLock::new(design)));
                            }
                            KeepProceed::NewDesignAfterSave => {
                                blocking_info = Some(("Save successfully", KeepProceed::NewDesign));
                            }
                            _ => (),
                        }
                    }
                    if let Some((d_id, path)) = requests.stapples_file.take() {
                        mediator.lock().unwrap().proceed_stapples(d_id, path);
                    }

                    if let Some(content) = requests.sequence_input.take() {
                        messages.lock().unwrap().push_sequence(content);
                    }

                    if let Some(f) = requests.new_shift_hyperboloid.take() {
                        mediator.lock().unwrap().new_shift_hyperboloid(f);
                    }

                    if let Some(s) = requests.organizer_selection.take() {
                        mediator.lock().unwrap().organizer_selection(s);
                    }

                    if let Some(c) = requests.organizer_candidates.take() {
                        mediator.lock().unwrap().organizer_candidates(c);
                    }

                    if let Some((a, elts)) = requests.new_attribute.take() {
                        mediator.lock().unwrap().update_attribute(a, elts);
                    }

                    if let Some(tree) = requests.new_tree.take() {
                        mediator.lock().unwrap().update_tree(tree);
                    }

                    if let Some(ui_size) = requests.new_ui_size.take() {
                        gui.new_ui_size(ui_size.clone(), &window, &multiplexer);
                        multiplexer.change_ui_size(ui_size.clone(), &window);
                        messages.lock().unwrap().new_ui_size(ui_size);
                        resized = true;
                    }

                    if requests.oxdna {
                        mediator.lock().unwrap().oxdna_export();
                        requests.oxdna = false;
                    }

                    if requests.split2d {
                        mediator.lock().unwrap().split_2d();
                        requests.split2d = false;
                    }

                    if requests.all_visible {
                        mediator.lock().unwrap().make_everything_visible();
                        requests.all_visible = false;
                    }

                    if let Some(b) = requests.toggle_visibility.take() {
                        mediator.lock().unwrap().toggle_visibility(b);
                    }

                    if let Some(b) = requests.redim_2d_helices.take() {
                        mediator.lock().unwrap().redim_2d_helices(b);
                    }

                    if let Some(b) = requests.invert_scroll.take() {
                        multiplexer.invert_y_scroll = b;
                    }

                    if requests.stop_roll {
                        mediator.lock().unwrap().stop_roll();
                        requests.stop_roll = false;
                    }

                    if requests.toggle_widget {
                        requests.toggle_widget = false;
                        mediator.lock().unwrap().toggle_widget();
                    }

                    if requests.delete_selection {
                        requests.delete_selection = false;
                        mediator.lock().unwrap().delete_selection();
                    }

                    if requests.select_scaffold.take().is_some() {
                        mediator.lock().unwrap().select_scaffold();
                    }

                    if let Some(n) = requests.scaffold_shift.take() {
                        mediator.lock().unwrap().set_scaffold_shift(n);
                    }

                    if let Some(mode) = requests.rendering_mode.take() {
                        mediator.lock().unwrap().rendering_mode(mode);
                    }

                    if let Some(bg) = requests.background3d.take() {
                        mediator.lock().unwrap().background3d(bg);
                    }

                    if requests.undo.take().is_some() {
                        mediator.lock().unwrap().undo()
                    }

                    if requests.redo.take().is_some() {
                        mediator.lock().unwrap().redo()
                    }

                    if requests.save_shortcut.take().is_some() {
                        messages.lock().unwrap().push_save(None);
                    }

                    if requests.show_tutorial.take().is_some() {
                        messages.lock().unwrap().push_show_tutorial()
                    }

                    if requests.force_help.take().is_some() {
                        messages.lock().unwrap().show_help()
                    }
                }

                if let Some((msg, keep_proceed)) = blocking_info.take() {
                    crate::utils::blocking_message(
                        msg.into(),
                        rfd::MessageLevel::Info,
                        requests.clone(),
                        keep_proceed,
                    )
                }

                if let Some(d_id) = download_stapples {
                    let requests = requests.clone();
                    let dialog = rfd::AsyncFileDialog::new().save_file();
                    std::thread::spawn(move || {
                        let save_op = async move {
                            let file = dialog.await;
                            if let Some(handle) = file {
                                let mut path_buf: std::path::PathBuf = handle.path().clone().into();
                                path_buf.set_extension("xlsx");
                                requests.lock().unwrap().stapples_file = Some((d_id, path_buf));
                            }
                        };
                        futures::executor::block_on(save_op);
                    });
                }

                if let Some((sequence, shift)) = set_scaffold.take() {
                    mediator.lock().unwrap().set_scaffold_sequence(
                        sequence,
                        requests.clone(),
                        shift,
                    );
                }

                if stapples.take().is_some() {
                    mediator.lock().unwrap().download_stapples(requests.clone())
                }

                // Treat eventual event that happenend in the gui left panel.
                let _overlay_change =
                    overlay_manager.fetch_change(&multiplexer, &window, &mut renderer);
                {
                    let mut messages = messages.lock().unwrap();
                    gui.forward_messages(&mut messages);
                    overlay_manager.forward_messages(&mut messages);
                }

                mediator.lock().unwrap().observe_designs();
                let now = std::time::Instant::now();
                let dt = now - last_render_time;
                redraw |= scheduler.lock().unwrap().check_redraw(&multiplexer, dt);
                last_render_time = now;

                if redraw {
                    window.request_redraw();
                }
            }
            Event::RedrawRequested(_)
                if window.inner_size().width > 0 && window.inner_size().height > 0 =>
            {
                if resized {
                    multiplexer.generate_textures();
                    scheduler
                        .lock()
                        .unwrap()
                        .forward_new_size(window.inner_size(), &multiplexer);
                    let window_size = window.inner_size();

                    swap_chain = device.create_swap_chain(
                        &surface,
                        &wgpu::SwapChainDescriptor {
                            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
                            format,
                            width: window_size.width,
                            height: window_size.height,
                            present_mode: wgpu::PresentMode::Mailbox,
                        },
                    );

                    gui.resize(&multiplexer, &window);
                }
                if scale_factor_changed {
                    multiplexer.generate_textures();
                    gui.notify_scale_factor_change(&window, &multiplexer);
                    println!("lolz");
                    scheduler
                        .lock()
                        .unwrap()
                        .forward_new_size(window.inner_size(), &multiplexer);
                    let window_size = window.inner_size();

                    swap_chain = device.create_swap_chain(
                        &surface,
                        &wgpu::SwapChainDescriptor {
                            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
                            format,
                            width: window_size.width,
                            height: window_size.height,
                            present_mode: wgpu::PresentMode::Mailbox,
                        },
                    );

                    gui.resize(&multiplexer, &window);
                }
                // Get viewports from the partition

                // If there are events pending
                gui.update(&multiplexer, &window);

                overlay_manager.process_event(&mut renderer, resized, &multiplexer, &window);

                resized = false;
                scale_factor_changed = false;

                if let Ok(frame) = swap_chain.get_current_frame() {
                    let mut encoder = device
                        .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });

                    // We draw the applications first
                    let now = std::time::Instant::now();
                    let dt = now - last_render_time;
                    scheduler
                        .lock()
                        .unwrap()
                        .draw_apps(&mut encoder, &multiplexer, dt);

                    gui.render(
                        &mut encoder,
                        &window,
                        &multiplexer,
                        &mut staging_belt,
                        &mut mouse_interaction,
                    );

                    multiplexer.draw(&mut encoder, &frame.output.view);
                    //overlay_manager.render(&device, &mut staging_belt, &mut encoder, &frame.output.view, &multiplexer, &window, &mut renderer);

                    // Then we submit the work
                    staging_belt.finish();
                    queue.submit(Some(encoder.finish()));

                    // And update the mouse cursor
                    window.set_cursor_icon(iced_winit::conversion::mouse_interaction(
                        mouse_interaction,
                    ));
                    if let Some(icon) = icon.take() {
                        window.set_cursor_icon(icon);
                    }
                    local_pool
                        .spawner()
                        .spawn(staging_belt.recall())
                        .expect("Recall staging buffers");

                    local_pool.run_until_stalled();
                } else {
                    println!("Error getting next frame, attempt to recreate swap chain");
                    resized = true;
                }
            }
            _ => {}
        }
    })
}

/// Message sent to the gui component
pub struct IcedMessages {
    left_panel: VecDeque<gui::left_panel::Message>,
    top_bar: VecDeque<gui::top_bar::Message>,
    color_overlay: VecDeque<gui::left_panel::ColorMessage>,
    status_bar: VecDeque<gui::status_bar::Message>,
    application_state: ApplicationState,
}

#[derive(Default, PartialEq, Eq, Debug, Clone)]
pub struct ApplicationState {
    pub can_undo: bool,
    pub can_redo: bool,
    pub simulation_state: crate::design::SimulationState,
    pub parameter_ptr: ParameterPtr,
    pub axis_aligned: bool,
    pub action_mode: ActionMode,
    pub selection_mode: SelectionMode,
}

impl IcedMessages {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
        Self {
            left_panel: VecDeque::new(),
            top_bar: VecDeque::new(),
            color_overlay: VecDeque::new(),
            status_bar: VecDeque::new(),
            application_state: Default::default(),
        }
    }

    pub fn push_scaffold_info(&mut self, info: Option<crate::design::ScaffoldInfo>) {
        self.left_panel
            .push_back(gui::left_panel::Message::NewScaffoldInfo(info));
    }

    pub fn push_custom_scaffold(&mut self) {
        self.left_panel
            .push_back(gui::left_panel::Message::CustomScaffoldRequested);
    }

    pub fn push_default_scaffold(&mut self) {
        self.left_panel
            .push_back(gui::left_panel::Message::DeffaultScaffoldRequested);
    }

    pub fn push_color(&mut self, color: u32) {
        let bytes = color.to_be_bytes();
        // bytes is [A, R, G, B]
        let color = iced::Color::from_rgb8(bytes[1], bytes[2], bytes[3]);
        self.color_overlay
            .push_back(gui::left_panel::ColorMessage::StrandColorChanged(color));
        self.left_panel
            .push_back(gui::left_panel::Message::StrandColorChanged(color));
    }

    pub fn push_sequence(&mut self, sequence: String) {
        self.left_panel
            .push_back(gui::left_panel::Message::SequenceChanged(sequence));
    }

    pub fn push_op(&mut self, operation: Arc<dyn Operation>) {
        self.status_bar
            .push_back(gui::status_bar::Message::Operation(operation));
    }

    pub fn push_selection(&mut self, selection: mediator::Selection, values: Vec<String>) {
        self.left_panel
            .push_back(gui::left_panel::Message::Selection(
                selection,
                values.clone(),
            ))
    }

    pub fn push_candidate(&mut self, selection: mediator::Selection, values: Vec<String>) {
        self.status_bar
            .push_back(gui::status_bar::Message::Selection(
                selection,
                values.clone(),
            ));
    }

    pub fn push_organizer_selection(&mut self, selection: Vec<crate::design::DnaElementKey>) {
        self.left_panel
            .push_back(gui::left_panel::Message::NewSelection(selection))
    }

    pub fn clear_op(&mut self) {
        self.status_bar.push_back(gui::status_bar::Message::ClearOp);
    }

    pub fn push_action_mode(&mut self, action_mode: mediator::ActionMode) {
        self.left_panel
            .push_back(gui::left_panel::Message::ActionModeChanged(action_mode))
    }

    pub fn push_selection_mode(&mut self, selection_mode: mediator::SelectionMode) {
        self.left_panel
            .push_back(gui::left_panel::Message::SelectionModeChanged(
                selection_mode,
            ))
    }

    pub fn push_progress(&mut self, progress_name: String, progress: f32) {
        self.status_bar
            .push_back(gui::status_bar::Message::Progress(Some((
                progress_name,
                progress,
            ))))
    }

    pub fn finish_progess(&mut self) {
        self.status_bar
            .push_back(gui::status_bar::Message::Progress(None))
    }

    pub fn notify_new_design(&mut self) {
        self.left_panel
            .push_back(gui::left_panel::Message::NewDesign)
    }

    pub fn push_roll(&mut self, roll: f32) {
        self.left_panel
            .push_back(gui::left_panel::Message::HelixRoll(roll))
    }

    pub fn push_dna_elements(&mut self, elements: Vec<crate::design::DnaElement>) {
        self.left_panel
            .push_back(gui::left_panel::Message::NewDnaElement(elements))
    }

    pub fn update_modifiers(&mut self, modifiers: ModifiersState) {
        self.left_panel
            .push_back(gui::left_panel::Message::ModifiersChanged(modifiers))
    }

    pub fn push_new_tree(
        &mut self,
        tree: ensnano_organizer::OrganizerTree<crate::design::DnaElementKey>,
    ) {
        self.left_panel
            .push_back(gui::left_panel::Message::NewTreeApp(tree))
    }

    pub fn new_ui_size(&mut self, ui_size: gui::UiSize) {
        self.left_panel
            .push_back(gui::left_panel::Message::UiSizeChanged(ui_size.clone()));
        self.top_bar
            .push_back(gui::top_bar::Message::UiSizeChanged(ui_size.clone()));
    }

    pub fn push_can_make_grid(&mut self, can_make_grid: bool) {
        self.left_panel
            .push_back(gui::left_panel::Message::CanMakeGrid(can_make_grid));
    }

    pub fn push_save(&mut self, keep_proceed: Option<KeepProceed>) {
        self.top_bar
            .push_back(gui::top_bar::Message::FileSaveRequested(keep_proceed));
    }

    pub fn push_open(&mut self) {
        self.top_bar
            .push_back(gui::top_bar::Message::FileAddRequested);
    }

    pub fn push_show_tutorial(&mut self) {
        self.left_panel
            .push_back(gui::left_panel::Message::ShowTutorial);
    }

    pub fn show_help(&mut self) {
        self.left_panel
            .push_back(gui::left_panel::Message::ForceHelp);
    }

    pub(crate) fn push_application_state(&mut self, state: ApplicationState) {
        let must_update = self.application_state != state;
        self.application_state = state.clone();
        if must_update {
            self.left_panel
                .push_back(gui::left_panel::Message::NewApplicationState(state.clone()));
            self.top_bar
                .push_back(gui::top_bar::Message::NewApplicationState(state))
        }
    }
}

pub struct OverlayManager {
    color_state: iced_native::program::State<ColorOverlay>,
    color_debug: Debug,
    overlay_types: Vec<OverlayType>,
    overlays: Vec<Overlay>,
}

impl OverlayManager {
    pub fn new(requests: Arc<Mutex<Requests>>, window: &Window, renderer: &mut Renderer) -> Self {
        let color = ColorOverlay::new(
            requests.clone(),
            PhysicalSize::new(250., 250.).to_logical(window.scale_factor()),
        );
        let mut color_debug = Debug::new();
        let color_state = program::State::new(
            color,
            convert_size(PhysicalSize::new(250, 250)),
            conversion::cursor_position(PhysicalPosition::new(-1f64, -1f64), window.scale_factor()),
            renderer,
            &mut color_debug,
        );
        Self {
            color_state,
            color_debug,
            overlay_types: Vec::new(),
            overlays: Vec::new(),
        }
    }

    fn forward_event(&mut self, event: IcedEvent, n: usize) {
        match self.overlay_types.get(n) {
            None => {
                println!("recieve event from non existing overlay");
                unreachable!();
            }
            Some(OverlayType::Color) => self.color_state.queue_event(event),
        }
    }

    fn add_overlay(&mut self, overlay_type: OverlayType, multiplexer: &mut Multiplexer) {
        match overlay_type {
            OverlayType::Color => self.overlays.push(Overlay {
                position: PhysicalPosition::new(500, 500),
                size: PhysicalSize::new(250, 250),
            }),
        }
        self.overlay_types.push(overlay_type);
        self.update_multiplexer(multiplexer);
    }

    fn process_event(
        &mut self,
        renderer: &mut Renderer,
        resized: bool,
        multiplexer: &Multiplexer,
        window: &Window,
    ) {
        for (n, overlay) in self.overlay_types.iter().enumerate() {
            let cursor_position = if multiplexer.foccused_element() == Some(ElementType::Overlay(n))
            {
                multiplexer.get_cursor_position()
            } else {
                PhysicalPosition::new(-1., -1.)
            };
            let mut clipboard = iced_native::clipboard::Null;
            match overlay {
                OverlayType::Color => {
                    if !self.color_state.is_queue_empty() || resized {
                        let _ = self.color_state.update(
                            convert_size(PhysicalSize::new(250, 250)),
                            conversion::cursor_position(cursor_position, window.scale_factor()),
                            renderer,
                            &mut clipboard,
                            &mut self.color_debug,
                        );
                    }
                }
            }
        }
    }

    #[allow(dead_code)]
    fn render(
        &self,
        device: &wgpu::Device,
        staging_belt: &mut wgpu::util::StagingBelt,
        encoder: &mut wgpu::CommandEncoder,
        target: &wgpu::TextureView,
        multiplexer: &Multiplexer,
        window: &Window,
        renderer: &mut Renderer,
    ) {
        for overlay_type in self.overlay_types.iter() {
            match overlay_type {
                OverlayType::Color => {
                    let color_viewport = Viewport::with_physical_size(
                        convert_size_u32(multiplexer.window_size),
                        window.scale_factor(),
                    );
                    let _color_interaction = renderer.backend_mut().draw(
                        &device,
                        staging_belt,
                        encoder,
                        &target,
                        &color_viewport,
                        self.color_state.primitive(),
                        &self.color_debug.overlay(),
                    );
                }
            }
        }
    }

    fn rm_overlay(&mut self, overlay_type: OverlayType, multiplexer: &mut Multiplexer) {
        let mut rm_idx = Vec::new();
        for (idx, overlay_type_) in self.overlay_types.iter().rev().enumerate() {
            if *overlay_type_ == overlay_type {
                rm_idx.push(idx);
            }
        }
        for idx in rm_idx.iter() {
            self.overlays.remove(*idx);
            self.overlay_types.remove(*idx);
        }
        self.update_multiplexer(multiplexer);
    }

    fn update_multiplexer(&self, multiplexer: &mut Multiplexer) {
        multiplexer.set_overlays(self.overlays.clone())
    }

    fn forward_messages(&mut self, messages: &mut IcedMessages) {
        for m in messages.color_overlay.drain(..) {
            self.color_state.queue_message(m);
        }
    }

    fn fetch_change(
        &mut self,
        multiplexer: &Multiplexer,
        window: &Window,
        renderer: &mut Renderer,
    ) -> bool {
        let mut ret = false;
        for (n, overlay) in self.overlay_types.iter().enumerate() {
            let cursor_position = if multiplexer.foccused_element() == Some(ElementType::Overlay(n))
            {
                multiplexer.get_cursor_position()
            } else {
                PhysicalPosition::new(-1., -1.)
            };
            let mut clipboard = iced_native::clipboard::Null;
            match overlay {
                OverlayType::Color => {
                    if !self.color_state.is_queue_empty() {
                        ret = true;
                        let _ = self.color_state.update(
                            convert_size(PhysicalSize::new(250, 250)),
                            conversion::cursor_position(cursor_position, window.scale_factor()),
                            renderer,
                            &mut clipboard,
                            &mut self.color_debug,
                        );
                    }
                }
            }
        }
        ret
    }
}

fn formated_path_end(path: &PathBuf) -> String {
    let components: Vec<_> = path.components().map(|comp| comp.as_os_str()).collect();
    let mut ret = if components.len() > 3 {
        vec!["..."]
    } else {
        vec![]
    };
    let mut iter = components.iter().rev().take(3).rev();
    for _ in 0..3 {
        if let Some(comp) = iter.next().and_then(|s| s.to_str()) {
            ret.push(comp.clone());
        }
    }
    ret.join("/")
}

fn save_before_new(requests: Arc<Mutex<Requests>>) {
    crate::utils::yes_no_dialog(
        "Do you want to save your design before loading an empty one?".into(),
        requests,
        KeepProceed::SaveBeforeNew,
        Some(KeepProceed::NewDesign),
    );
}

fn save_before_open(requests: Arc<Mutex<Requests>>) {
    crate::utils::yes_no_dialog(
        "Do you want to save your design before loading a new one?".into(),
        requests,
        KeepProceed::SaveBeforeOpen,
        Some(KeepProceed::LoadDesign),
    );
}

fn save_before_quit(requests: Arc<Mutex<Requests>>) {
    crate::utils::yes_no_dialog(
        "Do you want to save your design before exiting the app?".into(),
        requests,
        KeepProceed::SaveBeforeQuit,
        Some(KeepProceed::Quit),
    );
}