use std::{borrow::BorrowMut, sync::Arc};

use gtk::prelude::*;
use relm4::{
    component::{AsyncComponent, AsyncComponentParts},
    prelude::*,
    AsyncComponentSender,
};

use crate::{database::Database, sheet::Sheet, sheet_dao};

pub struct SheetEditDialogModel {
    database: Arc<Database>,
    hidden: bool,
    sheet: Option<Sheet>,
    sheet_name: String,
    sheet_composer: String,
    is_book: bool,
    book_sheets: Vec<(String, String, i64)>,
}

pub struct SheetEditDialogInit {
    pub database: Arc<Database>,
    pub sheet: Sheet,
}

#[derive(Debug)]
pub enum SheetEditDialogInput {
    Accept,
    Cancel,
}

#[derive(Debug)]
pub enum SheetEditDialogOutput {
    SheetEdited(Sheet),
}

#[relm4::component(pub, async)]
impl AsyncComponent for SheetEditDialogModel {
    type Init = SheetEditDialogInit;
    type Input = SheetEditDialogInput;
    type Output = SheetEditDialogOutput;
    type CommandOutput = ();

    view! {
        gtk::Window {
            #[watch]
            set_visible: !model.hidden,
            set_modal: true,
            set_title: Some("Edit sheet"),
            gtk::Box {
                set_orientation: gtk::Orientation::Vertical,
                set_margin_all : 5,
                gtk::Label {
                    set_text: "Sheet name"
                },
                gtk::Entry {
                    #[watch]
                    set_text: &model.sheet_name,
                },
                gtk::Label {
                    set_text: "Sheet composer"
                },
                gtk::Entry {
                    #[watch]
                    set_text : &model.sheet_composer,
                },
                gtk::Label {
                    set_text: "Book"
                },
                gtk::CheckButton {
                    #[watch]
                    set_active: model.is_book,
                },
                gtk::Box {
                    set_orientation: gtk::Orientation::Horizontal,
                    set_margin_top:5,
                    gtk::Button {
                        set_label : "Confirm",
                        connect_clicked[sender] => move |_| sender.input(SheetEditDialogInput::Accept)
                    },
                    gtk::Button {
                        set_label: "Cancel",
                        connect_clicked[sender] => move |_| sender.input(SheetEditDialogInput::Cancel)
                    }
                }
            }
        }
    }

    async fn init(
        params: Self::Init,
        root: Self::Root,
        sender: AsyncComponentSender<Self>,
    ) -> AsyncComponentParts<Self> {
        let sheet = params.sheet;
        let mut sheet_name = String::new();
        let mut sheet_composer = String::new();
        let mut is_book = false;

        match &sheet.kind {
            crate::sheet::SheetKind::Sheet {
                name, composer_id, ..
            } => {
                sheet_name = name.to_string();
                if let Ok(composer) =
                    sheet_dao::get_composer_by_id(&params.database, *composer_id).await
                {
                    sheet_composer = composer.name;
                }
            }
            crate::sheet::SheetKind::Orphan => {
                sheet_name = sheet.pdf.get_name().to_string();
            }
            crate::sheet::SheetKind::Book {
                name,
                composer_id,
                sheet_ids,
            } => {
                is_book = true;
                sheet_name = name.to_string();
                if let Ok(composer) =
                    sheet_dao::get_composer_by_id(&params.database, *composer_id).await
                {
                    sheet_composer = composer.name;
                }
                // TODO: load sheets of book
            }
        };

        let model = SheetEditDialogModel {
            database: params.database,
            hidden: false,
            sheet: Some(sheet),
            sheet_name,
            sheet_composer,
            is_book,
            book_sheets: Vec::new(),
        };
        let widgets = view_output!();

        AsyncComponentParts { model, widgets }
    }

    // TODO: init_loading_widgets

    async fn update(
        &mut self,
        msg: Self::Input,
        sender: AsyncComponentSender<Self>,
        _root: &Self::Root,
    ) {
        match msg {
            SheetEditDialogInput::Accept => {
                self.hidden = true;

                if let Some(mut sheet) = self.sheet.take() {
                    //     match sheet.kind.borrow_mut() {
                    //         crate::sheet::SheetKind::Sheet {
                    //             name,
                    //             composer_id,
                    //             first_page,
                    //             book_id,
                    //         } => {
                    //             todo!("Do something!!!");
                    //             // name = "hello world";
                    //             // name = &mut self.sheet_name.clone();
                    //             // composer_id = 0;
                    //         }
                    //         crate::sheet::SheetKind::Orphan => {
                    //             todo!("Create Sheet");
                    //         }
                    //         crate::sheet::SheetKind::Book {
                    //             name,
                    //             composer_id,
                    //             sheet_ids,
                    //         } => todo!(),
                    //     };
                    sender
                        .output(SheetEditDialogOutput::SheetEdited(sheet))
                        .unwrap();
                }
            }
            SheetEditDialogInput::Cancel => {
                self.hidden = true;
                self.sheet = None;
            }
        }
    }
}