//! A widget containing a list view insde a scrolled area.

use glib::StaticType;
use gtk::{
    CellLayoutExt, ContainerExt, GtkListStoreExtManual, TreeModelExt,
    TreeViewColumnExt, TreeViewExt, WidgetExt,
};
use relm::{Relm, Update, Widget};
use uuid::Uuid;
use {gdk_pixbuf, gtk};

#[repr(u8)]
enum ColumnIndex {
    Icon,
    Caption,
    Description,
    Id,
}

impl From<ColumnIndex> for i32 {
    fn from(c: ColumnIndex) -> i32 {
        c as i32
    }
}

impl From<ColumnIndex> for u32 {
    fn from(c: ColumnIndex) -> u32 {
        c as u32
    }
}

/// The parameter passed to the model on creation.
pub struct Param {
    /// The items shown in the model.
    pub items: Vec<Description>,
}

/// Model for the widget.
pub struct Model {
    relm: Relm<W>,
    store: gtk::ListStore,
}

/// 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 {
    /// A row of the view got activated.
    RowActivated(gtk::TreePath),
}

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

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

impl Outgoing {
    /// Get a reference to the message.
    pub fn msg(&self) -> &OutgoingMsg {
        &self.msg
    }

    /// Consumes the struct, returning the message.
    pub fn into_msg(self) -> OutgoingMsg {
        self.msg
    }
}

/// Outgoing messages.
#[derive(Debug, Clone)]
pub enum OutgoingMsg {
    /// An item got selected.
    ItemSelected(Uuid),
}

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

/// An item that gets shown in the tree.
#[derive(Clone)]
pub struct Description {
    /// The id of the item.
    pub id: Uuid,
    /// The icon of the item.
    pub icon: Option<gdk_pixbuf::Pixbuf>,
    /// The caption of the item.
    pub caption: String,
    /// The description of the item.
    pub description: String,
}

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

    fn model(relm: &Relm<Self>, details: Param) -> Self::Model {
        let store = gtk::ListStore::new(&[
            gdk_pixbuf::Pixbuf::static_type(),
            gtk::Type::String,
            gtk::Type::String,
            gtk::Type::String,
        ]);
        for item in details.items {
            use self::ColumnIndex::*;
            store.insert_with_values(
                None,
                &[
                    u32::from(Icon),
                    u32::from(Caption),
                    u32::from(Description),
                    u32::from(Id),
                ],
                &[
                    &item.icon,
                    &item.caption,
                    &item.description,
                    &format!("{}", item.id.to_hyphenated_ref()),
                ],
            );
        }
        Model {
            store,
            relm: relm.clone(),
        }
    }

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

impl W {
    fn update_internal(&mut self, e: InternalMsg) {
        use self::ColumnIndex::Id;
        use self::InternalMsg::*;
        match e {
            RowActivated(tree_path) => {
                if let Some(iter) = self.model.store.get_iter(&tree_path) {
                    let uuid = self
                        .model
                        .store
                        .get_value(&iter, i32::from(Id))
                        .get::<String>()
                        .unwrap();
                    let uuid = Uuid::parse_str(&uuid).unwrap();
                    self.model
                        .relm
                        .stream()
                        .emit(Msg::from(OutgoingMsg::ItemSelected(uuid)));
                }
            }
        }
    }
}

/// The description list view widget.
pub struct W {
    scrolled_window: gtk::ScrolledWindow,
    model: Model,
}

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

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

    fn view(relm: &Relm<Self>, model: Self::Model) -> Self {
        let scrolled_window = gtk::ScrolledWindow::new(
            None::<&gtk::Adjustment>,
            None::<&gtk::Adjustment>,
        );
        scrolled_window.set_vexpand(true);
        scrolled_window.set_hexpand(true);

        let treeview = gtk::TreeView::new_with_model(&model.store);
        scrolled_window.add(&treeview);

        connect!(
            relm,
            treeview,
            connect_row_activated(_, tree_path, _),
            Msg::from(InternalMsg::RowActivated(tree_path.clone()))
        );

        use self::ColumnIndex::*;

        {
            let col = gtk::TreeViewColumn::new();
            let renderer = gtk::CellRendererPixbuf::new();
            col.set_title("Icon");
            col.pack_start(&renderer, false);
            col.add_attribute(&renderer, "pixbuf", i32::from(Icon));
            treeview.append_column(&col);
        }

        {
            let col = gtk::TreeViewColumn::new();
            let renderer = gtk::CellRendererText::new();
            col.set_title("Name");
            col.pack_start(&renderer, false);
            col.add_attribute(&renderer, "text", i32::from(Caption));
            treeview.append_column(&col);
        }

        {
            let col = gtk::TreeViewColumn::new();
            let renderer = gtk::CellRendererText::new();
            col.set_title("Description");
            col.pack_start(&renderer, false);
            col.add_attribute(&renderer, "text", i32::from(Description));
            treeview.append_column(&col);
        }

        W {
            scrolled_window,
            model,
        }
    }
}