Unit.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/TranslatedString.h>
#include <NDEVR/StringStream.h>
#include <NDEVR/StringView.h>
#include <NDEVR/Angle.h>
namespace NDEVR
{
    class TranslatedString;
    enum class UnitCategory
    {
          e_undefined_unit      
        , e_angle               
        , e_orientation         
        , e_distance            
        , e_coordinate          
        , e_surface_area        
        , e_volume              
        , e_weight              
        , e_speed               
        , e_acceleration        
        , e_rotational_speed    
        , e_time                
        , e_force               
        , e_ratio               
        , e_lat_lon             
    };

    struct NDEVR_BASE_API Unit
    {
        const String name;                      
        const TranslatedString translated_id;   
        TranslatedString axis_name_ids[4];      
        TranslatedString axis_abbreviations[4]; 

        Unit(StringView name, TranslatedString translated_id);

        virtual ~Unit() = default;

        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const = 0;

        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& unit_space, const uint01 direction = X) const = 0;

        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const = 0;

        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& unit_space) const = 0;

        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const = 0;

        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& unit_space) const = 0;

        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const = 0;

        template<class t_angle_type>
        [[nodiscard]] String convertToString(const Angle<t_angle_type>& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            return convertToString(program_space.template internal<false>(), add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }

        template<class t_angle_type>
        [[nodiscard]] fltp08 convertToUnit(const Angle<t_angle_type>& program_space, uint01 direction = X) const
        {
            return convertToUnit(program_space.template internal<false>(), direction);
        }

        template<class t_angle_type>
        [[nodiscard]] Angle<t_angle_type> convertAngleFromUnit(const fltp08& unit_space, uint01 direction = X) const
        {
            return Angle<t_angle_type>(INTERNAL_ANGLE, convertFromUnit(unit_space, direction));
        }

        [[nodiscard]] virtual String convertToString(const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            return toString(convertToUnit(program_space, direction), add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }

        [[nodiscard]] String toString(const fltp08& unit_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            String s;
            toString(s, unit_space, add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
            return s;
        }

        virtual void toString(String& string, const fltp08& unit_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            string.append(unit_space);
            if (add_comma || min_decimals > 0 || max_decimals <= string.size() || min_digits > 0)
                string = string.formatNumberString(add_comma, min_decimals, max_decimals, min_digits);
            if (include_abv)
                string += abbreviation(direction).translation();
        }

        [[nodiscard]] virtual fltp08 convertFromString(const StringView& unit_string, uint01 direction = X) const
        {
            return convertFromUnit(fromString(unit_string, direction), direction);
        }

        [[nodiscard]] virtual fltp08 fromString(const StringView& unit_string, uint01 direction = X) const
        {
            UNUSED(direction);
            return unit_string.getAs<fltp08>();
        }

        [[nodiscard]] TranslatedString translatedName() const;

        [[nodiscard]] virtual TranslatedString translatedAxisName(uint04 index) const;

        [[nodiscard]] virtual StringView getNextPreferredSeparator(const StringView& current_string, uint01 direction = X) const;

        virtual void toFormula(StringAllocatingView& unit_string, uint01 direction = X) const;

        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction = X) const;
 

        [[nodiscard]] virtual const Unit* subUnit(uint01 direction) const = 0;

        [[nodiscard]] virtual Matrix<fltp08> matrix() const = 0;

        bool operator==(const Unit& other) const
        {
            return other.matrix() == matrix() && other.name == name;
        }

        [[nodiscard]] virtual Unit* clone() const;

        [[nodiscard]] virtual Unit* clone(const StringView& new_name, const TranslatedString& new_display_name) const = 0;
    protected:
        static Buffer<StringView> OperatorSplit(const StringView& string);
    };
    template class NDEVR_BASE_API StringStream<UnitCategory>;
 
 
}