use iced::Task;

use super::{Editor, Message};
use crate::engine::EngineCommand;

impl Editor {
    pub(crate) fn handle_modules(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::AddModuleToTrack(track_idx, module_type) => {
                self.routing.handle_add_module(track_idx, module_type, &self.tracks, self.engine.as_ref());
            }
            Message::RemoveModuleFromTrack(track_idx, module_id) => {
                let module_gui = &mut self.module_gui;
                if self.routing.handle_remove_module(
                    track_idx, module_id, &mut self.tracks, self.engine.as_ref(),
                    &mut self.module_params,
                    &mut |mid| module_gui.handle_module_removed(mid),
                ) {
                    self.mark_dirty();
                }
            }
            Message::ToggleModuleDisabled(track_idx, module_id) => {
                if self.routing.handle_toggle_disabled(track_idx, module_id, &self.tracks, self.engine.as_ref()) {
                    self.mark_dirty();
                }
            }
            Message::MoveModuleUp(track_idx, module_id) => {
                if self.routing.handle_move_module_up(track_idx, module_id, &mut self.tracks, self.engine.as_ref()) {
                    self.mark_dirty();
                }
            }
            Message::MoveModuleDown(track_idx, module_id) => {
                if self.routing.handle_move_module_down(track_idx, module_id, &mut self.tracks, self.engine.as_ref()) {
                    self.mark_dirty();
                }
            }
            Message::ShowModulePicker(track_idx) => {
                self.routing.module_picker_track = Some(track_idx);
            }
            Message::HideModulePicker => {
                self.routing.module_picker_track = None;
            }
            Message::LoadPluginOnTrack(track_idx, plugin_path) => {
                self.routing.handle_load_plugin(track_idx, plugin_path, &self.tracks, self.engine.as_ref());
            }
            Message::SetAnalysisFftSize(size) => {
                self.analysis_fft_size = size;
                if let Some(ref engine) = self.engine {
                    engine.send(EngineCommand::SetHilbertFftSize { size });
                }
            }
            Message::SetHilbertFftSize(size) => {
                self.analysis_fft_size = size;
                if let Some(ref engine) = self.engine {
                    engine.send(EngineCommand::SetHilbertFftSize { size });
                }
            }
            Message::SetVisualizerBufferSize(_size) => {
            }
            Message::ExpandModule(module_id) => {
                if self.module_params.expanded == Some(module_id) {
                    self.module_params.expanded = None;
                } else {
                    self.module_params.expanded = Some(module_id);
                    if !self.module_params.descriptors.contains_key(&module_id) {
                        if let Some(ref engine) = self.engine {
                            engine.send(EngineCommand::QueryModuleParams { module_id });
                        }
                    }
                }
            }
            Message::CollapseModule => {
                self.module_params.expanded = None;
            }
            Message::SetModuleParam { module_id, key, value } => {
                self.module_params.values.insert((module_id, key.clone()), value);
                self.module_gui.write_param(module_id, &key, value);
                if let Some(ref engine) = self.engine {
                    engine.send(EngineCommand::SetParam { module_id, key, value });
                }
            }
            Message::SelectTrackAndExpandModule { track_index, module_id } => {
                self.selected_track = Some(track_index);
                return self.update(Message::ExpandModule(module_id));
            }
            _ => {}
        }
        Task::none()
    }
}