use glib::Object;
use gtk::{glib, prelude::*, subclass::prelude::*};
use kifu_core::ui::GamePreviewElement;
use std::{cell::RefCell, rc::Rc};

#[derive(Default)]
pub struct GameObjectPrivate {
    game: Rc<RefCell<Option<GamePreviewElement>>>,
}

#[glib::object_subclass]
impl ObjectSubclass for GameObjectPrivate {
    const NAME: &'static str = "GameObject";
    type Type = GameObject;
}

impl ObjectImpl for GameObjectPrivate {}

glib::wrapper! {
    pub struct GameObject(ObjectSubclass<GameObjectPrivate>);
}

impl GameObject {
    pub fn new(game: GamePreviewElement) -> Self {
        let s: Self = Object::builder().build();
        *s.imp().game.borrow_mut() = Some(game);
        s
    }

    pub fn game(&self) -> Option<GamePreviewElement> {
        self.imp().game.borrow().clone()
    }
}

pub struct GameDatabasePrivate {
    model: gio::ListStore,
    list_view: gtk::ListView,
}

impl Default for GameDatabasePrivate {
    fn default() -> Self {
        let vector: Vec<GameObject> = vec![];
        let model = gio::ListStore::new(glib::types::Type::OBJECT);
        model.extend_from_slice(&vector);
        let factory = gtk::SignalListItemFactory::new();

        factory.connect_setup(move |_, list_item| {
            let label = gtk::Label::new(Some("some kind of text"));
            list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be a ListItem")
                .set_child(Some(&label));
        });
        factory.connect_bind(move |_, list_item| {
            let game_object = list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be ListItem")
                .item()
                .and_downcast::<GameObject>()
                .expect("The item has to be an IntegerObject.");

            let label = list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be ListItem")
                .child()
                .and_downcast::<gtk::Label>()
                .expect("The child has to be an Label.");

            label.set_label(
                format!(
                    "{} vs. {}",
                    game_object
                        .game()
                        .map(|g| g.black_player)
                        .unwrap_or("black".to_owned()),
                    game_object
                        .game()
                        .map(|g| g.white_player)
                        .unwrap_or("white".to_owned())
                )
                .as_ref(),
            );
        });

        let selection_model = gtk::NoSelection::new(Some(model.clone()));
        let list_view = gtk::ListView::new(Some(selection_model), Some(factory));
        Self { model, list_view }
    }
}

#[glib::object_subclass]
impl ObjectSubclass for GameDatabasePrivate {
    const NAME: &'static str = "GameDatabase";
    type Type = GameDatabase;
    type ParentType = gtk::Box;
}

impl ObjectImpl for GameDatabasePrivate {}
impl WidgetImpl for GameDatabasePrivate {}
impl BoxImpl for GameDatabasePrivate {}

glib::wrapper! {
    pub struct GameDatabase(ObjectSubclass<GameDatabasePrivate>) @extends gtk::Widget, gtk::Box;
}

impl GameDatabase {
    pub fn new() -> Self {
        let s: Self = Object::builder().build();
        s.set_width_request(200);
        s.set_height_request(200);
        s.append(&s.imp().list_view);
        s
    }

    pub fn set_games(&self, games: Vec<GamePreviewElement>) {
        let games = games
            .into_iter()
            .map(|g| GameObject::new(g))
            .collect::<Vec<GameObject>>();
        self.imp().model.extend_from_slice(&games);
    }
}