DurationViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.UI.Pages.Contracts.NewContract.ObjectModel;
using System.ComponentModel;
using System.Globalization;
using System.Text;
using Waher.Content;
 
namespace NeuroAccessMaui.UI.Pages.Main.Duration
{
    public partial class DurationViewModel : XmppViewModel
    {
        private bool skipEvaluations = false;
 
        public DurationViewModel(DurationNavigationArgs? Args)
            : base()
        {
            this.Entry = Args?.Entry;
        }
 
        protected override async Task OnDispose()
        {
            this.EvaluateDuration();
 
            await base.OnDispose();
        }
 
        #region Properties
 
        [ObservableProperty]
        private Waher.Content.Duration value;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(Value))]
        [NotifyPropertyChangedFor(nameof(Years))]
        [NotifyPropertyChangedFor(nameof(Months))]
        [NotifyPropertyChangedFor(nameof(Days))]
        [NotifyPropertyChangedFor(nameof(Hours))]
        [NotifyPropertyChangedFor(nameof(Minutes))]
        [NotifyPropertyChangedFor(nameof(Seconds))]
        [NotifyPropertyChangedFor(nameof(IsNegativeDuration))]
        private Entry? entry;
 
        protected override void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            base.OnPropertyChanged(e);
 
            switch (e.PropertyName)
            {
                case nameof(this.IsNegativeDuration):
                case nameof(this.Years):
                case nameof(this.Months):
                case nameof(this.Days):
                case nameof(this.Hours):
                case nameof(this.Minutes):
                case nameof(this.Seconds):
                    this.EvaluateDuration();
                    break;
 
                case nameof(this.Entry):
                    if ((this.Entry is not null) && (this.Entry.BindingContext is ParameterInfo ParameterInfo))
                    {
                        this.Value = ParameterInfo.DurationValue;
                        this.SplitDuration();
                    }
                    break;
 
                case nameof(this.Value):
                    if ((this.Entry is not null) && (this.Entry.BindingContext is ParameterInfo ParameterInfo2))
                        ParameterInfo2.DurationValue = this.Value;
                    break;
            }
        }
 
        [ObservableProperty]
        private bool isNegativeDuration;
 
        [ObservableProperty]
        private string years = string.Empty;
 
        [ObservableProperty]
        private string months = string.Empty;
 
        [ObservableProperty]
        private string days = string.Empty;
 
        [ObservableProperty]
        private string hours = string.Empty;
 
        [ObservableProperty]
        private string minutes = string.Empty;
 
        [ObservableProperty]
        private string seconds = string.Empty;
 
        [ObservableProperty]
        private bool yearsOk = false;
 
        [ObservableProperty]
        private bool monthsOk = false;
 
        [ObservableProperty]
        private bool daysOk = false;
 
        [ObservableProperty]
        private bool hoursOk = false;
 
        [ObservableProperty]
        private bool minutesOk = false;
 
        [ObservableProperty]
        private bool secondsOk = false;
 
        #endregion
 
        #region Commands
 
        [RelayCommand]
        private void PlusMinus()
        {
            this.IsNegativeDuration = !this.IsNegativeDuration;
        }
 
        public void SplitDuration()
        {
            this.skipEvaluations = true;
 
            this.IsNegativeDuration = this.Value.Negation;
            this.Years = ComponentToString(this.Value.Years);
            this.Months = ComponentToString(this.Value.Months);
            this.Days = ComponentToString(this.Value.Days);
            this.Hours = ComponentToString(this.Value.Hours);
            this.Minutes = ComponentToString(this.Value.Minutes);
            this.Seconds = ComponentToString(this.Value.Seconds);
 
            this.skipEvaluations = false;
        }
 
        private static string ComponentToString(int Value)
        {
            if (Value == 0)
                return string.Empty;
            else
                return Value.ToString(CultureInfo.InvariantCulture);
        }
 
        private static string ComponentToString(double Value)
        {
            if (Value == 0)
                return string.Empty;
            else
                return Value.ToString(CultureInfo.InvariantCulture);
        }
 
        public void EvaluateDuration()
        {
            if (this.skipEvaluations)
                return;
 
            bool IsZero = true;
            StringBuilder sb = new();
 
            if (this.IsNegativeDuration)
                sb.Append("-P");
            else
                sb.Append('P');
 
            if (!string.IsNullOrEmpty(this.Years))
            {
                IsZero = false;
                sb.Append(this.Years);
                sb.Append('Y');
                this.YearsOk = int.TryParse(this.Years, out _);
            }
            else
                this.YearsOk = true;
 
            if (!string.IsNullOrEmpty(this.Months))
            {
                IsZero = false;
                sb.Append(this.Months);
                sb.Append('M');
                this.MonthsOk = int.TryParse(this.Months, out _);
            }
            else
                this.MonthsOk = true;
 
            if (!string.IsNullOrEmpty(this.Days))
            {
                IsZero = false;
                sb.Append(this.Days);
                sb.Append('D');
                this.DaysOk = int.TryParse(this.Days, out _);
            }
            else
                this.DaysOk = true;
 
            bool IsHours = !string.IsNullOrEmpty(this.Hours);
            bool IsMinutes = !string.IsNullOrEmpty(this.Minutes);
            bool IsSeconds = !string.IsNullOrEmpty(this.Seconds);
 
            if (IsHours || IsMinutes || IsSeconds)
            {
                IsZero = false;
                sb.Append('T');
 
                if (IsHours)
                {
                    sb.Append(this.Hours);
                    sb.Append('H');
                    this.HoursOk = int.TryParse(this.Hours, out _);
                }
                else
                    this.HoursOk = true;
 
                if (IsMinutes)
                {
                    sb.Append(this.Minutes);
                    sb.Append('M');
                    this.MinutesOk = int.TryParse(this.Minutes, out _);
                }
                else
                    this.MinutesOk = true;
 
                if (IsSeconds)
                {
                    sb.Append(this.Seconds);
                    sb.Append('S');
                    this.SecondsOk = CommonTypes.TryParse(this.Seconds, out double _);
                }
                else
                    this.SecondsOk = true;
            }
            else
            {
                this.HoursOk = true;
                this.MinutesOk = true;
                this.SecondsOk = true;
            }
 
            if (IsZero)
                sb.Append("PT0S");
 
            if (Waher.Content.Duration.TryParse(sb.ToString(), out Waher.Content.Duration Result))
                this.Value = Result;
        }
 
        #endregion
    }
}