path: root/src/view/main.rs

use yew::services::ConsoleService;
use crate::viewmodel::vcard::VCardData;
use crate::viewmodel::Error;
use crate::view::telephone::{self,TelephoneView};
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 yewtil::ptr::Mrc;
use vobject::vcard::VcardBuilder;
use vobject::parameters;
use chrono::prelude::*;
use crate::viewmodel::name::Name;
use crate::viewmodel::address::Address;
use crate::viewmodel::telephone::Telephone;
use crate::viewmodel::utility::*;
use boolinator::Boolinator;


pub struct MainView {
    link: ComponentLink<Self>,
    error: Option<Error>,
    download: Option<Download>,
    selected_option: DownloadOption,
    vcard_data: Mrc<VCardData>,

    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,
    GeneratedName(Name),
    GeneratedAddress(Address),
    GeneratedTelephone(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_data: Mrc::new(VCardData::new()),

            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::GeneratedName(name) => {

                self.answer_count += 1;

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => vcard_data.add_name(name),
                    None => ConsoleService::info("Error in GeneratedName: Couldn't get mutable borrow of VCardData"),
                };

                shouldrender = true;

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

                self.answer_count += 1;

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => vcard_data.add_address(address),
                    None => ConsoleService::info("Error in GeneratedAddress: Couldn't get mutable borrow of VCardData"),
                };
                
                shouldrender = true;
            },
            Msg::GeneratedTelephone(telephone) => {

                self.answer_count += 1;

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => vcard_data.add_telephone(telephone),
                    None => ConsoleService::info("Error in GeneratedTelephone: Couldn't get mutable borrow of VCardData"),
                };

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

                self.answer_count = 0;

                let vcard_data = self.vcard_data.clone_inner();

                let mut builder = VcardBuilder::new();

                for name in vcard_data.names {

                    builder = builder
                    .with_fullname(
                        name.generate_fn()
                    )
                    .with_name(
                        parameters!(),
                        name.last_name.is_empty().as_some(name.last_name.clone()),
                        name.first_name.is_empty().as_some(name.first_name.clone()),
                        name.middle_name.is_empty().as_some(name.middle_name.clone()),
                        name.prefix.is_empty().as_some(name.prefix.clone()),
                        name.suffix.is_empty().as_some(name.suffix.clone())
                    );
                }

                for address in vcard_data.addresses {
                    let mut types = String::new();
                    if address.work {
                        types.push_str("WORK");
                    }
                    if address.home {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("HOME")
                    }

                    builder = builder.with_adr(
                        parameters!("TYPE" => types),
                        address.post_office_box.is_empty().as_some(address.post_office_box.clone()),
                        address.extension.is_empty().as_some(address.extension.clone()),
                        address.street.is_empty().as_some(address.street.clone()),
                        address.locality.is_empty().as_some(address.locality.clone()),
                        address.region.is_empty().as_some(address.region.clone()),
                        address.code.is_empty().as_some(address.code.clone()),
                        address.country.is_empty().as_some(address.country.clone()),
                    );
                }

                for telephone in vcard_data.telephones {
                    let mut types = String::new();
                    if telephone.work {
                        types.push_str("WORK");
                    }
                    if telephone.home {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("HOME")
                    }
                    if telephone.text {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("TEXT")
                    }
                    if telephone.voice {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("VOICE")
                    }
                    if telephone.fax {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("FAX")
                    }
                    if telephone.cell {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("CELL")
                    }
                    if telephone.video {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("VIDEO")
                    }
                    if telephone.pager {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("PAGER")
                    }
                    if telephone.text_phone {
                        if types.is_empty() {
                            types.push(',');
                        }
                        types.push_str("TEXTPHONE")
                    }

                    builder = builder.with_tel(
                        parameters!("TYPE" => types),
                        telephone.number.clone(),
                    );
                }
                    

                let rev = Local::now();
                
                match builder
                    .with_version("4.0".to_string())
                    .with_rev(format!("{}", rev))
                    .build() {
                        Ok(vcard) => {
                            match self.selected_option {
                                DownloadOption::VCard => {
                                    self.download = Some(
                                        Download {
                                            file_name: String::from("VCard.vcs"),
                                            content: vobject::write_component(&vcard),
                                            mime_type: MimeType::VCard,
                                        }
                                    );
                                },
                                DownloadOption::QrCode => {
                                    match QrCode::encode_text(&vobject::write_component(&vcard), 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!"),
                                            }
                                        ),
                                    };
                                },
                                _ => (),
                            };
                        },
                        Err(err) => self.error = Some(
                            Error{
                                msg: err.to_string(),
                            }
                        ),
                    };

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => *vcard_data = VCardData::new(),
                    None => ConsoleService::info("Couldn't reset VCardData"),
                };

                shouldrender = true;

            },
            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=self.link.callback(
                                                        |n: Name| 
                                                            Msg::GeneratedName(n)
                                                    )
                                        />
                                    }
                                )
                            }

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

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

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

                                <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()
    }
}