use crate::viewmodel::Error;
use crate::view::telephone::{self,TelephoneView};
use std::collections::HashSet;
use super::WeakComponentLink;
use super::name::{self,NameView};
use super::address::{self,AddressView};
use genpdf::Element as _;
use genpdf::{elements, style, fonts};
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use yew::prelude::*;
use vcard::properties;
use vcard::{VCard, VCardError};
use crate::viewmodel::utility::*;


pub struct MainView {
    link: ComponentLink<Self>,
    error: Option<Error>,
    download: Option<Download>,
    selected_option: DownloadOption,
    vcard: Option<VCard>,

    name_links: Vec<WeakComponentLink<NameView>>,
    address_links: Vec<WeakComponentLink<AddressView>>,
    telephone_links: Vec<WeakComponentLink<TelephoneView>>,

    answer_count: usize,
}

pub enum Msg {
    AddName,
    AddAddress,
    AddTelephone,

    ChangeDownloadOption(DownloadOption),

    Generate,
    GeneratedFormattedName(Result<properties::FormattedName,()>),
    GeneratedName(Result<properties::Name,()>),
    GeneratedAddress(Result<properties::Address,()>),
    GeneratedTelephone(Result<properties::Telephone,()>),
    GenerationComplete,

    Nope,
}

impl Component for MainView {
    type Message = Msg;
    type Properties = ();

    fn create(_props: Self::Properties, link: ComponentLink<Self>) -> Self {
        MainView { 
            link, 
            error: None, 
            download: None, 
            selected_option: DownloadOption::VCard,
            vcard: None,

            name_links: vec![WeakComponentLink::default()],
            address_links: vec![WeakComponentLink::default()],
            telephone_links: vec![WeakComponentLink::default()],
            answer_count: 0,
        }
    }

    fn update(&mut self, msg: Self::Message) -> ShouldRender {
        let shouldrender; // let the compiler check if it is always set
        self.error = None;

        match msg {
            Msg::AddName => {
                self.name_links.push(WeakComponentLink::default());
                shouldrender = true;
            },
            Msg::AddAddress => {
                self.address_links.push(WeakComponentLink::default());
                shouldrender = true;
            },
            Msg::AddTelephone => {
                self.telephone_links.push(WeakComponentLink::default());
                shouldrender = true;
            },
            Msg::ChangeDownloadOption(option) => {
                self.selected_option = option;
                shouldrender = false;
            },
            Msg::Generate => {

                if self.selected_option == DownloadOption::VCard || self.selected_option == DownloadOption::QrCode {

                    for name_link in self.name_links.iter() {
                        let name_link = name_link.borrow().clone().unwrap();
                        name_link.send_message(name::Msg::Generate);
                    }

                    for address_link in self.address_links.iter() {
                        let address_link = address_link.borrow().clone().unwrap();
                        address_link.send_message(address::Msg::Generate);
                    }

                    for telephone_link in self.telephone_links.iter() {
                        let telephone_link = telephone_link.borrow().clone().unwrap();
                        telephone_link.send_message(telephone::Msg::Generate);
                    }
                }
                /*
                    DownloadOption::PDF => {
                        match self.generate_pdf() {
                            Ok(pdf) => self.download = Some(
                                Download {
                                    file_name: format!("Visitenkarten {}.pdf", self.name.formatted_name()),
                                    content: pdf,
                                    mime_type: MimeType::PDF,
                                }
                            ),
                            Err(_) => self.error.push(String::from("Unexpected error while generating the PDF. Please contact me about it.")),
                        }
                    }
                }
                */

                shouldrender = true;
            },
            Msg::GeneratedFormattedName(formatted_name) => {

                self.answer_count += 1;

                match formatted_name {
                    Ok(formatted_name) => {
                        match &mut self.vcard {
                            None => {
                                match VCard::from_formatted_name(formatted_name) {
                                    Ok(vcard) => self.vcard = Some(vcard),
                                    Err(VCardError::FormatError(err)) => {
                                        self.error = Some(Error{
                                            msg: err.to_string(),
                                        });
                                    },
                                    Err(VCardError::EmptyFormatName) => {
                                        self.error= Some(Error{
                                            msg: String::from("At least one of the name fields should be filled out."),
                                        });
                                    },
                                };
                            },
                            Some(vcard) => {
                                vcard.formatted_names.insert(formatted_name);
                            },
                        };
                    },
                    Err(_) => (),
                };

                shouldrender = true;
            },
            Msg::GeneratedName(name) => {

                self.answer_count += 1;

                match name {
                    Ok(name) => {
                        match self.vcard {
                            Some(vcard) => {
                                match vcard.names {
                                    Some(names) => {
                                        names.insert(name);
                                    },
                                    None => {
                                        let names = {
                                            let mut names = HashSet::new();
                                            names.insert(name);
                        
                                            names
                                        };
            
                                        vcard.names = Some(vcard::Set::from_hash_set(names).unwrap());
                                    }
                                };
                            },
                            None => (),
                        };
                    },
                    Err(_) => (),
                };

                shouldrender = true;

            },
            Msg::GeneratedAddress(address) => {

                self.answer_count += 1;

                match address {
                    Ok(address) => {
                        match self.vcard {
                            Some(vcard) => {
                                match vcard.addresses {
                                    Some(addresses) => {
                                        addresses.insert(address);
                                    },
                                    None => {
                                        let addresses = {
                                            let mut addresses = HashSet::new();
                                            addresses.insert(address);
                        
                                            addresses
                                        };
        
                                        vcard.addresses = Some(vcard::Set::from_hash_set(addresses).unwrap());
                                    }
                                };
                            },
                            None => (),
                        };
                    },
                    Err(_) => (),
                };

                shouldrender = true;
            },
            Msg::GeneratedTelephone(telephone) => {

                self.answer_count += 1;

                match telephone {
                    Ok(telephone) => {
                        match self.vcard {
                            Some(vcard) => {
                                match vcard.telephones {
                                    Some(telephones) => {
                                        telephones.insert(telephone);
                                    },
                                    None => {
                                        let telephones = {
                                            let mut telephones = HashSet::new();
                                            telephones.insert(telephone);
                                            
                                            telephones
                                        };
                        
                                        vcard.telephones = Some(vcard::Set::from_hash_set(telephones).unwrap());
                                    }
                                };
                            },
                            None => (),
                        };        
                    },
                    Err(_) => (),
                }

                shouldrender = true;
            },
            Msg::GenerationComplete => {

                self.answer_count = 0;

                match self.vcard.clone() {
                    Some(vcard) => {
                        match self.selected_option {
                            DownloadOption::VCard => {
                                self.download = Some(
                                    Download {
                                        file_name: String::from("VCard.vcs"),
                                        content: vcard.to_string(),
                                        mime_type: MimeType::VCard,
                                    }
                                );
                            },
                            DownloadOption::QrCode => {
                                match QrCode::encode_text(&vcard.to_string(), QrCodeEcc::Low) {
                                    Ok(qr) => self.download = Some(
                                        Download {
                                            file_name: String::from("QR-Code VCard.svg"),
                                            content: qr.to_svg_string(4),
                                            mime_type: MimeType::SVG,
                                        }
                                    ),
                                    Err(_) => self.error = Some(
                                        Error{
                                            msg: String::from("Sorry, VCard is too long!"),
                                        }
                                    ),
                                };
                            },
                            _ => (),
                        };
                    
                        self.vcard = None;
                        shouldrender = true;
                    },
                    None => shouldrender = false, // what TODO here?
                }

            },
            Msg::Nope => shouldrender = false,
        };

        if self.answer_count >= self.get_subcomponent_count() {
            self.link.send_message(Msg::GenerationComplete);
        }
        if self.error.is_some() {
            self.download = None;
        }
        
        shouldrender
    }

    fn change(&mut self, _props: Self::Properties) -> ShouldRender {
        false
    }

    fn view(&self) -> Html {

        let download_options = self.link.callback(|e: ChangeData|
            match e {
                ChangeData::Select(v) => match v.value().as_str() {
                    "vcard" => Msg::ChangeDownloadOption(DownloadOption::VCard),
                    "pdf" => Msg::ChangeDownloadOption(DownloadOption::PDF),
                    "qrcode" => Msg::ChangeDownloadOption(DownloadOption::QrCode),
                    _ => Msg::Nope,
                },
                _ => Msg::Nope,
            }
        );

        html!{
            <>
                <main>
                    <section class="hero">
                        <div class="hero-body">
                            <div class="container is-max-widescreen">
                                <h1 class="title">{ "A Generator for vCards" }</h1>
                                <h2 class="subtitle">{ "Supports generating vCards (.vcf), print-ready PDF business cards and QR Codes" }</h2>
                            </div>
                        </div>
                    </section>

                    <section class="section">
                        <div class="container is-max-widescreen">

                            { self.render_error() }

                            {
                                for self.name_links.iter().map(|link|
                                    html!{
                                        <NameView   weak_link=link 
                                                    generated_fn=self.link.callback(
                                                        |fmn: Result<properties::FormattedName,()>| 
                                                            Msg::GeneratedFormattedName(fmn)
                                                    )
                                                    generated_name=self.link.callback(
                                                        |n: Result<properties::Name,()>| 
                                                            Msg::GeneratedName(n)
                                                    )
                                        />
                                    }
                                )
                            }

                            {
                                for self.address_links.iter().map(|link|
                                    html!{
                                        <AddressView    weak_link=link
                                                        generated=self.link.callback(
                                                            |a: Result<properties::Address,()>|
                                                                Msg::GeneratedAddress(a)
                                                        )
                                        />
                                    }
                                )
                            }

                            {
                                for self.telephone_links.iter().map(|link|
                                    html!{
                                        <TelephoneView  weak_link=link
                                                        generated=self.link.callback(
                                                            |t: Result<properties::Telephone,()>|
                                                                Msg::GeneratedTelephone(t)
                                                        )
                                        />
                                    }
                                )
                            }

                            <div class="block level-left">
                                <button onclick=self.link.callback(|_| Msg::Generate) class="button is-primary level-item" />

                                <div class="select level-item">
                                    <select id="download_options" onchange=download_options>
                                        <option value="vcard">{ "VCard (.vcf)" }</option>
                                        <option value="pdf">{ "Print-ready PDF" }</option>
                                        <option value="qrcode">{ "QR Code" }</option>
                                    </select>
                                </div>
                                
                                { self.render_download() }
                            </div>

                            <div class="block">
                                { self.render_preview() }
                            </div>

                        </div>
                    </section>
                </main>

                <footer class="footer">
                    <div class="content has-text-centered">
                        <p>
                            <strong>{ "VCard Generator" }</strong> { " by " } <a href="https://jelemux.dev">{ "Jeremias Weber" }</a>{ ". "}
                            { "The source code is licenced " } <a href="http://opensource.org/licenses/mit-license.php">{ "MIT" }</a>{"."}
                        </p>
                    </div>
                </footer>
            </>
        }
    }
}

impl MainView {
    fn render_error(&self) -> Html {
        html!{
            <>
                {
                    match &self.error {
                        Some(error) => {
                            html!{
                                <div class="notification is-danger is-light">
                                    { error.msg.clone() }
                                </div>
                            }
                        },
                        None => html!{},
                    }
                }
            </>
        }
    }
    fn render_download(&self) -> Html {
        if self.download.is_some() {
            let download = self.download.as_ref().unwrap();

            html!{
                <a href=download.as_data_link() download=download.file_name class="button is-success level-item" >
                    { "Download" }
                </a>
            }
        } else {
            html!{}
        }
    }
    fn render_preview(&self) -> Html {
        if self.download.is_some() {
            let download = self.download.as_ref().unwrap();

            match download.mime_type {
                MimeType::PDF => html!{
                    <iframe src=download.as_data_link() alt="PDF Preview" width="400" height="550"/>
                },
                MimeType::VCard => {
                    html!{
                        <pre>
                            <code> { download.content.clone() } </code>
                        </pre>
                    }
                }
                MimeType::SVG => html!{
                    <img src=download.as_data_link() alt="Image Preview" class="image is-square" width="300" height="300"/>
                },
            }
        } else {
            html!{}
        }
    }
    fn generate_pdf(&self) -> Result<String, ()>{
        let regular_bytes = include_bytes!("/usr/share/fonts/liberation/LiberationSans-Regular.ttf");
        let regular_font_data = fonts::FontData::new(regular_bytes.to_vec(), Some(printpdf::BuiltinFont::Helvetica)).expect("font data should be correct");

        let bold_bytes = include_bytes!("/usr/share/fonts/liberation/LiberationSans-Bold.ttf");
        let bold_font_data = fonts::FontData::new(bold_bytes.to_vec(), Some(printpdf::BuiltinFont::HelveticaBold)).expect("font data should be correct");

        let italic_bytes = include_bytes!("/usr/share/fonts/liberation/LiberationSans-Italic.ttf");
        let italic_font_data = fonts::FontData::new(italic_bytes.to_vec(), Some(printpdf::BuiltinFont::HelveticaOblique)).expect("font data should be correct");

        let bold_italic_bytes = include_bytes!("/usr/share/fonts/liberation/LiberationSans-BoldItalic.ttf");
        let bold_italic_font_data = fonts::FontData::new(bold_italic_bytes.to_vec(), Some(printpdf::BuiltinFont::HelveticaBoldOblique)).expect("font data should be correct");

        let font_family = fonts::FontFamily{ 
            regular: regular_font_data, 
            bold: bold_font_data, 
            italic: italic_font_data, 
            bold_italic: bold_italic_font_data 
        };

        let mut doc = genpdf::Document::new(font_family);

        doc.set_title("BCard test");
        doc.set_minimal_conformance();
        
        let mut decorator = genpdf::SimplePageDecorator::new();
        decorator.set_margins(10);
        doc.set_page_decorator(decorator);
        
        doc.set_line_spacing(1.25);

        doc.push(
            elements::Paragraph::new("genpdf Demo Document")
                .aligned(elements::Alignment::Center)
                .styled(style::Style::new().bold().with_font_size(20)),
        );

        // TODO fill doc with real data

        let mut buf: Vec<u8> = Vec::new();
        match doc.render(&mut buf) {
            Ok(_) => Ok(match String::from_utf8(buf) {
                Ok(s) => s,
                Err(_) => return Err(()),
            }),
            Err(_) => Err(()),
        }
    }
    fn get_subcomponent_count(&self) -> usize {
        self.name_links.len()
        + self.address_links.len()
        + self.telephone_links.len()
    }
}