//! A widget showing a menu.

use crate::{description_item, menu_page};
use gtk::StackExt;
use indexmap::IndexMap;
use relm::{Relm, Update, Widget};
use uuid::Uuid;

/// The description of a menu item.
#[derive(Debug, Clone)]
pub enum Item {
    /// A single description item that can be selected directly.
    Description(description_item::Item),
    /// A sub menu.
    SubMenu {
        /// The description item displayed in the parent menu.
        header: description_item::Item,
        /// The contents of the sub menu.
        items: IndexMap<Uuid, Item>,
    },
}

/// A menu.
#[derive(Debug, Clone)]
pub struct TopMenu {
    /// The description of the header label
    pub header: Option<description_item::Item>,
    /// The uuid of the menu.
    pub uuid: Uuid,
    /// The children displayed inside the menu.
    pub items: IndexMap<Uuid, Item>,
}

/// The parameter to the widget.
#[derive(Debug, Clone)]
pub struct Param {
    /// The menu.
    pub menu: TopMenu,
    /// The back button icon.
    pub back_icon: gdk_pixbuf::Pixbuf,
}

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

/// Incoming message.
#[derive(Debug)]
pub struct Incoming {
    /// The message contents.
    pub msg: IncomingMsg,
}

/// An incoming message.
#[derive(Debug)]
pub enum IncomingMsg {
    /// Reset the menu.
    Reset,
}

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

#[derive(Debug)]
enum InternalMsg {
    /// A message from a submenu.
    MenuMsg(menu_page::OutgoingMsg),
}

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

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

/// Outgoing message.
#[derive(Debug, Clone)]
pub enum OutgoingMsg {
    /// An item was selected.
    ItemActivated(Uuid),
}

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

impl Update for W {
    type Model = Param;
    type ModelParam = Param;
    type Msg = Msg;

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

    fn update(&mut self, event: Msg) {
        match event {
            Msg::Incoming(msg) => self.update_incoming(msg.msg),
            Msg::Internal(msg) => self.update_internal(msg.msg),
            Msg::Outgoing(_) => {}
        }
    }
}

impl W {
    fn update_internal(&mut self, msg: InternalMsg) {
        use self::InternalMsg::*;
        match msg {
            MenuMsg(msg) => {
                use menu_page::OutgoingMsg::*;
                match msg {
                    GoUp(uuid) => {
                        self.root.set_visible_child_full(
                            &uuid.to_string(),
                            gtk::StackTransitionType::SlideRight,
                        );
                    }
                    GoDown(uuid) => {
                        self.root.set_visible_child_full(
                            &uuid.to_string(),
                            gtk::StackTransitionType::SlideLeft,
                        );
                    }
                    ItemActivated(uuid) => {
                        self.relm.stream().emit(Msg::from(
                            OutgoingMsg::ItemActivated(uuid),
                        ));
                    }
                }
            }
        }
    }

    fn update_incoming(&mut self, msg: IncomingMsg) {
        use self::IncomingMsg::*;
        match msg {
            Reset => {
                self.root.set_visible_child_full(
                    &root_uuid().to_string(),
                    gtk::StackTransitionType::Crossfade,
                );
            }
        }
    }
}

fn root_uuid() -> Uuid {
    Uuid::from_u128(0x428a3431_dc4a_489c_99e1_b4a17f7d4dc8)
}

fn add_menu(
    relm: &Relm<W>,
    stack: &mut gtk::Stack,
    go_back: Option<Uuid>,
    uuid: Uuid,
    header: Option<&description_item::Item>,
    items: &IndexMap<Uuid, Item>,
    back_icon: &gdk_pixbuf::Pixbuf,
) -> IndexMap<Uuid, relm::Component<menu_page::W>> {
    let mut components = IndexMap::new();

    let param = menu_page::Param {
        go_back,
        header: header.cloned(),
        items: items.clone(),
        back_icon: back_icon.clone(),
    };
    let page = relm::create_component::<menu_page::W>(param);
    connect!(
        page@menu_page::Msg::Outgoing(ref e),
        relm,
        Msg::from(InternalMsg::MenuMsg(e.msg.clone())));
    stack.add_named(page.widget(), &uuid.to_string());
    components.insert(uuid, page);

    for (child_uuid, item) in items.iter() {
        use self::Item::*;
        match item {
            Description(_) => {}
            SubMenu { header, items } => {
                let children = add_menu(
                    relm,
                    stack,
                    Some(uuid),
                    *child_uuid,
                    Some(header),
                    &items,
                    back_icon,
                );
                components.extend(children.into_iter());
            }
        }
    }

    components
}

impl Widget for W {
    type Root = gtk::Stack;

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

    fn view(relm: &Relm<Self>, model: Self::Model) -> Self {
        let Param { menu, back_icon } = model;

        let mut root = gtk::StackBuilder::new().homogeneous(false).build();
        let components = add_menu(
            relm,
            &mut root,
            None,
            root_uuid(),
            menu.header.as_ref(),
            &menu.items,
            &back_icon,
        );

        root.set_visible_child_full(
            &root_uuid().to_string(),
            gtk::StackTransitionType::None,
        );

        W {
            root,
            relm: relm.clone(),
            _components: components,
        }
    }
}

/// The widget.
pub struct W {
    root: gtk::Stack,
    relm: Relm<Self>,
    _components: IndexMap<Uuid, relm::Component<menu_page::W>>,
}

impl<T: AsRef<IndexMap<Uuid, description_item::Item>>> From<T>
    for TopMenu
{
    fn from(t: T) -> TopMenu {
        TopMenu {
            header: None,
            uuid: root_uuid(),
            items: t
                .as_ref()
                .into_iter()
                .map(|(k, v)| (*k, Item::Description(v.clone())))
                .collect(),
        }
    }
}