Soft-LTS/ViewModels/SettingsViewModel.cs

using System.Collections.ObjectModel;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Windows;
using System.Windows.Input;
using PrinterMonitor.Configuration;

namespace PrinterMonitor.ViewModels;

public class SettingsViewModel : ViewModelBase
{
    private readonly AppSettings _settings;
    public ObservableCollection<PrinterConfig> Printers { get; }

    // Globale Einstellungen
    private int _tcpTargetPort;
    public int TcpTargetPort { get => _tcpTargetPort; set => SetProperty(ref _tcpTargetPort, value); }

    private PrinterConfig? _selectedPrinter;
    public PrinterConfig? SelectedPrinter
    {
        get => _selectedPrinter;
        set
        {
            if (_selectedPrinter != null)
                ApplyEdits();

            if (SetProperty(ref _selectedPrinter, value))
            {
                LoadEdits();
                OnPropertyChanged(nameof(HasSelection));
                OnPropertyChanged(nameof(IsNetworkPrinter));
            }
        }
    }

    public bool HasSelection => _selectedPrinter != null;
    public bool IsNetworkPrinter => _selectedPrinter != null &&
        !string.Equals(_selectedPrinter.Type, "Simulation", StringComparison.OrdinalIgnoreCase);

    // Edit-Felder
    private string _editName = "";
    private string _editType = "CabSquix";
    private string _editHost = "";
    private int _editPort;
    private bool _editEnabled = true;

    public string EditName { get => _editName; set => SetProperty(ref _editName, value); }

    public string EditType
    {
        get => _editType;
        set
        {
            if (SetProperty(ref _editType, value))
                OnPropertyChanged(nameof(IsNetworkPrinter));
        }
    }

    public string EditHost { get => _editHost; set => SetProperty(ref _editHost, value); }
    public int EditPort { get => _editPort; set => SetProperty(ref _editPort, value); }
    public bool EditEnabled { get => _editEnabled; set => SetProperty(ref _editEnabled, value); }

    public IReadOnlyList<string> PrinterTypes { get; } =
        new[] { "CabSquix", "Zebra", "Honeywell", "Simulation" };

    public ICommand AddCommand { get; }
    public ICommand RemoveCommand { get; }
    public ICommand SaveCommand { get; }

    private readonly Func<Task> _onSaved;

    public SettingsViewModel(AppSettings settings, Func<Task> onSaved)
    {
        _settings = settings;
        _onSaved = onSaved;
        Printers = new ObservableCollection<PrinterConfig>(settings.Printers);
        TcpTargetPort = settings.TcpTargetPort;

        AddCommand = new RelayCommand(AddPrinter);
        RemoveCommand = new RelayCommand(RemovePrinter, () => HasSelection);
        SaveCommand = new AsyncRelayCommand(SaveAsync);
    }

    private void AddPrinter()
    {
        var newPrinter = new PrinterConfig
        {
            Name = "Neuer Drucker",
            Type = "CabSquix",
            Host = "",
            Port = 4840,
            Enabled = true
        };
        Printers.Add(newPrinter);
        SelectedPrinter = newPrinter;
    }

    private void RemovePrinter()
    {
        if (_selectedPrinter == null) return;
        var idx = Printers.IndexOf(_selectedPrinter);
        Printers.Remove(_selectedPrinter);
        _selectedPrinter = null;
        LoadEdits();
        OnPropertyChanged(nameof(HasSelection));
        OnPropertyChanged(nameof(SelectedPrinter));

        if (Printers.Count > 0)
            SelectedPrinter = Printers[Math.Min(idx, Printers.Count - 1)];
    }

    private async Task SaveAsync()
    {
        if (_selectedPrinter != null)
            ApplyEdits();

        try
        {
            var configPath = Path.Combine(AppContext.BaseDirectory, "appsettings.json");

            var jsonOptions = new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                WriteIndented = true
            };

            JsonNode? root = null;
            if (File.Exists(configPath))
            {
                var existing = await File.ReadAllTextAsync(configPath);
                root = JsonNode.Parse(existing);
            }
            root ??= new JsonObject();

            root["tcpTargetPort"] = TcpTargetPort;
            root["printers"] = JsonSerializer.SerializeToNode(Printers.ToList(), jsonOptions);

            await File.WriteAllTextAsync(configPath,
                root.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));

            _settings.TcpTargetPort = TcpTargetPort;
            _settings.Printers = Printers.ToList();

            await _onSaved();

            MessageBox.Show("Einstellungen gespeichert. Monitoring wurde neu gestartet.",
                "Gespeichert", MessageBoxButton.OK, MessageBoxImage.Information);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Fehler beim Speichern:\n{ex.Message}",
                "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
        }
    }

    private void LoadEdits()
    {
        if (_selectedPrinter == null)
        {
            EditName = "";
            EditType = "CabSquix";
            EditHost = "";
            EditPort = 0;
            EditEnabled = true;
            return;
        }

        EditName = _selectedPrinter.Name;
        EditType = _selectedPrinter.Type;
        EditHost = _selectedPrinter.Host;
        EditPort = _selectedPrinter.Port;
        EditEnabled = _selectedPrinter.Enabled;
    }

    private void ApplyEdits()
    {
        if (_selectedPrinter == null) return;

        _selectedPrinter.Name = EditName;
        _selectedPrinter.Type = EditType;
        _selectedPrinter.Host = EditHost;
        _selectedPrinter.Port = EditPort;
        _selectedPrinter.Enabled = EditEnabled;
    }
}