ContactInfo.h

#pragma once
#include <NDEVR/Model.h>
#if NDEVR_CONTACT_INFO
#include <NDEVR/Translator.h>
namespace NDEVR
{
    class ContactName : public Model
    {
    public:
        ContactName(const Model& model)
            : Model(model)
        {
 
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }
        void setContact(const StringView& name)
        {
            set<NDPO::untranslated_string_data>(name);
        }
        StringView getContact() const
        {
            return get<NDPO::untranslated_string_data>();
        }
        static constexpr const char* ValidRegex() { return "(\\w+)(\\.|_)?(\\w*)@(\\w+)(\\.(\\w+))+"; }
        static constexpr const char* TypeName() { return "contact_name"; }
    };
    class TelephoneNumber : public Model
    {
    public:
        TelephoneNumber(const Model& model)
            : Model(model)
        {
            if (!model.isValid())
                return;
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
                set<NDPOC::name>(_t("Mobile"));
                set<NDPO::icon>("mobile");
            }
        }
        StringView phoneNumber() const
        {
            return get<NDPO::untranslated_string_data>();
        }
        void updatePhoneNumber(const StringView& phone_number, const void* lock_ptr = nullptr)
        {
            update<NDPO::untranslated_string_data>(phone_number, lock_ptr);
        }
        StringView phoneNumberName() const
        {
            return get<NDPO::name>();
        }
        void updatePhoneNumberName(const StringView& phone_number_name, const void* lock_ptr = nullptr)
        {
            update<NDPO::name>(phone_number_name, lock_ptr);
        }
        static constexpr StringView ValidRegex() { return "sad";/*TODO*/ }
        static constexpr StringView TypeName() { return "telephone_number"; }
 
    };

    class PhysicalAddressModel : public Model
    {
    public:
        PhysicalAddressModel(const Model& model)
            : Model(model)
        {
            if (get<NDPN::type>() != TypeName())
            {
                set<NDPN::type>(TypeName());
                setAddress("\t\t\t");
                set<NDPOC::name>(_t("Address"));
                set<NDPO::icon>("pin");
            }
        }
        StringView address() const
        {
            return get<NDPO::untranslated_string_data>();
        }
        void setAddress(const StringView& address)
        {
            lib_assert(address.count('\t') == 3, "Bad Address");
            if (address.count('\t') == 3)
                update<NDPO::untranslated_string_data>(address);
        }
        StringView streetAddress() const
        {
            StringView address = get<NDPO::untranslated_string_data>();
            return address.split('\t')[0];
        }
        void setStreetAddress(const StringView& street)
        {
            String current_data(get<NDPO::untranslated_string_data>());
            Buffer<StringView> parts = current_data.split('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 0)
                    current_data += street;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }
        StringView city() const
        {
            StringView s = get<NDPO::untranslated_string_data>();
            if (s.contains('\t'))
                return s.split('\t')[1];
            else
                return StringView();
        }
        void setCity(const StringView& city)
        {
            String current_data(get<NDPO::untranslated_string_data>());
            Buffer<StringView> parts = current_data.split('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            current_data.clear();
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 1)
                    current_data += city;
                else
                    current_data += parts[i];
                if (i < 3)
                    current_data += "\t";
            }
            setAddress(current_data);
        }

        String state() const
        {
            StringView s = get<NDPO::untranslated_string_data>();
            if (s.count('\t') >= 2)
                return String(s.split('\t')[2]);
            else
                return String();
        }
        void setState(const StringView& state)
        {
            StringView current_data(get<NDPO::untranslated_string_data>());
            Buffer<StringView> parts = current_data.split('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            String all_data;
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 2)
                    all_data += state;
                else
                    all_data += parts[i];
                if (i < 3)
                    all_data += "\t";
            }
            setAddress(all_data);
        }

        StringView zipCode() const
        {
            StringView s = get<NDPO::untranslated_string_data>();
            if (s.count('\t') >= 3)
                return s.split('\t')[3];
            else
                return StringView();
        }
        void setZipCode(const StringView& zip)
        {
            StringView current_data = get<NDPO::untranslated_string_data>();
            Buffer<StringView> parts = current_data.split('\t');
            lib_assert(parts.size() == 4, "Bad Address");
            String all_data;
            for (uint04 i = 0; i < parts.size(); i++)
            {
                if (i == 3)
                    all_data += zip;
                else
                    all_data += parts[i];
                if (i < 3)
                    all_data += "\t";
            }
            setAddress(all_data);
        }
        static constexpr const char* TypeName() { return "physical_address"; }
    };
    class EmailAddress : public Model
    {
    public:
        EmailAddress(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }
        static constexpr const char* TypeName() { return "email_address"; }
        void setEmail(const StringView& email)
        {
            set<NDPO::untranslated_string_data>(email);
        }
        StringView getEmail() const
        {
            return get<NDPO::untranslated_string_data>();
        }
    };
    class CompanyName : public Model
    {
    public:
        CompanyName(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }
        void setCompany(const StringView& companyName)
        {
            set<NDPO::untranslated_string_data>(companyName);
        }
        StringView getCompany() const
        {
            return get<NDPO::untranslated_string_data>();
        }
        static constexpr const char* TypeName() { return "company_name"; }
    };
    class CompanyRole : public Model
    {
    public:
        CompanyRole(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }
        void setCompanyRole(const StringView& role)
        {
            set<NDPO::untranslated_string_data>(role);
        }
        StringView getCompanyRole() const
        {
            return get<NDPO::untranslated_string_data>();
        }
        static constexpr const char* TypeName() { return "company_role"; }
    };

    class ContactInfo : public Model
    {
    public:
        ContactInfo(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                createChildren(5);
                set<NDPN::type>(TypeName());
                set<NDPOC::name>(_t("Contact"));
            }
        }
        ContactName contactName()
        {
            return ContactName(getChild(0));
        }
        TelephoneNumber telephoneNumber()
        {
            return TelephoneNumber(getChild(1));
        }
        EmailAddress emailAddress()
        {
            return EmailAddress(getChild(2));
        }
        CompanyName companyName()
        {
            return CompanyName(getChild(3));
        }
        CompanyRole companyRole()
        {
            return CompanyRole(getChild(4));
        }
        static constexpr const char* TypeName() { return "contact_info"; }
    };
}
#endif