#[cxx_qt::bridge]
pub mod slide_object {
    unsafe extern "C++" {
        include!("cxx-qt-lib/qstring.h");
        type QString = cxx_qt_lib::QString;
        include!("cxx-qt-lib/qmap.h");
        type QMap_QString_QVariant =
            cxx_qt_lib::QMap<cxx_qt_lib::QMapPair_QString_QVariant>;
        // include!("cxx-qt-gen/slide_model.cxxqt.h");
        // type SlideModel = crate::slide_model::slide_model::SlideModel;
    }

    unsafe extern "RustQt" {
        #[qsignal]
        fn playing_changed(
            self: Pin<&mut SlideObject>,
            is_playing: bool,
        );
        // #[qsignal]
        // fn slide_index_changed(
        //     self: Pin<&mut SlideObject>,
        //     slide_index: i32,
        // );
        // #[qsignal]
        // fn slide_size_changed(
        //     self: Pin<&mut SlideObject>,
        //     slide_size: i32,
        // );
        #[qsignal]
        fn slide_changed(self: Pin<&mut SlideObject>, slide: i32);
        #[qsignal]
        fn loop_changed(self: Pin<&mut SlideObject>, looping: bool);
        #[qsignal]
        fn reveal_next(self: Pin<&mut SlideObject>);
        #[qsignal]
        fn reveal_prev(self: Pin<&mut SlideObject>);

        #[qobject]
        #[qml_element]
        #[qproperty(i32, slide_index)]
        #[qproperty(i32, slide_size)]
        #[qproperty(i32, inner_slide_index)]
        #[qproperty(bool, is_playing)]
        #[qproperty(bool, looping)]
        #[qproperty(QString, text)]
        #[qproperty(QString, ty)]
        #[qproperty(QString, audio)]
        #[qproperty(QString, image_background)]
        #[qproperty(QString, video_background)]
        #[qproperty(bool, html)]
        #[qproperty(QString, vtext_alignment)]
        #[qproperty(QString, htext_alignment)]
        #[qproperty(QString, font)]
        #[qproperty(i32, font_size)]
        #[qproperty(f32, video_start_time)]
        #[qproperty(f32, video_end_time)]
        // #[qproperty(*mut SlideModel, slide_model)]
        type SlideObject = super::SlideObjectRust;

        #[qinvokable]
        fn change_slide(
            self: Pin<&mut SlideObject>,
            item: QMap_QString_QVariant,
            index: i32,
        );
        #[qinvokable]
        fn next(
            self: Pin<&mut SlideObject>,
            next_item: QMap_QString_QVariant,
        ) -> bool;
        #[qinvokable]
        fn previous(
            self: Pin<&mut SlideObject>,
            next_item: QMap_QString_QVariant,
        ) -> bool;
        #[qinvokable]
        pub fn play(self: Pin<&mut SlideObject>) -> bool;
        #[qinvokable]
        pub fn pause(self: Pin<&mut SlideObject>) -> bool;
        #[qinvokable]
        pub fn play_pause(self: Pin<&mut SlideObject>) -> bool;
    }
}

use std::pin::Pin;

use cxx_qt::CxxQtType;
use cxx_qt_lib::{CaseSensitivity, QString, QVariant};
use tracing::{debug, error};

use crate::{
    slide_model::{slide_model, Slide}, slide_types::SlideType
};

use self::slide_object::QMap_QString_QVariant;

#[derive(Clone, Debug)]
pub struct SlideObjectRust {
    slide_index: i32,
    slide_size: i32,
    inner_slide_index: i32,
    is_playing: bool,
    looping: bool,
    text: QString,
    ty: QString,
    audio: QString,
    image_background: QString,
    video_background: QString,
    html: bool,
    vtext_alignment: QString,
    htext_alignment: QString,
    font: QString,
    font_size: i32,
    video_start_time: f32,
    video_end_time: f32,
    // slide_model: *mut slide_model::SlideModel,
}

impl Default for SlideObjectRust {
    fn default() -> Self {
        Self {
            slide_index: 0,
            slide_size: 0,
            is_playing: false,
            looping: false,
            text: QString::from(""),
            ty: QString::from(""),
            audio: QString::from(""),
            image_background: QString::from(""),
            html: false,
            video_background: QString::from(""),
            vtext_alignment: QString::from(""),
            htext_alignment: QString::from(""),
            font: QString::from(""),
            font_size: 50,
            inner_slide_index: 0,
            video_start_time: 0.0,
            video_end_time: 0.0,
            // slide_model: std::ptr::null_mut(),
        }
    }
}

impl slide_object::SlideObject {
    pub fn change_slide(
        mut self: Pin<&mut Self>,
        item: QMap_QString_QVariant,
        slide_index: i32,
    ) {
        // This function will grab the item from the relevant model
        // and load it into the slide_object
        let kind = item
            .get(&QString::from("type"))
            .unwrap_or(QVariant::from(&QString::default()))
            .value()
            .unwrap_or(QString::default());
        match SlideType::try_from(kind) {
            Ok(st) => {
                debug!(kind = ?st, "Changing slide");
                // let slide = match st {
                //     SlideType::Song => {
                //         SongModel::get_item(slide_index)
                //     }
                //     SlideType::Image => {
                //         ImageModel::get_item(slide_index)
                //     }
                //     SlideType::Video => {
                //         VideoModel::get_item(slide_index)
                //     }
                //     SlideType::Presentation(_) => {
                //         PresentationModel::get_item(slide_index)
                //     }
                //     SlideType::Content => {
                //         PresentationModel::get_item(slide_index)
                //     }
                // };
                // debug!(slide);
            }
            Err(e) => error!(?e),
        }

        let _current_index = self.as_ref().get_ref().slide_index();
        let icount_variant = item
            .get(&QString::from("imageCount"))
            .unwrap_or(QVariant::from(&1));
        let _count =
            icount_variant.value::<i32>().unwrap_or_default();

        let slindex = item
            .get(&QString::from("slideIndex"))
            .unwrap_or(QVariant::from(&0));
        let inner_slide_index =
            slindex.value::<i32>().unwrap_or_default();

        //     if html {
        //         debug!(?html, count, slide_index);
        //         if slide_index > 0 && slide_index < count - 1 {
        //             if current_index < &index {
        //                 self.as_mut().reveal_next();
        //                 debug!("RevealNext");
        //                 return;
        //             } else if slide_index > 0 {
        //                 self.as_mut().reveal_prev();
        //                 debug!("RevealPrev");
        //                 return;
        //             }
        //         }
        //     }
        // }
        debug!(slide_index, inner_slide_index, "Changing slide");

        println!("## Slide Details ##");
        let text = item
            .get(&QString::from("text"))
            .unwrap_or(QVariant::from(&QString::from("")));
        if let Some(txt) = text.value::<QString>() {
            if &txt != self.as_ref().text() {
                println!("text: {txt}");
                self.as_mut().set_text(txt);
            };
        } else {
            println!("text: empty");
        }
        let audio = item
            .get(&QString::from("audio"))
            .unwrap_or(QVariant::from(&QString::from("")));
        if let Some(audio) = audio.value::<QString>() {
            if &audio != self.as_ref().audio() {
                println!("audio: {audio}");
                self.as_mut().set_audio(audio);
            }
        } else {
            println!("audio: empty");
        }
        let ty = item
            .get(&QString::from("type"))
            .unwrap_or(QVariant::from(&QString::from("")));
        if let Some(ty) = ty.value::<QString>() {
            if &ty != self.as_ref().ty() {
                println!("type: {ty}");
                self.as_mut().set_ty(ty);
            }
        } else {
            println!("type: empty");
        }

        let image_background = item
            .get(&QString::from("imageBackground"))
            .unwrap_or(QVariant::from(&QString::from("")));
        if let Some(image_background) =
            image_background.value::<QString>()
        {
            if &image_background != self.as_ref().image_background() {
                println!("image-bg: {image_background}");
                self.as_mut().set_image_background(image_background);
            }
        } else {
            println!("image-bg: empty");
        }
        let video_background = item
            .get(&QString::from("videoBackground"))
            .unwrap_or(QVariant::from(&QString::from("")));
        if let Some(video_background) =
            video_background.value::<QString>()
        {
            if &video_background != self.as_ref().video_background() {
                println!("video-bg: {video_background}");
                self.as_mut().set_video_background(video_background);
            }
        } else {
            println!("video-bg: empty");
        }
        let font = item
            .get(&QString::from("font"))
            .unwrap_or(QVariant::from(&QString::from("Quicksand")));
        if let Some(font) = font.value::<QString>() {
            if &font != self.as_ref().font() {
                println!("font: {font}");
                self.as_mut().set_font(font);
            }
        } else {
            println!("font: empty");
        }
        let vtext_alignment = item
            .get(&QString::from("verticalTextAlignment"))
            .unwrap_or(QVariant::from(&QString::from("center")));
        if let Some(vtext_alignment) =
            vtext_alignment.value::<QString>()
        {
            if &vtext_alignment != self.as_ref().vtext_alignment() {
                println!("vertical-text-align: {vtext_alignment}");
                self.as_mut().set_vtext_alignment(vtext_alignment);
            }
        } else {
            println!("vertical-text-align: empty");
        }
        let htext_alignment = item
            .get(&QString::from("horizontalTextAlignment"))
            .unwrap_or(QVariant::from(&QString::from("center")));
        if let Some(htext_alignment) =
            htext_alignment.value::<QString>()
        {
            if &htext_alignment != self.as_ref().htext_alignment() {
                println!("horizontal-text-align: {htext_alignment}");
                self.as_mut().set_htext_alignment(htext_alignment);
            }
        } else {
            println!("horizontal-text-align: empty");
        }
        let font_size = item
            .get(&QString::from("fontSize"))
            .unwrap_or(QVariant::from(&50));
        if let Some(font_size) = font_size.value::<i32>() {
            if font_size != self.as_ref().font_size {
                println!("font-size: {font_size}");
                self.as_mut().rust_mut().font_size = font_size;
            }
        } else {
            println!("font-size: empty");
        }
        let looping = item
            .get(&QString::from("looping"))
            .unwrap_or(QVariant::from(&false));
        if let Some(looping) = looping.value::<bool>() {
            if &looping != self.as_ref().looping() {
                println!("looping: {looping}");
                self.as_mut().set_looping(looping);
                let lp = looping;
                self.as_mut().loop_changed(lp)
            }
        } else {
            println!("looping: empty")
        }
        let slide_size = item
            .get(&QString::from("imageCount"))
            .unwrap_or(QVariant::from(&1));
        if let Some(slide_size) = slide_size.value::<i32>() {
            if &slide_size != self.as_ref().slide_size() {
                println!("slide-size: {slide_size}");
                self.as_mut().set_slide_size(slide_size);
            }
        }
        let video_start_time = item
            .get(&QString::from("videoStartTime"))
            .unwrap_or(QVariant::from(&0.0));
        if let Some(int) = video_start_time.value::<f32>() {
            debug!(start_time = int);
            self.as_mut().set_video_start_time(int)
        }
        let video_end_time = item
            .get(&QString::from("videoEndTime"))
            .unwrap_or(QVariant::from(&0.0));
        if let Some(int) = video_end_time.value::<f32>() {
            debug!(end_time = int);
            self.as_mut().set_video_end_time(int)
        }

        let html =
            image_background.value_or_default::<QString>().ends_with(
                &QString::from(".html"),
                CaseSensitivity::CaseInsensitive,
            );
        self.as_mut().set_html(html);

        let html = item
            .get(&QString::from("html"))
            .unwrap_or(QVariant::from(&false));
        if let Some(html) = html.value::<bool>() {
            if !html {
                self.as_mut().set_inner_slide_index(inner_slide_index)
            } else {
                self.as_mut().set_inner_slide_index(0);
            }
        }

        self.as_mut().set_slide_index(slide_index);

        // This is pointing to the slide in the overall model. So to get it
        // we need to either track the overall slide index, or get it from
        self.as_mut().slide_changed(slide_index);
        // self.as_mut().emit(Signals::SlideChanged { slide: &index });
        println!("## Slide End ##");
    }

    pub fn next(
        mut self: Pin<&mut Self>,
        next_item: QMap_QString_QVariant,
    ) -> bool {
        debug!(
            item = ?next_item.get(&QString::from("type")).unwrap().value::<QString>(),
            ibg = ?next_item.get(&QString::from("imageBackground")).unwrap().value::<QString>(),
            vbg = ?next_item.get(&QString::from("videoBackground")).unwrap().value::<QString>(),
            "advancing to next slide"
        );
        let new_id = self.as_ref().slide_index() + 1;
        let html = self.as_ref().image_background.ends_with(
            &QString::from(".html"),
            CaseSensitivity::CaseInsensitive,
        );
        // let service_item = next_item
        //     .get(&QString::from("serviceItemId"))
        //     .unwrap()
        //     .value::<i32>()
        //     .unwrap_or_default();
        if html {
            // Check to see if current slide is at the end
            // if not, advance to the next one.
            let new_inner = self.as_ref().inner_slide_index + 1;
            debug!(
                currentIndex = self.as_ref().slide_index,
                newIndex = new_id,
                inner_slide_index = new_inner,
                slide_size = self.as_ref().slide_size
            );
            if self.as_ref().slide_size > new_inner {
                // self.as_mut().set_slide_index(new_id);
                self.as_mut().set_inner_slide_index(new_inner);
                self.as_mut().reveal_next();
                debug!("returning false");
                return false;
            }
        }
        self.as_mut().set_slide_index(new_id);
        // reset to empty before change to ensure that the web source gets unloaded
        self.as_mut().set_image_background(QString::from(""));
        self.as_mut().change_slide(next_item, new_id);
        debug!(new_id, "returning true");
        true
    }
    pub fn previous(
        mut self: Pin<&mut Self>,
        prev_item: QMap_QString_QVariant,
    ) -> bool {
        debug!(
            item = ?prev_item.get(&QString::from("type")).unwrap().value::<QString>(),
            ibg = ?prev_item.get(&QString::from("imageBackground")).unwrap().value::<QString>(),
            vbg = ?prev_item.get(&QString::from("videoBackground")).unwrap().value::<QString>(),
            "backing to previous slide"
        );
        let new_id = self.as_ref().slide_index() - 1;
        let html = self.as_ref().image_background.ends_with(
            &QString::from(".html"),
            CaseSensitivity::CaseInsensitive,
        );
        if html {
            // Check to see if current slide is at the beginning
            // if not, go back to the previous one.
            let new_inner = self.as_ref().inner_slide_index - 1;
            if self.as_ref().inner_slide_index > 0 {
                self.as_mut().set_inner_slide_index(new_inner);
                self.as_mut().reveal_prev();
                return false;
            }
        }
        self.as_mut().set_slide_index(new_id);
        // reset to empty before change to ensure that the web source gets unloaded
        self.as_mut().set_image_background(QString::from(""));
        self.as_mut().change_slide(prev_item, new_id);
        true
    }
    pub fn play(mut self: Pin<&mut Self>) -> bool {
        self.as_mut().set_is_playing(true);
        self.as_mut().playing_changed(true);
        true
    }
    pub fn pause(mut self: Pin<&mut Self>) -> bool {
        self.as_mut().set_is_playing(false);
        self.as_mut().playing_changed(false);
        false
    }
    pub fn play_pause(mut self: Pin<&mut Self>) -> bool {
        let playing = *self.as_ref().is_playing();
        match playing {
            true => self.as_mut().set_is_playing(false),
            false => self.as_mut().set_is_playing(true),
        }
        self.as_mut().playing_changed(!playing);
        !playing
    }
    pub fn set_slide(mut self: Pin<&mut Self>, slide: &Slide) {
        self.as_mut().set_slide_index(slide.service_item_id);
        self.as_mut().set_slide_size(slide.slide_count);
        self.as_mut().set_looping(slide.looping);
        self.as_mut().set_text(QString::from(&slide.text));
        self.as_mut().set_ty(QString::from(&slide.ty.to_string()));
        self.as_mut().set_audio(QString::from(&slide.audio));
        self.as_mut().set_image_background(QString::from(&slide.image_background));
        self.as_mut().set_video_background(QString::from(&slide.video_background));
        self.as_mut().set_vtext_alignment(QString::from(&slide.vtext_alignment));
        self.as_mut().set_htext_alignment(QString::from(&slide.htext_alignment));
        self.as_mut().set_font(QString::from(&slide.font));
        self.as_mut().set_font_size(slide.font_size);
        self.as_mut().set_video_start_time(slide.video_start_time);
        self.as_mut().set_video_end_time(slide.video_end_time);
        self.as_mut().set_html(slide.html);
        self.as_mut().set_inner_slide_index(slide.slide_index);
        self.as_mut().set_is_playing(true);
    }
}