#![allow(new_without_default)]

use gio::{
    ActionMapExt, ApplicationExt, ApplicationExtManual, ApplicationFlags, Settings, SettingsExt,
    SimpleAction, SimpleActionExt,
};
use glib;
use gst_player;
use gtk;
use gtk::prelude::*;
use gtk::SettingsExt as GtkSettingsExt;

use crossbeam_channel::{unbounded, Sender};
use hammond_data::Podcast;

use headerbar::Header;
use settings::{self, WindowGeometry};
use stacks::{Content, PopulatedState};
use utils;
use widgets::appnotif::{InAppNotification, UndoState};
use widgets::player;
use widgets::player::PlayerExt;
use widgets::{about_dialog, mark_all_notif, remove_show_notif};

use std::rc::Rc;
use std::sync::Arc;

/// Creates an action named $called in the action map $on with the handler $handle
macro_rules! action {
    ($on:expr, $called:expr, $handle:expr) => {{
        // Create a stateless, parameterless action
        let act = SimpleAction::new($called, None);
        // Connect the handler
        act.connect_activate($handle);
        // Add it to the map
        $on.add_action(&act);
        // Return the action
        act
    }};
}

#[derive(Debug, Clone)]
pub enum Action {
    RefreshAllViews,
    RefreshEpisodesView,
    RefreshEpisodesViewBGR,
    RefreshShowsView,
    ReplaceWidget(Arc<Podcast>),
    RefreshWidgetIfSame(i32),
    ShowWidgetAnimated,
    ShowShowsAnimated,
    HeaderBarShowTile(String),
    HeaderBarNormal,
    HeaderBarShowUpdateIndicator,
    HeaderBarHideUpdateIndicator,
    MarkAllPlayerNotification(Arc<Podcast>),
    RemoveShow(Arc<Podcast>),
    ErrorNotification(String),
    InitEpisode(i32),
    PlayerDurationChanged(player::Duration),
    PlayerPositionUpdated(player::Position),
    PlayerEndofStream(gst_player::Player),
}

#[derive(Debug)]
pub struct App {
    app_instance: gtk::Application,
    settings: Settings,
}

impl App {
    pub fn new() -> App {
        let settings = Settings::new("org.gnome.Hammond");
        let application = gtk::Application::new("org.gnome.Hammond", ApplicationFlags::empty())
            .expect("Application Initialization failed...");

        let cleanup_date = settings::get_cleanup_date(&settings);
        utils::cleanup(cleanup_date);

        application.connect_startup(clone!(settings => move |app| {
            let (sender, receiver) = unbounded();

            app.set_accels_for_action("win.refresh", &["<primary>r"]);
            app.set_accels_for_action("win.quit", &["<primary>q"]);
            // Bind the hamburger menu button to `F10`
            app.set_accels_for_action("win.menu", &["F10"]);

            app.connect_activate(clone!(sender, settings => move |app| {
                // Get the current window (if any)
                if let Some(window) = app.get_active_window() {
                    // Already open, just raise the window
                    window.present();
                } else {
                    // Time to open one!
                    // Create the main window
                    let window = gtk::ApplicationWindow::new(&app);
                    window.set_title("Hammond");

                    App::setup_gactions(&window, &sender);

                    window.connect_delete_event(clone!(app, settings => move |window, _| {
                        WindowGeometry::from_window(&window).write(&settings);
                        app.quit();
                        Inhibit(false)
                    }));


                    // Create a content instance
                    let content =
                        Rc::new(Content::new(sender.clone()).expect(
                            "Content Initialization failed."));

                    // Create the headerbar
                    let header = Rc::new(Header::new(&content, &window, &sender));

                    action!(window, "menu", clone!(header => move |_, _| {
                        header.open_menu();
                    }));

                    // Add the content main stack to the overlay.
                    let overlay = gtk::Overlay::new();
                    overlay.add(&content.get_stack());

                    let wrap = gtk::Box::new(gtk::Orientation::Vertical, 0);
                    // Add the overlay to the main Box
                    wrap.add(&overlay);

                    let player = player::PlayerWidget::new(&sender);
                    // Add the player to the main Box
                    wrap.add(&player.action_bar);

                    window.add(&wrap);

                    WindowGeometry::from_settings(&settings).apply(&window);

                    App::setup_timed_callbacks(&sender, &settings);

                    window.show_all();
                    window.activate();

                    gtk::timeout_add(50, clone!(sender, receiver => move || {
                        // Uses receiver, content, header, sender, overlay, playback
                        match receiver.try_recv() {
                            Ok(Action::RefreshAllViews) => content.update(),
                            Ok(Action::RefreshShowsView) => content.update_shows_view(),
                            Ok(Action::RefreshWidgetIfSame(id)) =>
                                content.update_widget_if_same(id),
                            Ok(Action::RefreshEpisodesView) => content.update_home(),
                            Ok(Action::RefreshEpisodesViewBGR) =>
                                content.update_home_if_background(),
                            Ok(Action::ReplaceWidget(pd)) => {
                                let shows = content.get_shows();
                                let mut pop = shows.borrow().populated();
                                pop.borrow_mut()
                                    .replace_widget(pd.clone())
                                    .map_err(|err| error!("Failed to update ShowWidget: {}", err))
                                    .map_err(|_|
                                        error!("Failed ot update ShowWidget {}", pd.title()))
                                    .ok();
                            }
                            Ok(Action::ShowWidgetAnimated) => {
                                let shows = content.get_shows();
                                let mut pop = shows.borrow().populated();
                                pop.borrow_mut().switch_visible(
                                    PopulatedState::Widget,
                                    gtk::StackTransitionType::SlideLeft,
                                );
                            }
                            Ok(Action::ShowShowsAnimated) => {
                                let shows = content.get_shows();
                                let mut pop = shows.borrow().populated();
                                pop.borrow_mut()
                                    .switch_visible(PopulatedState::View,
                                                    gtk::StackTransitionType::SlideRight);
                            }
                            Ok(Action::HeaderBarShowTile(title)) =>
                                header.switch_to_back(&title),
                            Ok(Action::HeaderBarNormal) => header.switch_to_normal(),
                            Ok(Action::HeaderBarShowUpdateIndicator) =>
                                header.show_update_notification(),
                            Ok(Action::HeaderBarHideUpdateIndicator) =>
                                header.hide_update_notification(),
                            Ok(Action::MarkAllPlayerNotification(pd)) => {
                                let notif = mark_all_notif(pd, &sender);
                                notif.show(&overlay);
                            }
                            Ok(Action::RemoveShow(pd)) => {
                                let notif = remove_show_notif(pd, sender.clone());
                                notif.show(&overlay);
                            }
                            Ok(Action::ErrorNotification(err)) => {
                                error!("An error notification was triggered: {}", err);
                                let callback = || glib::Continue(false);
                                let notif = InAppNotification::new(&err, callback,
                                                                   || {}, UndoState::Hidden);
                                notif.show(&overlay);
                            },
                            Ok(Action::InitEpisode(rowid)) => player.initialize_episode(rowid).unwrap(),
                            Ok(Action::PlayerDurationChanged(dur)) => player.timer.on_duration_changed(dur),
                            Ok(Action::PlayerPositionUpdated(pos)) => player.timer.on_position_updated(pos),
                            Ok(Action::PlayerEndofStream(_)) => player.stop(),
                            Err(_) => (),
                        }

                        Continue(true)
                    }));
                }
            }));
        }));

        App {
            app_instance: application,
            settings,
        }
    }

    fn setup_timed_callbacks(sender: &Sender<Action>, settings: &Settings) {
        App::setup_dark_theme(settings);
        App::setup_refresh_on_startup(&sender, settings);
        App::setup_auto_refresh(&sender, settings);
    }

    fn setup_dark_theme(settings: &Settings) {
        let gtk_settings = gtk::Settings::get_default().unwrap();
        let enabled = settings.get_boolean("dark-theme");

        gtk_settings.set_property_gtk_application_prefer_dark_theme(enabled);
    }

    fn setup_refresh_on_startup(sender: &Sender<Action>, settings: &Settings) {
        // Update the feeds right after the Application is initialized.
        let sender = sender.clone();
        if settings.get_boolean("refresh-on-startup") {
            info!("Refresh on startup.");
            // The ui loads async, after initialization
            // so we need to delay this a bit so it won't block
            // requests that will come from loading the gui on startup.
            gtk::timeout_add(1500, move || {
                let s: Option<Vec<_>> = None;
                utils::refresh(s, sender.clone());
                glib::Continue(false)
            });
        }
    }

    fn setup_auto_refresh(sender: &Sender<Action>, settings: &Settings) {
        let refresh_interval = settings::get_refresh_interval(&settings).num_seconds() as u32;

        info!("Auto-refresh every {:?} seconds.", refresh_interval);

        let sender = sender.clone();
        gtk::timeout_add_seconds(refresh_interval, move || {
            let s: Option<Vec<_>> = None;
            utils::refresh(s, sender.clone());

            glib::Continue(true)
        });
    }

    /// Define the `GAction`s.
    ///
    /// Used in menus and the keyboard shortcuts dialog.
    fn setup_gactions(win: &gtk::ApplicationWindow, sender: &Sender<Action>) {
        // Create the `refresh` action.
        //
        // This will trigger a refresh of all the shows in the database.
        action!(
            win,
            "refresh",
            clone!(sender => move |_, _| {
            gtk::idle_add(clone!(sender => move || {
                let s: Option<Vec<_>> = None;
                utils::refresh(s, sender.clone());
                glib::Continue(false)
            }));
        })
        );

        // Create the `OPML` import action
        action!(
            win,
            "import",
            clone!(sender, win => move |_, _| {
            utils::on_import_clicked(&win, &sender);
        })
        );

        // Create the action that shows a `gtk::AboutDialog`
        action!(
            win,
            "about",
            clone!(win => move |_, _| {
            about_dialog(&win);
        })
        );

        // Create the quit action
        action!(
            win,
            "quit",
            clone!(win => move |_, _| win.get_application().expect("Failed to get application").quit())
        );
    }

    pub fn run(self) {
        // Weird magic I copy-pasted that sets the Application Name in the Shell.
        glib::set_application_name("Hammond");
        glib::set_prgname(Some("Hammond"));
        // We need out own org.gnome.Hammon icon
        gtk::Window::set_default_icon_name("multimedia-player");
        ApplicationExtManual::run(&self.app_instance, &[]);
    }
}