MaxGog/ParametricFunctionApp: Параметрическая функция с 3-го курса университета МАДИ направление "ИТС" 2025

Репозиторий помещен в архив 24 октября 2025. Вся функциональность доступна только для чтения.
ViewModels/MainPageViewModel.cs
465 строк14 KB
MaxGog
Доработка формулы
07 окт 2025, 19:34
07 окт 2025, 19:347193377
using System.Text;
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using ParametricFunctionApp.Models;
using ParametricFunctionApp.Controls;
using ParametricFunctionApp.Interfaces;

namespace ParametricFunctionApp.ViewModels;

public class MainPageViewModel : INotifyPropertyChanged
{
    private readonly INotificationService _notificationService;
    private double _coefficientK;
    private double _stepCoefficient;
    private double _parameterA;
    private double _initialX;
    private bool _kSet = false;
    private bool _kdSet = false;
    private bool _aSet = false;
    private bool _x1Set = false;
    private List<stRecursion> _recOut = new List<stRecursion>();
    private GraphDrawable _graphDrawable;
    private AppSettings _settings = new AppSettings();
    private int _pointsCount;
    private string _errorMessage = string.Empty;
    private bool _hasErrors = false;

    public MainPageViewModel(INotificationService notificationService)
    {
        _notificationService = notificationService ?? throw new ArgumentNullException(nameof(notificationService));
        _graphDrawable = new GraphDrawable();
        _pointsCount = _settings.PointsCount;
        PropertyChanged = delegate { };
    }

    public double CoefficientK
    {
        get => _coefficientK;
        set
        {
            if (SetProperty(ref _coefficientK, value))
            {
                ValidateInputs();
            }
        }
    }

    public double StepCoefficient
    {
        get => _stepCoefficient;
        set
        {
            if (SetProperty(ref _stepCoefficient, value))
            {
                ValidateInputs();
            }
        }
    }

    public double ParameterA
    {
        get => _parameterA;
        set
        {
            if (SetProperty(ref _parameterA, value))
            {
                ValidateInputs();
            }
        }
    }

    public double InitialX
    {
        get => _initialX;
        set
        {
            if (SetProperty(ref _initialX, value))
            {
                ValidateInputs();
            }
        }
    }

    public bool KSet
    {
        get => _kSet;
        set => SetProperty(ref _kSet, value);
    }

    public bool KdSet
    {
        get => _kdSet;
        set => SetProperty(ref _kdSet, value);
    }

    public bool ASet
    {
        get => _aSet;
        set => SetProperty(ref _aSet, value);
    }

    public bool X1Set
    {
        get => _x1Set;
        set => SetProperty(ref _x1Set, value);
    }

    public List<stRecursion> RecOut
    {
        get => _recOut;
        set => SetProperty(ref _recOut, value);
    }

    public GraphDrawable GraphDrawable
    {
        get => _graphDrawable;
        set => SetProperty(ref _graphDrawable, value);
    }

    public string ErrorMessage
    {
        get => _errorMessage;
        set => SetProperty(ref _errorMessage, value);
    }

    public bool HasErrors
    {
        get => _hasErrors;
        set => SetProperty(ref _hasErrors, value);
    }

    public int PointsCount
    {
        get => _pointsCount;
        set
        {
            if (SetProperty(ref _pointsCount, value))
            {
                _settings.PointsCount = value;
                ValidateInputs();
            }
        }
    }

    public void ResetK()
    {
        CoefficientK = 0;
        KSet = false;
        ValidateInputs();
    }

    public void ResetKd()
    {
        StepCoefficient = 0;
        KdSet = false;
        ValidateInputs();
    }

    public void ResetA()
    {
        ParameterA = 0;
        ASet = false;
        ValidateInputs();
    }

    public void ResetX1()
    {
        InitialX = 0;
        X1Set = false;
        ValidateInputs();
    }

    public async Task<bool> SetKValueAsync(string input)
    {
        if (!ValidateAndParseDouble(input, out double value))
        {
            await _notificationService.ShowErrorAsync("Введите числовое значение с максимум 1 знаком после запятой");
            return false;
        }

        CoefficientK = Math.Round(value, 1);
        KSet = true;

        OnPropertyChanged(nameof(CoefficientK));
        OnPropertyChanged(nameof(KSet));
        return true;
    }

    public async Task<bool> SetKdValueAsync(string input)
    {
        if (!ValidateAndParseDouble(input, out double value))
        {
            await _notificationService.ShowErrorAsync("Введите положительное числовое значение с максимум 1 знаком после запятой");
            return false;
        }

        if (value <= 0)
        {
            await _notificationService.ShowErrorAsync("Шаг kd должен быть положительным числом");
            return false;
        }

        StepCoefficient = Math.Round(value, 1);
        KdSet = true;

        OnPropertyChanged(nameof(StepCoefficient));
        OnPropertyChanged(nameof(KdSet));
        return true;
    }

    public async Task<bool> SetAValueAsync(string input)
    {
        if (!ValidateAndParseDouble(input, out double value))
        {
            await _notificationService.ShowErrorAsync("Введите числовое значение с максимум 1 знаком после запятой");
            return false;
        }

        if (value <= 0)
        {
            await _notificationService.ShowErrorAsync("Параметр A должен быть положительным числом");
            return false;
        }

        ParameterA = Math.Round(value, 1);
        ASet = true;

        OnPropertyChanged(nameof(ParameterA));
        OnPropertyChanged(nameof(ASet));
        return true;
    }

    public async Task<bool> SetX1ValueAsync(string input)
    {
        if (!ValidateAndParseDouble(input, out double value))
        {
            await _notificationService.ShowErrorAsync("Введите числовое значение с максимум 1 знаком после запятой");
            return false;
        }

        InitialX = Math.Round(value, 1);
        X1Set = true;

        OnPropertyChanged(nameof(InitialX));
        OnPropertyChanged(nameof(X1Set));
        return true;
    }

    public async Task ShowAppInfoAsync()
    {
        await _notificationService.ShowInfoAsync(
            "Разработчик: Гоглов Максим Алексеевич\n\n" +
            "Университет: Московский автомобильно-дорожный государственный технический университет (МАДИ)\n" +
            "Группа: 3бИТС2\n\n" +
            "Дата выпуска: октябрь 2025",
            "О программе");
    }

    public bool ValidateAndParseDouble(string input, out double result)
    {
        input = input.Replace('.', ',');

        if (double.TryParse(input, NumberStyles.Any, CultureInfo.GetCultureInfo("ru-RU"), out result))
        {
            int decimalPlaces = GetDecimalPlaces(input);
            return decimalPlaces <= 1;
        }
        return false;
    }

    private int GetDecimalPlaces(string numberString)
    {
        if (string.IsNullOrEmpty(numberString))
            return 0;

        int decimalPointIndex = numberString.IndexOf(',');
        if (decimalPointIndex == -1)
            return 0;

        return numberString.Length - decimalPointIndex - 1;
    }

    public bool CanCalculate()
    {
        return KSet && KdSet && ASet && X1Set && !HasErrors && PointsCount > 0;
    }

    private void ValidateInputs()
    {
        HasErrors = false;
        ErrorMessage = string.Empty;

        if (PointsCount <= 0)
        {
            HasErrors = true;
            ErrorMessage = "Количество точек N должно быть положительным числом (N > 0)";
            return;
        }

        if (ASet && ParameterA < 0)
        {
            HasErrors = true;
            ErrorMessage = "Параметр A должен быть положительным числом (A > 0)";
            return;
        }

        if (KdSet && StepCoefficient < 0)
        {
            HasErrors = true;
            ErrorMessage = "Шаг kd должен быть положительным числом (kd > 0)";
            return;
        }
    }

    public void CalculateFunction()
    {
        if (!CanCalculate())
        {
            return;
        }

        var newRecOut = new List<stRecursion>();

        double boundary = CoefficientK * ParameterA;
        double step = ParameterA * StepCoefficient;
        double x = InitialX;

        for (int i = 0; i < PointsCount; i++)
        {
            double y;
            string functionType;

            if (x < boundary)
            {
                y = ParameterA * Math.Cos(x + 1) + ParameterA;
                functionType = "f₂(x,a) = Acos(x+1)+A";
            }
            else
            {
                y = ParameterA * Math.Sqrt(Math.Abs(x + 2 * ParameterA));
                functionType = "f₁(x,a) = A√|x+2A|";
            }

            newRecOut.Add(new stRecursion(i + 1, Math.Round(x, 3), Math.Round(y, 3), functionType));
            x += step;
        }

        RecOut = newRecOut;
        GraphDrawable = new GraphDrawable
        {
            DataPoints = newRecOut,
            ParameterA = ParameterA,
            CoefficientK = CoefficientK
        };
        OnPropertyChanged(nameof(GraphDrawable));
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected bool SetProperty<T>(ref T backingStore, T value, [CallerMemberName] string propertyName = "")
    {
        if (EqualityComparer<T>.Default.Equals(backingStore, value))
            return false;

        backingStore = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    public async Task<bool> ExportToTxtAsync()
    {
        try
        {
            if (RecOut == null || RecOut.Count == 0)
                return false;

            var sb = new StringBuilder();

            sb.AppendLine("ТАБУЛИРОВАНИЕ ПАРАМЕТРИЧЕСКОЙ ФУНКЦИИ");
            sb.AppendLine($"Дата создания: {DateTime.Now:dd.MM.yyyy HH:mm:ss}");
            sb.AppendLine($"Параметры: a={ParameterA:F1}, k={CoefficientK:F1}, kd={StepCoefficient:F1}, x₁={InitialX:F1}, N={PointsCount}");
            sb.AppendLine();

            sb.AppendLine("┌───────┬────────────┬────────────┐");
            sb.AppendLine("│ № п/п │     X      │     Y      │");
            sb.AppendLine("├───────┼────────────┼────────────┤");

            foreach (var item in RecOut)
            {
                sb.AppendLine($"│ {item.nIdStruct,5} │ {item.nValue1,10:F4} │ {item.nValue2,10:F3} │");
            }

            sb.AppendLine("└───────┴────────────┴────────────┘");
            sb.AppendLine();
            sb.AppendLine($"Всего точек: {RecOut.Count}");
            sb.AppendLine($"Функция: Y = {(CoefficientK * ParameterA):F1} * {(ParameterA):F1}√|x + 2*{(ParameterA):F1}| при x < {(CoefficientK * ParameterA):F1}");
            sb.AppendLine($"         Y = {(ParameterA):F1} * cos(x + 1) + {(ParameterA):F1} при x >= {(CoefficientK * ParameterA):F1}");

            var tempFile = Path.Combine(FileSystem.CacheDirectory, $"function_results_{DateTime.Now:yyyyMMdd_HHmmss}.txt");
            await File.WriteAllTextAsync(tempFile, sb.ToString(), Encoding.UTF8);

            await ShareFile(tempFile, "text/plain", "Результаты табулирования.txt");
            return true;
        }
        catch (Exception ex)
        {
            await _notificationService.ShowErrorAsync($"Ошибка при экспорте в TXT: {ex.Message}");
            return false;
        }
    }

    public async Task<bool> ExportToXlsxAsync()
    {
        try
        {
            if (RecOut == null || RecOut.Count == 0)
                return false;

            var sb = new StringBuilder();

            sb.AppendLine("№;X;Y;Тип функции");

            foreach (var item in RecOut)
            {
                var functionType = item.nValue1 < CoefficientK * ParameterA ? $"a·cos(x+1)+a (a={ParameterA:F1})" : $"a√|x+2a| (a={ParameterA:F1})";

                sb.AppendLine($"{item.nIdStruct};{item.nValue1:F4};{item.nValue2:F3};{functionType}");
            }

            sb.AppendLine();
            sb.AppendLine($"Параметр a;{ParameterA:F1}");
            sb.AppendLine($"Коэффициент k;{CoefficientK:F1}");
            sb.AppendLine($"Шаг kd;{StepCoefficient:F1}");
            sb.AppendLine($"Начальное значение x₁;{InitialX:F1}");
            sb.AppendLine($"Количество точек;{PointsCount}");
            sb.AppendLine($"Дата создания;{DateTime.Now:dd.MM.yyyy HH:mm:ss}");

            var tempFile = Path.Combine(FileSystem.CacheDirectory, $"function_results_{DateTime.Now:yyyyMMdd_HHmmss}.xlsx");
            await File.WriteAllTextAsync(tempFile, sb.ToString(), Encoding.UTF8);

            await ShareFile(tempFile, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Результаты табулирования.xlsx");
            return true;
        }
        catch (Exception ex)
        {
            await _notificationService.ShowErrorAsync($"Ошибка при экспорте в XLSX: {ex.Message}");
            return false;
        }
    }

    private async Task ShareFile(string filePath, string contentType, string shareFileName)
    {
        await Share.RequestAsync(new ShareFileRequest
        {
            Title = "Экспорт результатов табулирования",
            File = new ShareFile(filePath, contentType)
        });
    }
}