use std::borrow::Borrow;
use std::cell::RefCell;
use std::fs;
use std::sync::{Arc, Mutex};

use std::io::ErrorKind;
use std::path::Path;
use std::rc::Rc;


use crate::card::Card;
use crate::db::*;
use crate::ui::cards::new::*;
use crate::widgets::card_entry::CardEntry;
use glib::subclass::InitializingObject;
use gtk::gio::ListStore;
use gtk::glib::object::ObjectExt;
use gtk::glib::{clone, closure_local, Object};
use gtk::prelude::WidgetExt;
use gtk::subclass::prelude::*;
use gtk::{
    gio, glib, Button, CompositeTemplate, ListView, NoSelection, ScrolledWindow, SearchEntry,
    Switch, Window,
};
use gtk::{prelude::*, FileDialog};
use gtk::{ListItem, SignalListItemFactory};
use rusqlite::Connection;
use sha256::try_digest;

#[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<ListView>,
    #[template_child]
    pub cards_scrolled_window: TemplateChild<ScrolledWindow>,
    #[template_child]
    pub back_button: TemplateChild<Button>,

    displaying_cards: Arc<Mutex<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();
        let binding = self.obj();

        glib::spawn_future_local(clone!(@weak binding => async move {
            binding.imp().query_cards(None);
        }));

        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 |b: &Button| {
                                            b.set_visible(false);
                                            gtk::glib::MainContext::default().spawn_local(new_card_setup(Rc::clone(&new_win)));
                                            println!("test");
                                        }));
                                        new_win.get_done_button().connect_closure("clicked", true, closure_local!(@strong binding => move |_w: &Button| {
                                            binding.imp().query_cards(None);
                                            binding.imp().update_state();
                                        }));
                                        new_win.present();
        }));

        self.search_entry.connect_closure("activate", 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 '%{}%' OR translation LIKE '%{}%'", search_option, search_option, search_option);
                        Some(conditions)
                    }
                }
            );
            binding.imp().update_state();
        }));
        // self.query_cards(None);
        self.update_state();
    }
}

impl MemoryCardsEditScene {
    pub fn update_state(&self) {
        let model = ListStore::new::<CardEntry>();
        model.extend_from_slice(&*(*self.displaying_cards.lock().unwrap()).borrow());

        let factory = SignalListItemFactory::new();
        factory.connect_setup(move |_, list_item| {
            let card_entry = CardEntry::new(None);
            list_item
                .downcast_ref::<ListItem>()
                .unwrap()
                .set_child(Some(&card_entry));
        });
        let self_binding = self.obj();

        //setting up every card's buttons behavior: editing, switch flipping and deleting.
        factory.connect_closure("bind", false, closure_local!(@strong self_binding => move |_f: &SignalListItemFactory, list_item: &Object| {
            let card_object = &list_item
                .downcast_ref::<ListItem>()
                .unwrap()
                .item()
                .and_downcast::<CardEntry>()
                .unwrap();

            let card_object_to_display = list_item
                .downcast_ref::<ListItem>()
                .unwrap()
                .child()
                .and_downcast::<CardEntry>()
                .unwrap();
            card_object_to_display.get_edit_button_widget().connect_closure("clicked", false, closure_local!(@strong self_binding as binding, @strong card_object as card => move |_b: &Button| {
                let new_win = Rc::new(MemoryCardsNewScene::new(&binding.application().unwrap()));

                //setting corresponding properties
                new_win.get_picture_widget().set_file(Some(&gio::File::for_path(card.imagepath())));
                new_win.get_hieroglyph_entry().set_text(&card.hieroglyph());
                new_win.get_reading_entry().set_text(&card.reading());
                new_win.get_translation_entry().set_text(&card.translation());

                new_win.get_file_choose_button().connect_clicked(clone!(@strong new_win, @strong card => move |b: &Button| {
                    b.set_visible(false);
                    gtk::glib::MainContext::default().spawn_local(new_card_setup(Rc::clone(&new_win)));
                }));
                new_win.get_done_button().connect_closure("clicked", true, closure_local!(@strong binding, @strong new_win as w, @strong card => move |_w: &Button| {
                    let conn = Connection::open(get_db_path()).unwrap();

                    let hieroglyph = w.get_hieroglyph_input();
                    let reading = w.get_reading_input();
                    let translation = w.get_translation_input();
                    let imagepath = w.get_picture_widget().file();
                    conn.execute("INSERT OR REPLACE INTO cards ( id,
                        hieroglyph,
                        reading,
                        translation,
                        is_learning,
                        imagename
                    ) VALUES (
                        (SELECT id FROM cards WHERE hieroglyph = ?1),
                        ?1,
                        ?2,
                        ?3,
                        (SELECT is_learning FROM cards WHERE hieroglyph = ?1),
                        (SELECT imagename FROM cards WHERE hieroglyph = ?1)
                    )", (&hieroglyph, &reading, &translation)).unwrap();
                    let imagepath = imagepath.unwrap().path().unwrap();
                    let imagepath = imagepath.to_str();

                    card.set_imagepath(imagepath.unwrap());
                    card.set_hieroglyph(hieroglyph);
                    card.set_reading(reading);
                    card.set_translation(translation);
                    card.update_file_for_image();

                    binding.imp().update_state();
                    w.close();
                }));
                new_win.present();
            }));

            card_object_to_display.get_is_learning_switch_widget().connect_closure("state-set", false, closure_local!(@strong card_object as card => move |_s: &Switch, is_enabled: bool| {
                let connection = Connection::open(get_db_path()).unwrap();
                let is_learning = is_enabled;
                let hieroglyph = card.hieroglyph();
                connection.execute("UPDATE cards SET is_learning = ?1 WHERE hieroglyph = ?2", (&is_learning, &hieroglyph)).unwrap();
                glib::Propagation::Proceed
            }));

            card_object_to_display.get_delete_button_widget().connect_closure("clicked", false, closure_local!(@strong card_object as 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();
                match fs::remove_file(get_images_store_path() + "/" + &imagename) {
                    Ok(()) => (),
                    Err(_) => ()
                };
                connection.execute("DELETE FROM cards WHERE hieroglyph = ?1", [&card.hieroglyph()]).unwrap();
                let displaying_cards_lock = self_binding.imp().displaying_cards.lock().unwrap();
                let position = (**displaying_cards_lock.borrow()).borrow().iter().position(|c| *c == card).unwrap();
                displaying_cards_lock.borrow_mut().remove(position);
                self_binding.imp().update_state();
            }));

            card_object_to_display.get_image_widget().set_file(Some(card_object.get_image_file_path().as_str()));
            card_object_to_display.set_hieroglyph(card_object.hieroglyph());
            card_object_to_display.set_reading(card_object.reading());
            card_object_to_display.set_translation(card_object.translation());
            card_object_to_display.set_islearning(card_object.islearning());
        }));

        let no_selection_model = NoSelection::new(Some(model));
        let list_view = ListView::new(Some(no_selection_model), Some(factory));
        self.cards_scrolled_window.set_child(Some(&list_view));
    }

    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, translation, is_learning FROM cards {selector}"
        );

        let mut stmt  = conn.prepare(sql.as_str()).unwrap();

        // let mut stmt = stmt.lock().unwrap();
        let cards_iter = stmt
        .query_map([], |row| {
            let image_path: String = match row.get(0) {
                Ok(path) => path,
                Err(_) => String::from(""),
            };
            let c = Card::new(
                Some(get_images_store_path() + &image_path),
                Some(row.get(1).unwrap()),
                Some(row.get(2).unwrap()),
                Some(row.get(3).unwrap()),
                Some(row.get(4).unwrap()),
                );
            let entry = CardEntry::new(Some(&c));
            entry.update_state();
            Ok(entry)
        })
        .unwrap();
        for c in cards_iter {
            self.displaying_cards.lock().unwrap().borrow_mut().push(c.unwrap());
        }
    }
}

async fn new_card_setup<W: IsA<gtk::Window>>(window: Rc<W>) {
    let w: &MemoryCardsNewScene = Into::<&Window>::into(window.upcast_ref())
        .downcast_ref()
        .unwrap(); // Weird casting from &Window as passed in func to &MemoryCardsNewScene

    let picture_widget = w.get_picture_widget();

    let dialog: FileDialog = gtk::FileDialog::builder().build();
    let answer = dialog.open_future(Some(&*window)).await;
    let path = match answer {
        Ok(p) => p,
        Err(_) => return,
    }
    .path()
    .unwrap();
    let path: String = path.as_path().to_str().unwrap().to_owned();

    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 images!"),
        },
    };

    w.get_done_button().connect_closure(
        "clicked",
        false,
        closure_local!(@strong w, @strong path => move |_b: &Button| {
            let hash = try_digest(&path).unwrap();
            let extenstion = Path::new(path.as_str()).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");

            let hieroglyph = w.get_hieroglyph_input();
            // let reading = w.get_reading_input();
            // let translation = w.get_translation_input();

            // println!("Input: {hieroglyph}, {reading}, {translation}");
            let conn = Connection::open(get_db_path()).unwrap();

            // conn.execute("INSERT OR REPLACE INTO cards ( id, 
            //                 imagename, 
            //                 hieroglyph, 
            //                 reading, 
            //                 translation, 
            //                 is_learning
            //             ) VALUES (
            //                 (SELECT id FROM cards WHERE hieroglyph = ?2), 
            //                 ?1, 
            //                 ?2, 
            //                 ?3, 
            //                 ?4, 
            //                 (SELECT is_learning FROM cards WHERE hieroglyph = ?2 
            //                 )
            //             )", (&new_filename, &hieroglyph, &reading, &translation)).unwrap();
            // println!("")
            conn.execute("UPDATE cards SET imagename = ?1 WHERE hieroglyph = ?2", (&new_filename, &hieroglyph)).unwrap();
            // conn.execute("INSERT OR REPLACE INTO cards (id, imagename) VALUES ((SELECT id FROM cards WHERE hieroglyph = ?1), ?2)", (&hieroglyph, &new_filename)).unwrap();
            conn.execute("UPDATE cards SET is_learning = TRUE WHERE hieroglyph = ?1", [&hieroglyph]).unwrap();
        }),
    );
}

impl WidgetImpl for MemoryCardsEditScene {}

impl WindowImpl for MemoryCardsEditScene {}

impl ApplicationWindowImpl for MemoryCardsEditScene {}