use crate::model::address::*;
use crate::model::name::*;
use crate::model::organizational::*;
use crate::model::other_identification::*;
use crate::model::telephone::*;
use crate::model::utility::*;
use crate::model::vcard::VCardData;
use crate::model::Error;
use crate::model::VCardPropertyInputGroupObject;
use crate::view::property_group::PropertyGroupInputComponent;
use crate::view::weak_links::WeakComponentLink;
use boolinator::Boolinator;
use chrono::prelude::*;
use genpdf::Element as _;
use genpdf::{elements, fonts, style};
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use vobject::parameters;
use vobject::vcard::VcardBuilder;
use yew::prelude::*;
use yew::services::ConsoleService;
use yewtil::ptr::Mrc;

type NameView = PropertyGroupInputComponent<Name, NameMsg>;
type AddressView = PropertyGroupInputComponent<Address, AddressMsg>;
type OtherIdentificationView =
    PropertyGroupInputComponent<OtherIdentification, OtherIdentificationMsg>;
type OrganizationalView = PropertyGroupInputComponent<Organizational, OrganizationalMsg>;
type TelephoneView = PropertyGroupInputComponent<Telephone, TelephoneMsg>;

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>>,
    other_identifications_links: Vec<WeakComponentLink<OtherIdentificationView>>,
    organizational_links: Vec<WeakComponentLink<OrganizationalView>>,

    answer_count: usize,
}

pub enum Msg {
    AddName,
    AddAddress,
    AddTelephone,
    AddDates,
    AddOrganizational,

    ChangeDownloadOption(DownloadOption),

    Generate,
    GeneratedName(Name),
    GeneratedOtherIdentification(OtherIdentification),
    GeneratedAddress(Address),
    GeneratedTelephone(Telephone),
    GeneratedOrganizational(Organizational),
    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()],
            other_identifications_links: vec![WeakComponentLink::default()],
            organizational_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::AddDates => {
                self.other_identifications_links.push(WeakComponentLink::default());
                shouldrender = true;
            }
            Msg::AddOrganizational => {
                self.organizational_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(NameMsg::Generate);
                    }

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

                    for telephone_link in self.telephone_links.iter() {
                        let telephone_link = telephone_link.borrow().clone().unwrap();
                        telephone_link.send_message(TelephoneMsg::Generate);
                    }

                    for dates_link in self.other_identifications_links.iter() {
                        let dates_link = dates_link.borrow().clone().unwrap();
                        dates_link.send_message(OtherIdentificationMsg::Generate)
                    }

                    for organizational_links in self.organizational_links.iter() {
                        let organizational_link = organizational_links.borrow().clone().unwrap();
                        organizational_link.send_message(OrganizationalMsg::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::GeneratedOtherIdentification(other_identification) => {
                self.answer_count += 1;

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => vcard_data.add_other_identification(other_identification),
                    None => ConsoleService::info(
                        "Error in GeneratedOtherIdentification: 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::GeneratedOrganizational(organizational) => {
                self.answer_count += 1;

                match self.vcard_data.get_mut() {
                    Some(vcard_data) => vcard_data.add_organizational(organizational),
                    None => ConsoleService::info("Error in GeneratedOrganizational: 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 {
                    if !name.is_empty() {
                        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 {
                    if !address.is_empty() {
                        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")
                        }

                        let params = if types.is_empty() {
                            parameters!()
                        } else {
                            parameters!("TYPE" => types)
                        };

                        builder = builder.with_adr(
                            params,
                            (!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 {
                    if !telephone.is_empty() {
                        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")
                        }

                        let params = if types.is_empty() {
                            parameters!()
                        } else {
                            parameters!("TYPE" => types)
                        };

                        builder = builder.with_tel(params, telephone.number.clone());
                    }
                }

                for other_identification in vcard_data.other_identifications {
                    if !other_identification.nickname.is_empty() {
                        builder =
                            builder.with_nickname(parameters!(), other_identification.nickname);
                    }

                    match other_identification.photo {
                        Some(file) => builder = builder.with_photo(parameters!(), file.content),
                        None => (),
                    };

                    if !other_identification.anniversary.is_empty() {
                        builder = builder.with_anniversary(other_identification.anniversary);
                    }

                    if !other_identification.birthday.is_empty() {
                        builder = builder.with_bday(parameters!(), other_identification.birthday);
                    }

                    if !other_identification.gender.is_empty() {
                        builder = builder.with_gender(parameters!(), other_identification.gender);
                    }
                }

                for organizational in vcard_data.organizationals {
                    if !organizational.org.is_empty() {
                        builder = builder.with_org(vec![organizational.org]);
                    }

                    match organizational.logo {
                        Some(file) => builder = builder.with_logo(file.content),
                        None => (),
                    };

                    if !organizational.title.is_empty() {
                        builder = builder.with_title(organizational.title);
                    }

                    if !organizational.role.is_empty() {
                        builder = builder.with_role(organizational.role);
                    }

                    if !organizational.member.is_empty() {
                        builder = builder.with_member(organizational.member);
                    }

                    if !organizational.related.is_empty() {
                        builder = builder.with_related(organizational.related);
                    }
                }

                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.other_identifications_links.iter().map(|link|
                                    html!{
                                        <OtherIdentificationView  weak_link=link
                                                    generated=self.link.callback(
                                                        |d: OtherIdentification|
                                                            Msg::GeneratedOtherIdentification(d)
                                                    )
                                        />
                                    }
                                )
                            }

                            {
                                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)
                                                        )
                                        />
                                    }
                                )
                            }

                            {
                                for self.organizational_links.iter().map(|link|
                                    html!{
                                        <OrganizationalView weak_link=link
                                                            generated=self.link.callback(
                                                                |o: Organizational|
                                                                    Msg::GeneratedOrganizational(o)
                                                            )
                                        />
                                    }
                                )
                            }

                            <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()
            + self.other_identifications_links.len()
            + self.organizational_links.len()
    }
}