//! A widget for showing a message.

use gtk;
use gtk::{BoxExt, ButtonExt, LabelExt, StyleContextExt, WidgetExt};
use relm::{Relm, Update, Widget};

/// Model for the widget.
pub struct Model {
    message: String,
    details: Option<String>,
    confirm_button_caption: Option<String>,
}

/// The parameters for creating the model.
pub struct Param {
    /// The message which should be shown.
    pub message: String,
    /// A detailed description of the message. Could be a backtrace
    /// or contents of a log file. When set, an expander will be
    /// added which opens the detailed view.
    pub details: Option<String>,
    /// The text which gets shown on the confirm button.
    ///
    /// If this is `None`, no confirm button is shown. If it is `Some`,
    /// then the confirm button gets shown with the text on it.
    /// If this is used, it will usually be something like "OK",
    /// "Confirm" or "Close".
    pub confirm_button_caption: Option<String>,
}

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

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

/// A message which can be sent to a W instance.
#[derive(Debug)]
pub enum IncomingMsg {
    /// Update the display.
    Update {
        /// The message which should be shown.
        message: String,
        /// A detailed description of the message. Could be a backtrace
        /// or contents of a log file. When set, an expander will be
        /// added which opens the detailed view.
        details: Option<String>,
        /// The text which gets shown on the confirm button.
        confirm_button_caption: Option<String>,
    },
}

impl From<IncomingMsg> for Msg {
    fn from(msg: IncomingMsg) -> Msg {
        Msg::Incoming(Incoming { msg })
    }
}

/// An 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 {
    /// The confirm button got activated.
    Confirmed,
}

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

/// The message widget.
pub struct W {
    b: gtk::Box,
    message: gtk::Label,
    details_expander: gtk::Expander,
    details: gtk::Label,
    confirm_button: gtk::Button,
}

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

    fn model(_relm: &Relm<Self>, details: Param) -> Model {
        let Param {
            message,
            details,
            confirm_button_caption,
        } = details;
        Model {
            message,
            details,
            confirm_button_caption,
        }
    }

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

impl W {
    fn update_incoming(&mut self, e: IncomingMsg) {
        use self::IncomingMsg as M;
        match e {
            M::Update {
                message,
                details,
                confirm_button_caption,
            } => {
                self.message.set_text(&message);
                self.details_expander.set_visible(details.is_some());
                self.confirm_button
                    .set_visible(confirm_button_caption.is_some());

                if let Some(text) = details {
                    self.details.set_text(&text);
                }

                if let Some(caption) = confirm_button_caption {
                    self.confirm_button.set_label(&caption);
                }
            }
        }
    }
}

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

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

    fn view(relm: &Relm<Self>, model: Self::Model) -> Self {
        use gtk::Cast;

        let b = gtk::Box::new(gtk::Orientation::Vertical, 3);

        let message = {
            let label =
                gtk::LabelBuilder::new().label(&model.message).build();
            label.get_style_context().add_class("message");

            let scroller = gtk::ScrolledWindowBuilder::new()
                .child(label.upcast_ref())
                .build();
            scroller.get_style_context().add_class("message");

            b.pack_start(&scroller, true, true, 3);
            label
        };

        let details = gtk::LabelBuilder::new()
            .justify(gtk::Justification::Left)
            .build();
        details.get_style_context().add_class("details");

        let details_expander = {
            let scroller = gtk::ScrolledWindowBuilder::new()
                .child(details.upcast_ref())
                .build();
            scroller.get_style_context().add_class("details");

            let expander = gtk::ExpanderBuilder::new()
                .label("Details")
                .child(scroller.upcast_ref())
                .build();
            expander.get_style_context().add_class("details");

            b.pack_start(&expander, false, false, 3);

            expander
        };

        let confirm_button = gtk::Button::new();
        b.pack_start(&confirm_button, false, false, 3);

        b.show_all();

        if let Some(text) = model.details {
            details.set_label(&text);
        } else {
            details.set_visible(false);
        }

        if let Some(text) = model.confirm_button_caption {
            confirm_button.set_label(&text);
        } else {
            confirm_button.set_visible(false);
        }

        connect!(
            relm,
            confirm_button,
            connect_clicked(_),
            Msg::from(OutgoingMsg::Confirmed)
        );

        W {
            b,
            message,
            details,
            details_expander,
            confirm_button,
        }
    }
}