QWERTYkez.Mensura/QWERTYkez.Mensura/Units/Pressure.cs

namespace QWERTYkez.Mensura.Units;

/// <summary>
/// Base value is Pascals or NewtonsPerMeterSquared
/// </summary>
[UnitGenerator, DebuggerDisplay("Pa, N/m2 = {NewtonsPerMeterSquared.ToString(\"0.###\")}, kgf/mm2 = {KiloGramForcesPerMilliMeterSquared.ToString(\"0.###\")}")]
public readonly partial record struct Pressure
{
	public static Pressure Pascal { get; } = new() { _Pascals = 1 };
	[NotMapped, JsonIgnore] public double _Pascals { get => _Value; init => _Value = value; }


    public static Pressure NewtonPerMeterSquared { get; } = new() { NewtonsPerMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double NewtonsPerMeterSquared
    {
        get => _Value;
        init
        {
            _Value = value;
        }
    }

    public static Pressure KiloPascal { get; } = new() { KiloPascals = 1 };
    [NotMapped, JsonIgnore] public double KiloPascals
    {
        get => PressureConv.KiloPascals.From(_Value);
        init
        {
            _Value = PressureConv.KiloPascals.To(value);
        }
    }

    public static Pressure MegaPascal { get; } = new() { MegaPascals = 1 };
    [NotMapped, JsonIgnore] public double MegaPascals
    {
        get => PressureConv.MegaPascals.From(_Value);
        init
        {
            _Value = PressureConv.MegaPascals.To(value);
        }
    }

    public static Pressure NewtonPerMilliMeterSquared { get; } = new() { NewtonsPerMilliMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double NewtonsPerMilliMeterSquared
    {
        get => PressureConv.NewtonsPerMilliMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.NewtonsPerMilliMeterSquared.To(value);
        }
    }

    public static Pressure KiloGramForcePerMilliMeterSquared { get; } = new() { KiloGramForcesPerMilliMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double KiloGramForcesPerMilliMeterSquared
    {
        get => PressureConv.KiloGramForcesPerMilliMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.KiloGramForcesPerMilliMeterSquared.To(value);
        }
    }

    public static Pressure KiloGramForcePerMeterSquared { get; } = new() { KiloGramForcesPerMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double KiloGramForcesPerMeterSquared
    {
        get => PressureConv.KiloGramForcesPerMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.KiloGramForcesPerMeterSquared.To(value);
        }
    }

    public static Pressure KiloNewtonPerMilliMeterSquared { get; } = new() { KiloNewtonsPerMilliMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double KiloNewtonsPerMilliMeterSquared
    {
        get => PressureConv.KiloNewtonsPerMilliMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.KiloNewtonsPerMilliMeterSquared.To(value);
        }
    }

    public static Pressure KiloNewtonPerMeterSquared { get; } = new() { KiloNewtonsPerMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double KiloNewtonsPerMeterSquared
    {
        get => PressureConv.KiloNewtonsPerMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.KiloNewtonsPerMeterSquared.To(value);
        }
    }

    public static Pressure TonForcePerMilliMeterSquared { get; } = new() { TonForcesPerMilliMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double TonForcesPerMilliMeterSquared
    {
        get => PressureConv.TonForcesPerMilliMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.TonForcesPerMilliMeterSquared.To(value);
        }
    }

    public static Pressure TonForcePerMeterSquared { get; } = new() { TonForcesPerMeterSquared = 1 };
    [NotMapped, JsonIgnore] public double TonForcesPerMeterSquared
    {
        get => PressureConv.TonForcesPerMeterSquared.From(_Value);
        init
        {
            _Value = PressureConv.TonForcesPerMeterSquared.To(value);
        }
    }

    public Pressure AddPascals(double value) => new(_Value + value);
    public Pressure AddNewtonsPerMeterSquared(double value) => new(_Value + value);
    public Pressure AddKiloPascals(double value) => new(_Value + PressureConv.KiloPascals.To(value));
    public Pressure AddMegaPascals(double value) => new(_Value + PressureConv.MegaPascals.To(value));
    public Pressure AddKiloGramForcesPerMeterSquared(double value) => new(_Value + PressureConv.KiloGramForcesPerMeterSquared.To(value));
    public Pressure AddTonsPerMeterSquared(double value) => new(_Value + PressureConv.TonForcesPerMeterSquared.To(value));
}

internal readonly struct PressureConv
{
    private PressureConv(double multiplicator) => this.Multiplicator = multiplicator;
    public double To(double value) => value * Multiplicator;
    public double From(double value) => value / Multiplicator;
    public double Multiplicator { get; init; }

    public static PressureConv Pascals { get; } = new(1);
    public static PressureConv NewtonsPerMeterSquared { get; } = new(1);
    public static PressureConv KiloPascals { get; } = new(1000);
    public static PressureConv MegaPascals { get; } = new(1000000);
    public static PressureConv NewtonsPerMilliMeterSquared { get; } = new(1000000);

    public static PressureConv KiloGramForcesPerMeterSquared { get; } = new(Constants.g);
    public static PressureConv KiloGramForcesPerMilliMeterSquared { get; } = new(Constants.g * 1000000);

    public static PressureConv KiloNewtonsPerMeterSquared { get; } = new(1000);
    public static PressureConv KiloNewtonsPerMilliMeterSquared { get; } = new(1000000000);

    public static PressureConv TonForcesPerMeterSquared { get; } = new(Constants.g * 1000);
    public static PressureConv TonForcesPerMilliMeterSquared { get; } = new(Constants.g * 1000000000000);
}