//! A widget for querying samplic parameters for a sample.

use gtk::{BoxExt, ButtonExt, WidgetExt};
use indexmap::IndexMap;
use ommui_data::samplic::{
    Parameter, ParameterDescription, ProfileParameterDescription,
};
use relm::{Component, ContainerWidget, Relm, Update, Widget};
use {parameter_editor, text_entry, tr, XTr};

/// The parameter passed to the model on creation.
#[derive(Debug)]
pub struct Param<TR: XTr> {
    /// The sample identifier.
    pub identifier: String,
    /// The parameter values.
    pub values: IndexMap<String, Parameter>,
    /// The parameter descriptions.
    pub descriptions: IndexMap<String, ParameterDescription>,
    /// The profile-specific parameter configuration.
    pub profile: IndexMap<String, ProfileParameterDescription>,
    /// The translation.
    pub translation: TR,
}

/// Message for updating the widget.
#[derive(Msg, Debug)]
pub enum Msg {
    /// Internal message
    Internal(Internal),
    /// Outgoing message
    Outgoing(Outgoing),
}

/// Internal message.
#[derive(Debug)]
pub struct Internal {
    msg: InternalMsg,
}

#[derive(Debug)]
enum InternalMsg {
    /// An outgoing message from the parameter editor.
    ParameterEditorMsg(parameter_editor::OutgoingMsg),
    /// An outgoing message from the identifier entry.
    IdentifierEntryMsg(text_entry::OutgoingMsg),
    /// The confirm button got clicked.
    ConfirmButtonClicked,
}

impl From<InternalMsg> for Msg {
    fn from(msg: InternalMsg) -> Msg {
        Msg::Internal(Internal { msg })
    }
}

impl<TR: XTr + Clone> Update for W<TR> {
    type Model = Param<TR>;
    type ModelParam = Param<TR>;
    type Msg = Msg;

    fn model(_relm: &Relm<Self>, details: Param<TR>) -> Self::Model {
        details
    }

    fn update(&mut self, event: Msg) {
        use self::Msg::*;
        match event {
            Internal(e) => self.update_internal(e.msg),
            Outgoing(_) => {}
        }
    }
}

/// Outgoing message.
#[derive(Debug)]
pub struct Outgoing {
    /// The message.
    pub msg: OutgoingMsg,
}

/// Outgoing message.
#[derive(Debug, Clone)]
pub enum OutgoingMsg {
    /// The parameters were confirmed.
    Confirmed {
        /// The sample identifier
        identifier: String,
        /// The values
        values: IndexMap<String, Parameter>,
    },
}

impl From<OutgoingMsg> for Msg {
    fn from(msg: OutgoingMsg) -> Msg {
        Msg::Outgoing(Outgoing { msg })
    }
}

impl<TR: XTr + Clone> W<TR> {
    fn update_internal(&mut self, e: InternalMsg) {
        use self::InternalMsg::*;
        match e {
            ParameterEditorMsg(msg) => {
                use parameter_editor::OutgoingMsg::*;
                match msg {
                    ValueChanged { index, value } => {
                        let k = self
                            .values
                            .get_index(index)
                            .unwrap()
                            .0
                            .to_string();
                        self.values
                            .entry(k.to_string())
                            .and_modify(|v| *v = value);
                    }
                }
            }
            IdentifierEntryMsg(msg) => {
                use text_entry::OutgoingMsg::*;
                match msg {
                    ValueChanged(identifier) => {
                        self.identifier = identifier;
                    }
                }
            }
            ConfirmButtonClicked => {
                self.relm.stream().emit(Msg::from(
                    OutgoingMsg::Confirmed {
                        identifier: self.identifier.to_string(),
                        values: self.values.clone(),
                    },
                ));
            }
        }
    }
}

impl<TR: 'static + XTr + Clone> Widget for W<TR> {
    type Root = gtk::Box;

    fn root(&self) -> Self::Root {
        self.root.clone()
    }

    fn view(relm: &Relm<Self>, model: Self::Model) -> Self {
        let Param {
            descriptions,
            profile,
            translation,
            values,
            identifier,
        } = model;
        let parameter_model = parameter_editor::Param {
            descriptions,
            profile,
            translation,
            values: values.clone(),
        };

        let root = gtk::Box::new(gtk::Orientation::Vertical, 0);

        root.pack_start(
            &gtk::Label::new(Some(tr("Identifier").as_str())),
            false,
            false,
            0,
        );
        let identifier_model = text_entry::Param {
            value: identifier.to_string(),
        };
        let identifier_entry =
            root.add_widget::<text_entry::W>(identifier_model);
        connect!(
            identifier_entry@text_entry::Msg::Outgoing(ref msg),
            relm,
            Msg::from(InternalMsg::IdentifierEntryMsg(msg.msg.clone()))
        );

        let parameters_scroller = gtk::ScrolledWindow::new(
            None::<&gtk::Adjustment>,
            None::<&gtk::Adjustment>,
        );
        parameters_scroller.set_size_request(300, 150);

        let editor = parameters_scroller
            .add_widget::<parameter_editor::W<TR>>(parameter_model);

        connect!(
            editor@parameter_editor::Msg::Outgoing(ref msg),
            relm,
            Msg::from(InternalMsg::ParameterEditorMsg(msg.msg.clone()))
        );

        root.pack_start(
            &gtk::Label::new(Some(tr("Parameters").as_str())),
            false,
            false,
            0,
        );
        root.pack_start(&parameters_scroller, true, true, 0);

        let b = gtk::Button::new_with_label(&tr("Continue →"));
        root.pack_start(&b, false, false, 0);
        connect!(
            relm,
            b,
            connect_clicked(_),
            Msg::from(InternalMsg::ConfirmButtonClicked)
        );

        root.show_all();

        W {
            relm: relm.clone(),
            root,
            _editor: editor,
            _identifier_entry: identifier_entry,
            identifier,
            values,
        }
    }
}

/// The widget.
pub struct W<TR: 'static + XTr + Clone> {
    relm: Relm<W<TR>>,
    root: gtk::Box,
    _editor: Component<parameter_editor::W<TR>>,
    _identifier_entry: Component<text_entry::W>,
    identifier: String,
    values: IndexMap<String, Parameter>,
}