use std::cell::RefCell;
use std::fs;
use std::io::ErrorKind;
use std::path::Path;
use std::rc::Rc;

use crate::db::*;
use crate::ui::cards::new::*;
use crate::widgets::card_entry::CardEntry;
use glib::subclass::InitializingObject;
use gtk::glib::object::ObjectExt;
use gtk::glib::{clone, closure_local};
use gtk::subclass::prelude::*;
use gtk::{gio, glib, Box, Button, CompositeTemplate, ScrolledWindow, SearchEntry, Window};
use gtk::{prelude::*, FileDialog};
use rusqlite::Connection;
use sha256::try_digest;
use gtk::prelude::WidgetExt;

#[derive(CompositeTemplate, Default)]
#[template(resource = "/org/foxarmy/learn-hieroglyph/cards/edit/ui.xml")]
pub struct MemoryCardsEditScene {
    #[template_child]
    pub search_entry: TemplateChild<SearchEntry>,
    #[template_child]
    pub add_button: TemplateChild<Button>,
    #[template_child]
    pub cards_container: TemplateChild<Box>,
    #[template_child]
    pub cards_scrolled_window: TemplateChild<ScrolledWindow>,

    displaying_cards: RefCell<Vec<CardEntry>>
}

#[glib::object_subclass]
impl ObjectSubclass for MemoryCardsEditScene {
    const NAME: &'static str = "MemoryCardsEditScene";
    type Type = super::MemoryCardsEditScene;
    type ParentType = gtk::ApplicationWindow;

    fn class_init(klass: &mut Self::Class) {
        klass.bind_template();
    }

    fn instance_init(obj: &InitializingObject<Self>) {
        obj.init_template();
    }
}

impl ObjectImpl for MemoryCardsEditScene {
    fn constructed(&self) {
        self.parent_constructed();

        self.query_cards(None);
        self.update_card_list();

        let binding = self.obj();

        self.add_button.connect_closure("clicked", 
                                        false,
                                        closure_local!(@strong binding => move |_b: &Button| {
                                        let new_win = Rc::new(MemoryCardsNewScene::new(&binding.application().unwrap()));
                                        new_win.get_file_choose_button().connect_clicked(clone!(@strong new_win => move |_| {
                                            gtk::glib::MainContext::default().spawn_local(file_choose_dialog(Rc::clone(&new_win)));
                                        }));
                                        new_win.get_done_button().connect_closure("clicked", true, closure_local!(@strong binding => move |_w: &Button| {
                                            binding.imp().query_cards(None);
                                            binding.imp().update_card_list();
                                        }));
                                        new_win.present();
                                        
        }));

        self.search_entry.connect_closure("changed", false, closure_local!(@strong binding => move |e: &SearchEntry| {
            binding.imp().query_cards(
                match e.text().as_str() {
                    "" => None,
                    _ => {
                        let search_option = e.text().to_string();   
                        let conditions = format!("hieroglyph LIKE '%{}%' OR reading LIKE '%{}%'", search_option, search_option);
                        Some(conditions)
                    }
                }
            );
            binding.imp().update_card_list();
        }));
        self.update_card_list();
    }
}

impl MemoryCardsEditScene {
    pub fn clear_displaying_card(&self) {
        let c: &Box = self.cards_container.as_ref();

        while c.first_child() != None {
            c.remove(&c.first_child().unwrap());
        }
    }

    pub fn query_cards(&self, options: Option<String>) {
        let conn = Connection::open(get_db_path()).unwrap();

        let selector = match options {
            Some(s) => "WHERE ".to_owned() + &s,
            None => "".to_owned()
        };

        let sql = format!("SELECT imagename, hieroglyph, reading FROM cards {selector}");
        let mut stmt = conn
            .prepare(sql.as_str())
            .unwrap();
        let cards_iter = stmt
            .query_map([], |row| {
                let image_path: String = row.get(0).unwrap();
                let image_path: String = get_images_store_path() + &image_path;
                let hieroglyph: String = row.get(1).unwrap();
                let reading: String = row.get(2).unwrap();
                let entry = CardEntry::new(&image_path, &hieroglyph, &reading);
                Ok(entry)
            })
            .unwrap();
        self.displaying_cards.borrow_mut().clear();
        for card in cards_iter {
            let card_binding = card.unwrap();
            self.displaying_cards.borrow_mut().push(card_binding);
        }
    }

    pub fn update_card_list(&self) {
        let c: &Box = self.cards_container.as_ref();

        self.clear_displaying_card();

        for card in self.displaying_cards.borrow().iter() {
            let self_binding = self.obj();
            c.append(card);

            card.get_delete_button_widget().connect_closure("clicked", false, closure_local!(@strong card, @strong self_binding => move |_b: &Button| {
                let connection = Connection::open(get_db_path()).unwrap();
                let imagepath = card.imagepath();
                let imagename = &Path::new(&imagepath).file_name().unwrap().to_str().unwrap();
                fs::remove_file(get_images_store_path() + "/" + &imagename).expect("Could not remove file!");
                connection.execute("DELETE FROM cards WHERE imagename = ?1", [&imagename]).unwrap();
                self_binding.imp().update_card_list();
            }));
            card.update_file_for_picture();
        }
    }
}

async fn file_choose_dialog<W: IsA<gtk::Window>>(window: Rc<W>) {
    let dialog: FileDialog = gtk::FileDialog::builder().build();
    let answer = dialog.open_future(Some(&*window)).await;
    let path = answer.unwrap().path().unwrap();
    let path: &str = path.as_path().to_str().unwrap();
    let w: &MemoryCardsNewScene = Into::<&Window>::into(window.upcast_ref())
        .downcast_ref()
        .unwrap(); // Weird casting from &Window as passed in func to &MemoryCardsNewScene

    w.get_picture_widget()
        .set_file(Some(&gio::File::for_path(path)));

    let images_store_path = get_program_home_path() + "/images";

    match fs::create_dir_all(&images_store_path) {
        Ok(_) => {}
        Err(error) => match error.kind() {
            ErrorKind::AlreadyExists => {}
            _ => panic!("Could not create directory for storing pictures!"),
        },
    };

    let hash = try_digest(path).unwrap();
    let extenstion = Path::new(path).extension().unwrap().to_str().unwrap();
    let new_filename: String = hash.as_str().to_owned() + "." + extenstion;
    let stored_image_path = Path::new(&images_store_path).join(&new_filename);
    fs::copy(path, stored_image_path).expect("Error copying image to store");

    w.get_done_button().connect_closure(
        "clicked",
        false,
        closure_local!(@strong w => move |_b: &Button| {
            let hieroglyph = w.get_hieroglyph_input();
            let reading = w.get_reading_input();
            let conn = Connection::open(get_db_path()).unwrap();

            let query = "INSERT INTO cards (imagename, hieroglyph, reading) VALUES(?1, ?2, ?3)";
            conn.execute(query, (&new_filename, &hieroglyph, &reading)).unwrap();      
            w.close();
        }),
    );
}

impl WidgetImpl for MemoryCardsEditScene {}

impl WindowImpl for MemoryCardsEditScene {}

impl ApplicationWindowImpl for MemoryCardsEditScene {}