use std::{io, path::PathBuf};

use cosmic::{
    dialog::file_chooser::open::Dialog,
    iced::{
        font::{Family, Stretch, Style, Weight},
        Font, Length,
    },
    iced_wgpu::graphics::text::cosmic_text::fontdb,
    iced_widget::{row, stack},
    theme,
    widget::{
        button, column, combo_box, container, dropdown,
        horizontal_space, icon, scrollable, svg::Handle, text,
        text_editor, text_input, Svg,
    },
    Element, Task,
};
use dirs::font_dir;
use iced_video_player::Video;
use tracing::{debug, error};

use crate::{
    core::{service_items::ServiceTrait, songs::Song},
    Background, BackgroundKind,
};

use super::presenter::slide_view;

#[derive(Debug)]
pub struct SongEditor {
    pub song: Option<Song>,
    title: String,
    font_db: fontdb::Database,
    fonts: Vec<(fontdb::ID, String)>,
    fonts_combo: combo_box::State<String>,
    font_sizes: combo_box::State<String>,
    font: String,
    author: String,
    audio: PathBuf,
    font_size: usize,
    verse_order: String,
    pub lyrics: text_editor::Content,
    editing: bool,
    background: Option<Background>,
    video: Option<Video>,
    current_font: Font,
    ccli: String,
}

pub enum Action {
    Task(Task<Message>),
    UpdateSong(Song),
    None,
}

#[derive(Debug, Clone)]
pub enum Message {
    ChangeSong(Song),
    UpdateSong(Song),
    ChangeFont(String),
    ChangeFontSize(usize),
    ChangeTitle(String),
    ChangeVerseOrder(String),
    ChangeLyrics(text_editor::Action),
    ChangeBackground(Result<PathBuf, SongError>),
    PickBackground,
    Edit(bool),
    None,
    ChangeAuthor(String),
}

impl SongEditor {
    pub fn new() -> Self {
        let fonts = font_dir();
        debug!(?fonts);
        let mut font_db = fontdb::Database::new();
        font_db.load_system_fonts();
        let mut fonts: Vec<(fontdb::ID, String)> = font_db
            .faces()
            .map(|f| {
                let id = f.id;
                let font_base_name: String =
                    f.families.iter().map(|f| f.0.clone()).collect();
                let font_weight = f.weight;
                let font_style = f.style;
                let font_stretch = f.stretch;
                (id, font_base_name)
            })
            .collect();
        fonts.dedup();
        // let fonts = vec![
        //     String::from("Quicksand"),
        //     String::from("Noto Sans"),
        // ];
        let font_sizes = vec![
            "5".to_string(),
            "6".to_string(),
            "8".to_string(),
            "10".to_string(),
            "12".to_string(),
            "16".to_string(),
            "18".to_string(),
            "20".to_string(),
            "24".to_string(),
            "28".to_string(),
            "32".to_string(),
            "36".to_string(),
            "40".to_string(),
            "48".to_string(),
            "50".to_string(),
            "55".to_string(),
            "60".to_string(),
            "65".to_string(),
            "70".to_string(),
            "80".to_string(),
        ];
        let font_texts = fonts.iter().map(|f| f.1.clone()).collect();
        Self {
            song: None,
            font_db,
            fonts,
            fonts_combo: combo_box::State::new(font_texts),
            title: "Death was Arrested".to_owned(),
            font: "Quicksand".to_owned(),
            font_size: 16,
            font_sizes: combo_box::State::new(font_sizes),
            verse_order: "Death was Arrested".to_owned(),
            lyrics: text_editor::Content::new(),
            editing: false,
            author: "North Point Worship".into(),
            audio: PathBuf::new(),
            background: None,
            video: None,
            current_font: cosmic::font::default(),
            ccli: "8".to_owned(),
        }
    }
    pub fn update(&mut self, message: Message) -> Action {
        match message {
            Message::ChangeSong(song) => {
                self.song = Some(song.clone());
                self.title = song.title;
                if let Some(font) = song.font {
                    self.font = font
                };
                if let Some(font_size) = song.font_size {
                    self.font_size = font_size as usize
                };
                if let Some(verse_order) = song.verse_order {
                    self.verse_order = verse_order
                        .into_iter()
                        .map(|mut s| {
                            s.push(' ');
                            s
                        })
                        .collect();
                }
                if let Some(author) = song.author {
                    self.author = author
                };
                if let Some(audio) = song.audio {
                    self.audio = audio
                };
                if let Some(ccli) = song.ccli {
                    self.ccli = ccli
                };
                if let Some(lyrics) = song.lyrics {
                    self.lyrics =
                        text_editor::Content::with_text(&lyrics)
                };
                self.background_video(&song.background);
                self.background = song.background;
            }
            Message::ChangeFont(font) => {
                let font_id = self
                    .fonts
                    .iter()
                    .filter(|f| f.1 == font)
                    .map(|f| f.0)
                    .next();
                if let Some(id) = font_id {
                    if let Some(face) = self.font_db.face(id) {
                        self.font = face.post_script_name.clone();
                        // self.current_font = Font::from(face);
                    }
                }
                self.font = font.clone();

                let font_name = font.into_boxed_str();
                let family = Family::Name(Box::leak(font_name));
                let weight = Weight::Bold;
                let stretch = Stretch::Normal;
                let style = Style::Normal;
                let font = Font {
                    family,
                    weight,
                    stretch,
                    style,
                };
                self.current_font = font;
                // return self.update_song(song);
            }
            Message::ChangeFontSize(size) => self.font_size = size,
            Message::ChangeTitle(title) => {
                self.title = title.clone();
                if let Some(song) = &mut self.song {
                    song.title = title;
                    let song = song.to_owned();
                    return self.update_song(song);
                }
            }
            Message::ChangeVerseOrder(verse_order) => {
                self.verse_order = verse_order.clone();
                if let Some(mut song) = self.song.clone() {
                    let verse_order = verse_order
                        .split(" ")
                        .map(|s| s.to_owned())
                        .collect();
                    song.verse_order = Some(verse_order);
                    return self.update_song(song);
                }
            }
            Message::ChangeLyrics(action) => {
                self.lyrics.perform(action);

                let lyrics = self.lyrics.text();

                if let Some(mut song) = self.song.clone() {
                    song.lyrics = Some(lyrics);
                    return self.update_song(song);
                }
            }
            Message::Edit(edit) => {
                debug!(edit);
                self.editing = edit;
            }
            Message::ChangeAuthor(author) => {
                debug!(author);
                self.author = author.clone();
                if let Some(mut song) = self.song.clone() {
                    song.author = Some(author);
                    return self.update_song(song);
                }
            }
            Message::ChangeBackground(Ok(path)) => {
                debug!(?path);
                if let Some(mut song) = self.song.clone() {
                    let background =
                        Background::try_from(path.clone()).ok();
                    self.background_video(&background);
                    song.background = background;
                    return self.update_song(song);
                }
            }
            Message::ChangeBackground(Err(error)) => {
                error!(?error);
            }
            Message::PickBackground => {
                return Action::Task(Task::perform(
                    pick_background(),
                    Message::ChangeBackground,
                ))
            }
            _ => (),
        }
        Action::None
    }

    pub fn view(&self) -> Element<Message> {
        let slide_preview = container(self.slide_preview())
            .width(Length::FillPortion(2));

        let column = column::with_children(vec![
            self.toolbar(),
            row![
                container(self.left_column())
                    .center_x(Length::FillPortion(2)),
                container(slide_preview)
                    .center_x(Length::FillPortion(3))
            ]
            .into(),
        ])
        .spacing(theme::active().cosmic().space_l());
        column.into()
    }

    fn slide_preview(&self) -> Element<Message> {
        if let Some(song) = &self.song {
            if let Ok(slides) = song.to_slides() {
                let slides = slides
                    .into_iter()
                    .enumerate()
                    .map(|(index, slide)| {
                        container(
                            slide_view(
                                slide,
                                if index == 0 {
                                    &self.video
                                } else {
                                    &None
                                },
                                self.current_font,
                                false,
                                false,
                            )
                            .map(|_| Message::None),
                        )
                        .height(250)
                        .center_x(Length::Fill)
                        .padding([0, 20])
                        .clip(true)
                        .into()
                    })
                    .collect();
                scrollable(
                    column::with_children(slides)
                        .spacing(theme::active().cosmic().space_l()),
                )
                .height(Length::Fill)
                .width(Length::Fill)
                .into()
            } else {
                horizontal_space().into()
            }
        } else {
            horizontal_space().into()
        }
    }

    fn left_column(&self) -> Element<Message> {
        let title_input = text_input("song", &self.title)
            .on_input(Message::ChangeTitle)
            .label("Song Title");

        let author_input = text_input("author", &self.author)
            .on_input(Message::ChangeAuthor)
            .label("Song Author");

        let verse_input = text_input(
            "Verse
order",
            &self.verse_order,
        )
        .label("Verse Order")
        .on_input(Message::ChangeVerseOrder);

        let lyric_title = text("Lyrics");
        let lyric_input = column::with_children(vec![
            lyric_title.into(),
            text_editor(&self.lyrics)
                .on_action(Message::ChangeLyrics)
                .height(Length::Fill)
                .into(),
        ])
        .spacing(5);

        column::with_children(vec![
            title_input.into(),
            author_input.into(),
            verse_input.into(),
            lyric_input.into(),
        ])
        .spacing(25)
        .width(Length::FillPortion(2))
        .into()
    }

    fn toolbar(&self) -> Element<Message> {
        let selected_font = &self.font;
        let selected_font_size = {
            let font_size_position = self
                .font_sizes
                .options()
                .iter()
                .position(|s| *s == self.font_size.to_string());
            self.font_sizes
                .options()
                .get(font_size_position.unwrap_or_default())
        };
        let font_selector = combo_box(
            &self.fonts_combo,
            "Font",
            Some(selected_font),
            Message::ChangeFont,
        )
        .width(200);
        let font_size = combo_box(
            &self.font_sizes,
            "Font Size",
            selected_font_size,
            |size| {
                Message::ChangeFontSize(
                    size.parse().expect("Should be a number"),
                )
            },
        )
        .width(theme::active().cosmic().space_xxl());

        let background_selector = button::icon(
            icon::from_name("folder-pictures-symbolic").scale(2),
        )
        .label("Background")
        .tooltip("Select an image or video background")
        .on_press(Message::PickBackground)
        .padding(10);

        row![
            font_selector,
            font_size,
            horizontal_space(),
            background_selector
        ]
        .spacing(10)
        .into()
    }

    pub fn editing(&self) -> bool {
        self.editing
    }

    fn update_song(&mut self, song: Song) -> Action {
        self.song = Some(song.clone());
        Action::UpdateSong(song)
    }

    fn background_video(&mut self, background: &Option<Background>) {
        if let Some(background) = background {
            if background.kind == BackgroundKind::Video {
                let video =
                    Video::try_from(background).ok().map(|mut v| {
                        v.set_looping(true);
                        v
                    });
                debug!(?video);
                self.video = video;
            }
        }
    }
}

impl Default for SongEditor {
    fn default() -> Self {
        Self::new()
    }
}

async fn pick_background() -> Result<PathBuf, SongError> {
    let dialog = Dialog::new().title("Choose a background...");
    dialog
        .open_file()
        .await
        .map_err(|_| SongError::DialogClosed)
        .map(|file| file.url().to_file_path().unwrap())
    // rfd::AsyncFileDialog::new()
    //     .set_title("Choose a background...")
    //     .pick_file()
    //     .await
    //     .ok_or(SongError::DialogClosed)
    //     .map(|file| file.path().to_owned())
}

#[derive(Debug, Clone)]
pub enum SongError {
    DialogClosed,
    IOError(io::ErrorKind),
}