#![recursion_limit="1024"]
extern crate wee_alloc;
extern crate console_error_panic_hook;
use name::{NameView,Name};
use genpdf::Element as _;
use genpdf::{elements, style, fonts};
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use wasm_bindgen::prelude::*;
use yew::prelude::*;
use vcard::{VCard, VCardError};
use std::panic;

mod name;

// Use `wee_alloc` as the global allocator.
#[global_allocator]
static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;

fn init() {
    panic::set_hook(Box::new(console_error_panic_hook::hook));
}

pub struct Download {
    pub file_name: String,
    pub content: String,
    pub mime_type: MimeType,
}

impl Download {
    pub fn as_data_link(&self) -> String {
        let data = base64::encode(&*self.content);
        let uri_component: String = js_sys::encode_uri_component(&data).into();

        format!("data:{};base64,{}", self.mime_type.as_text(), uri_component)
    }
}

impl Clone for Download {
    fn clone(&self) -> Self { 
        Self {
            file_name: self.file_name.clone(),
            content: self.content.clone(),
            mime_type: self.mime_type.clone(),
        }
    }
}

pub enum MimeType {
    PDF,
    VCard,
    SVG,
}

impl MimeType {
    pub fn as_text(&self) -> &str {
        match self {
            MimeType::PDF => "application/pdf",
            MimeType::VCard => "text/vcard",
            MimeType::SVG => "image/svg+xml",
        }
    }
}

impl Clone for MimeType {
    fn clone(&self) -> Self {
        match self {
            MimeType::PDF => MimeType::PDF,
            MimeType::VCard => MimeType::VCard,
            MimeType::SVG => MimeType::SVG,
        }
    }
}

pub struct MainView {
    link: ComponentLink<Self>,
    error: Vec<String>,
    name: Name,
    download: Option<Download>,
}

pub enum Msg {
    UpdateName(Name),
    GenerateVCard,
    GeneratePdf,
    GenerateQrCode,
    Nope,
}

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

    fn create(_props: Self::Properties, link: ComponentLink<Self>) -> Self {
        MainView { link, error: vec![], name: Name::new(), download: None, }
    }

    fn update(&mut self, msg: Self::Message) -> ShouldRender {
        self.error.clear();
        match msg {
            Msg::UpdateName(value) => self.name = value,
            Msg::GenerateVCard => {
                match self.generate_vcard() {
                    Ok(vcard) => self.download = Some(
                        Download { 
                            file_name: format!("{}.vcs", self.name.formatted_name()), 
                            content: vcard.to_string(), 
                            mime_type: MimeType::VCard,
                        }
                    ),
                    Err(VCardError::FormatError(err)) => self.error.push(err.to_string()),
                    Err(VCardError::EmptyFormatName) => self.error.push(String::from("A VCard should have at least one formatted name.")),
                };
            }
            Msg::GeneratePdf => {
                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.")),
                }
            }
            Msg::GenerateQrCode => {
                let mut vcard_content = None;
                match self.generate_vcard() {
                    Ok(vcard) => vcard_content = Some(vcard.to_string()),
                    Err(VCardError::FormatError(err)) => self.error.push(err.to_string()),
                    Err(VCardError::EmptyFormatName) => self.error.push(String::from("A VCard should have at least one formatted name.")),
                };
                if vcard_content.is_some() {
                    match QrCode::encode_text(vcard_content.as_ref().unwrap(), QrCodeEcc::Low) {
                        Ok(qr) => self.download = Some(
                            Download {
                                file_name: format!("QR-Code VCard {}.svg", self.name.formatted_name()),
                                content: qr.to_svg_string(4),
                                mime_type: MimeType::SVG,
                            }
                        ),
                        Err(_) => self.error.push(String::from("Sorry, VCard is too long!")),
                    };
                }
            }
            Msg::Nope => return false,
        };
        if self.error.len() > 0 {
            self.download = None;
        }
        true
    }

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

    fn view(&self) -> Html {

        let download = self.download.clone();

        let on_name_input = self.link.batch_callback(move |n: Name|
            if download.is_some() {
                vec![
                    Msg::UpdateName(n),
                    match download.as_ref().unwrap().mime_type {
                        MimeType::PDF => Msg::GeneratePdf,
                        MimeType::SVG => Msg::GenerateQrCode,
                        MimeType::VCard => Msg::GenerateVCard,
                    }
                ]
            } else {
                vec![Msg::UpdateName(n), Msg::GenerateVCard]
            }
        );

        let download_options = self.link.callback(|e: ChangeData|
            match e {
                ChangeData::Select(v) => match v.value().as_str() {
                    "vcard" => Msg::GenerateVCard,
                    "pdf" => Msg::GeneratePdf,
                    "qrcode" => Msg::GenerateQrCode,
                    _ => 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_errors() }

                            <NameView oninput=on_name_input />

                            <div class="block">
                                <div class="select">
                                    <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_errors(&self) -> Html {
        html!{
            <>
                {
                    for self.error.iter().map(|err| 
                        html!{
                            <div class="notification is-danger is-light">
                                { err }
                            </div>
                        }
                    ) 
                }
            </>
        }
    }
    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-primary" >
                    { "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!{
                    <code> { download.content.clone() } </code>
                },
                MimeType::SVG => html!{
                    <img src=download.as_data_link() alt="Image Preview" class="image is-square" width="300" height="300"/>
                },
            }
        } else {
            html!{}
        }
    }
    fn generate_vcard(&self) -> Result<VCard, VCardError> {
        match VCard::from_formatted_name_str(&self.name.formatted_name()) {
            Ok(vcard) => Ok(vcard),
            Err(err) => Err(err),
        }
    }
    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();
        doc.set_margins(10);
        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(()),
        }
    }
}


#[wasm_bindgen(start)]
pub fn run_app() {
    init();
    App::<MainView>::new().mount_to_body();
}