use diesel::prelude::*;
use diesel::r2d2::{ConnectionManager, Pool};
use gtk::gdk::Display;
use gtk::prelude::*;
use relm4::{factory::FactoryVecDeque, prelude::*};

mod library_list;
mod sample_list;
use library_list::LibraryListItem;
mod app_msg;
use app_msg::AppMsg;
use sample_amp::get_connection_pool;
use sample_amp::models::Library;
use sample_amp::schema::libraries;

use crate::sample_list::SampleListModel;

struct AppModel {
    sample_list: Controller<SampleListModel>,
    libraries: FactoryVecDeque<LibraryListItem>,
    pool: Pool<ConnectionManager<SqliteConnection>>,
}

#[relm4::component]
impl SimpleComponent for AppModel {
    type Input = AppMsg;

    type Output = ();
    type Init = ();

    fn init(
        _: Self::Init,
        window: &Self::Root,
        sender: ComponentSender<Self>,
    ) -> relm4::ComponentParts<Self> {
        let mut model = AppModel {
            pool: get_connection_pool(),
            libraries: FactoryVecDeque::new(gtk::ListBox::default(), sender.input_sender()),
            sample_list: SampleListModel::builder().launch(()).detach(),
        };

        let sample_view = model.sample_list.widget();

        // todo: cleaner
        let library_results = libraries::dsl::libraries
            .select(Library::as_select())
            .load(&mut model.pool.get().expect("Expected a connection."))
            .expect("Error loading libraries");

        model.libraries.guard().push_back("All".to_string());
        for lib in library_results {
            model.libraries.guard().push_back(lib.name);
        }

        let library_view = model.libraries.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

    fn update(&mut self, message: Self::Input, _sender: ComponentSender<Self>) {
        match message {
            AppMsg::Close => {
                relm4::main_application().quit();
            }
        }
    }

    view! {
        gtk::Window {
            set_title: Some("SampleAmp"),
            set_default_width: 1000,
            set_default_height: 600,

            connect_close_request[sender] => move |_| {
                sender.input(AppMsg::Close);
                gtk::Inhibit(true)
            },

            gtk::Box {
                gtk::ScrolledWindow {
                    set_css_classes: &["sidebar"],
                    set_hscrollbar_policy: gtk::PolicyType::Never,
                    #[local_ref]
                    library_view -> gtk::ListBox{
                        set_css_classes: &["navigation-sidebar"]
                    }
                },
                gtk::Box {
                    set_orientation: gtk::Orientation::Vertical,
                    set_hexpand: true,

                    #[local_ref]
                    sample_view -> gtk::ScrolledWindow {},

                    gtk::Box {
                        set_height_request: 100,
                        set_margin_all: 5,
                        gtk::Label {
                            #[watch]
                            set_label: "Sample playback",
                        },
                    }
                }
            }
        }
    }
}

fn load_css() {
    let provider = gtk::CssProvider::new();
    provider.load_from_data(include_str!("../css/style.css"));
    gtk::style_context_add_provider_for_display(
        &Display::default().expect("Could not connect to a display."),
        &provider,
        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
    );
}

fn main() {
    let app = RelmApp::new("relm.test.simple_manual");
    relm4::main_application().connect_startup(|_| load_css());
    relm4_icons::initialize_icons();
    app.run::<AppModel>(());
}