use adw::{prelude::*, subclass::prelude::*};
use glib::Object;
use gtk::glib;
// use otg_core::ui::GamePreviewElement;
use sgf::Game;
use std::{cell::RefCell, rc::Rc};

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

#[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: Game) -> Self {
        let s: Self = Object::builder().build();
        *s.imp().game.borrow_mut() = Some(game);
        s
    }

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

pub struct LibraryPrivate {
    model: gio::ListStore,
    list_view: gtk::ColumnView,
}

impl Default for LibraryPrivate {
    fn default() -> Self {
        let vector: Vec<GameObject> = vec![];
        let model = gio::ListStore::new::<GameObject>();
        model.extend_from_slice(&vector);

        /*
        let factory = gtk::SignalListItemFactory::new();

        factory.connect_setup(move |_, list_item| {
            let preview = GamePreview::new();
            list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be a ListItem")
                .set_child(Some(&preview));
        });
        factory.connect_bind(move |_, list_item| {
            let game_element = list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be ListItem")
                .item()
                .and_downcast::<GameObject>()
                .expect("The item has to be a GameObject.");

            let preview = list_item
                .downcast_ref::<gtk::ListItem>()
                .expect("Needs to be ListItem")
                .child()
                .and_downcast::<GamePreview>()
                .expect("The child has to be a GamePreview object.");

            match game_element.game() {
                Some(game) => preview.set_game(game),
                None => (),
            };
        });
        */

        let selection_model = gtk::NoSelection::new(Some(model.clone()));
        let list_view = gtk::ColumnView::builder()
            .model(&selection_model)
            .hexpand(true)
            .build();

        fn make_factory<F>(bind: F) -> gtk::SignalListItemFactory
        where
            F: Fn(Game) -> String + 'static,
        {
            let factory = gtk::SignalListItemFactory::new();
            factory.connect_setup(|_, list_item| {
                list_item
                    .downcast_ref::<gtk::ListItem>()
                    .unwrap()
                    .set_child(Some(
                        &gtk::Label::builder()
                            .halign(gtk::Align::Start)
                            .ellipsize(gtk::pango::EllipsizeMode::End)
                            .build(),
                    ))
            });
            factory.connect_bind(move |_, list_item| {
                let list_item = list_item.downcast_ref::<gtk::ListItem>().unwrap();
                let game = list_item.item().and_downcast::<GameObject>().unwrap();
                let preview = list_item.child().and_downcast::<gtk::Label>().unwrap();
                if let Some(game) = game.game() {
                    preview.set_text(&bind(game))
                }
            });
            factory
        }

        list_view.append_column(
            &gtk::ColumnViewColumn::builder()
                .title("date")
                .factory(&make_factory(|g| {
                    g.dates
                        .iter()
                        .map(|date| {
                            format!("{}", date)
                            /*
                            let l = locale!("en-US").into();
                            let options = length::Bag::from_date_style(length::Date::Medium);
                            let date = Date::try_new_iso_date(date.
                            let dtfmt =
                                DateFormatter::try_new_with_length(&l, options).unwrap();
                            dtfmt.format(date).unwrap()
                            */
                        })
                        .collect::<Vec<String>>()
                        .join(", ")
                }))
                .expand(true)
                .build(),
        );
        list_view.append_column(
            &gtk::ColumnViewColumn::builder()
                .title("game")
                .factory(&make_factory(|g| {
                    g.game_name.unwrap_or("Unnamed".to_owned())
                }))
                .expand(true)
                .build(),
        );
        list_view.append_column(
            &gtk::ColumnViewColumn::builder()
                .title("black")
                .factory(&make_factory(|g| {
                    g.black_player.name.unwrap_or("Black".to_owned())
                }))
                .expand(true)
                .build(),
        );
        list_view.append_column(
            &gtk::ColumnViewColumn::builder()
                .title("white")
                .factory(&make_factory(|g| {
                    g.white_player.name.unwrap_or("White".to_owned())
                }))
                .expand(true)
                .build(),
        );
        list_view.append_column(&gtk::ColumnViewColumn::new(
            Some("result"),
            Some(make_factory(|g| {
                g.result.map(|d| format!("{}", d)).unwrap_or("".to_owned())
            })),
        ));

        Self { model, list_view }
    }
}

#[glib::object_subclass]
impl ObjectSubclass for LibraryPrivate {
    const NAME: &'static str = "Library";
    type Type = Library;
    type ParentType = adw::Bin;
}

impl ObjectImpl for LibraryPrivate {}
impl WidgetImpl for LibraryPrivate {}
impl BinImpl for LibraryPrivate {}

glib::wrapper! {
    pub struct Library(ObjectSubclass<LibraryPrivate>) @extends adw::Bin, gtk::Widget;
}

impl Default for Library {
    fn default() -> Self {
        let s: Self = Object::builder().build();

        s.set_child(Some(&s.imp().list_view));
        s
    }
}

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