mod imp;

use std::cell::RefCell;

use glib::Object;
use gtk::{gio, glib::{self, subclass::types::ObjectSubclassIsExt}, prelude::*, Entry, Image};
use rusqlite::Connection;

use crate::db::{get_db_path, get_images_store_path};

glib::wrapper! {
    pub struct CardDisplay(ObjectSubclass<imp::CardDisplay>)
        @extends gtk::Widget,
        @implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
                    gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
}

struct Card {
    imagename: String,
    hieroglyph: String,
}

impl CardDisplay {
    pub fn new(image_path: &String, hieroglyph: &String) -> Self {
        Object::builder()
            .property("imagepath", image_path)
            .property("hieroglyph", hieroglyph)
            // .property("reading", reading)
            .build()
    }

    pub fn update_file_for_image(&self) {
        let image_binding: &Image = self.imp().image.as_ref();
        let path: &str = &*self.imp().imagepath.borrow().clone().to_string();
        if path == "" {
            self.imp().error_message.set_visible(true);
            return;
        }
        image_binding.set_file(Some(&path));
    }
    pub fn generate_card(&self) -> Option<(&RefCell<String>, &RefCell<String>)> {
        let connection = Connection::open(get_db_path()).unwrap();

        let mut stmt = connection.prepare("SELECT imagename, hieroglyph FROM cards ORDER BY RANDOM() LIMIT 1").unwrap();
        let random_card_iter = stmt.query_map((), |row| {
            Ok(
                Card {
                    imagename: row.get(0).unwrap(),
                    hieroglyph: row.get(1).unwrap()
                }
            )
        }).unwrap();

        let mut random_card = None;
        for i in random_card_iter {
            random_card = Some(i.unwrap());
        }
        let random_card: Card = match random_card {
            Some(card) => card,
            None => return None
        };

        *self.imp().imagepath.borrow_mut() = get_images_store_path() + "/" + random_card.imagename.as_str();
        *self.imp().hieroglyph.borrow_mut() = random_card.hieroglyph;

        self.update_file_for_image();

        connection.flush_prepared_statement_cache();
        connection.cache_flush().expect("Cannot flush cache");

        Some((&self.imp().imagepath, &self.imp().hieroglyph))
        
    }

    pub fn get_answer_entry(&self) -> &Entry {
        self.imp().answer_entry.as_ref()
    }

    pub fn get_hieroglyph(&self) -> String {
        self.imp().hieroglyph.borrow().clone()
    }
}