presence/Presence.Desktop/ViewModels/GroupViewModel.cs

using Avalonia.Controls.ApplicationLifetimes;
using domain.Models;
using domain.UseCase;
using Presence.Desktop.Views;
using ReactiveUI;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive;
using System.Reactive.Linq;
using System.Windows.Input;
using Avalonia;
using System.Formats.Asn1;
using System.IO;
using CsvHelper;
using CsvHelper.Configuration;
using data.RemoteData.RemoteDataBase;

namespace Presence.Desktop.ViewModels
{
    public class GroupViewModel : ViewModelBase, IRoutableViewModel
    {
        // Объявляем поле _remoteDatabaseContext
        private readonly RemoteDatabaseContext _remoteDatabaseContext;

        public string? UrlPathSegment { get; }
        public IScreen HostScreen { get; }

        private readonly UseCaseGeneratePresence _presenceUseCase;
        private readonly GroupUseCase _groupUseCase;
        private List<GroupPresenter> groupPresentersDataSource = new List<GroupPresenter>();
        private ObservableCollection<GroupPresenter> _groups;
        public ObservableCollection<GroupPresenter> Groups => _groups;

        private GroupPresenter? _selectedGroupItem;
        public GroupPresenter? SelectedGroupItem
        {
            get => _selectedGroupItem;
            set => this.RaiseAndSetIfChanged(ref _selectedGroupItem, value);
        }

        public ObservableCollection<UserPresenter> Users { get => _users; }
        private ObservableCollection<UserPresenter> _users;

        // Список опций сортировки
        public List<string> SortOptions { get; } = new List<string> { "По фамилии", "По убыванию" };

        private string _selectedSortOption;
        public string SelectedSortOption
        {
            get => _selectedSortOption;
            set => this.RaiseAndSetIfChanged(ref _selectedSortOption, value);
        }

        public bool CanDelete => SelectedUsers?.Count > 0;
        public bool CanEdit => SelectedUsers?.Count == 1;

        public ObservableCollection<UserPresenter> SelectedUsers { get; set; } = new ObservableCollection<UserPresenter>();

        public ReactiveCommand<Unit, Unit> OnDeleteUserClicks { get; }
        public ReactiveCommand<Unit, Unit> EditUserCommand { get; }
        public ReactiveCommand<Unit, Unit> NextPageCommand { get; }

        public ICommand RemoveAllStudentsCommand { get; }
        public ICommand AddStudentCommand { get; }

        // Конструктор, инициализация _remoteDatabaseContext
        public GroupViewModel(IScreen screen, GroupUseCase groupUseCase, UseCaseGeneratePresence presenceUseCase, RemoteDatabaseContext remoteDatabaseContext)
        {
            _groupUseCase = groupUseCase;
            _presenceUseCase = presenceUseCase;
            HostScreen = screen;
            _remoteDatabaseContext = remoteDatabaseContext; // Инициализация _remoteDatabaseContext

            OnDeleteUserClicks = ReactiveCommand.Create(OnDeleteUserClick, this.WhenAnyValue(vm => vm.CanDelete));
            EditUserCommand = ReactiveCommand.Create(OnEditUserClick, this.WhenAnyValue(vm => vm.CanEdit));

            RefreshGroups();

            _groups = new ObservableCollection<GroupPresenter>(groupPresentersDataSource);
            _users = new ObservableCollection<UserPresenter>();

            this.WhenAnyValue(vm => vm.SelectedGroupItem)
                .Subscribe(vm => SetUsers());

            this.WhenAnyValue(vm => vm.SelectedSortOption)
                .Subscribe(_ => SortUsers());

            RemoveAllStudentsCommand = ReactiveCommand.Create(RemoveAllStudents);
            AddStudentCommand = ReactiveCommand.Create(AddStudent);

            SelectedUsers.CollectionChanged += (s, e) =>
            {
                this.RaisePropertyChanged(nameof(CanDelete));
                this.RaisePropertyChanged(nameof(CanEdit));
            };

            NextPageCommand = ReactiveCommand.Create(NextPageButton);
        }

        private void SetUsers()
        {
            if (SelectedGroupItem?.users == null) return;

            Users.Clear();
            foreach (var item in SelectedGroupItem.users)
            {
                Users.Add(item);
            }

            SortUsers();
        }

        private void SortUsers()
        {
            if (SelectedGroupItem?.users == null) return;

            var sortedUsers = SelectedGroupItem.users.ToList();

            switch (SelectedSortOption)
            {
                case "По фамилии":
                    sortedUsers = sortedUsers.OrderBy(u => u.Name).ToList();
                    break;
                case "По убыванию":
                    sortedUsers = sortedUsers.OrderByDescending(u => u.Name).ToList();
                    break;
            }

            Users.Clear();
            foreach (var item in sortedUsers)
            {
                Users.Add(item);
            }
        }

        private void RemoveAllStudents()
        {
            if (SelectedGroupItem == null) return;

            _groupUseCase.RemoveAllStudentsFromGroup(SelectedGroupItem.Id);
            SelectedGroupItem.users = new List<UserPresenter>();
            SetUsers();
        }

        private void NextPageButton()
        {
            var groupRepository = new SQLGroupRepositoryImpl(_remoteDatabaseContext);
            var groupUseCase = new GroupUseCase(groupRepository);

            HostScreen.Router.Navigate.Execute(new PresenceViewModel(HostScreen, groupUseCase, _presenceUseCase));
        }

        private void AddStudent()
        {
            string csvFilePath = @"C:\Users\class_student\Documents\Group.csv"; // Укажите путь к CSV файлу

            List<UserPresenter> students;
            try
            {
                students = ReadStudentsFromCsv(csvFilePath);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Ошибка при чтении CSV: {ex.Message}");
                return;
            }

            if (SelectedGroupItem == null) return;

            foreach (var student in students)
            {
                _groupUseCase.AddStudentToGroup(SelectedGroupItem.Id, new User
                {
                    FIO = student.Name
                });

                var newStudent = new UserPresenter
                {
                    Name = student.Name,
                    Group = SelectedGroupItem // Устанавливаем ссылку на группу
                };

                var updatedUsers = SelectedGroupItem.users?.ToList() ?? new List<UserPresenter>();
                updatedUsers.Add(newStudent);
                SelectedGroupItem.users = updatedUsers;
            }

            SetUsers();
        }

        private List<UserPresenter> ReadStudentsFromCsv(string filePath)
        {
            var students = new List<UserPresenter>();

            try
            {
                using (var reader = new StreamReader(filePath))
                using (var csv = new CsvReader(reader, new CsvConfiguration(System.Globalization.CultureInfo.InvariantCulture)
                {
                    HasHeaderRecord = true,
                    Delimiter = ","
                }))
                {
                    var records = csv.GetRecords<StudentCsvModel>().ToList();
                    foreach (var record in records)
                    {
                        var student = new UserPresenter
                        {
                            Guid = Guid.NewGuid(), // Генерация GUID
                            Name = record.Name
                        };
                        students.Add(student);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Ошибка при чтении CSV файла: {ex.Message}");
            }

            return students;
        }

        public void OnDeleteUserClick()
        {
            if (SelectedUsers.Count == 0 || SelectedGroupItem?.users == null)
                return;

            foreach (var user in SelectedUsers.ToList())
            {
                _groupUseCase.RemoveUserByGuid(user.Guid);

                var updatedUsers = SelectedGroupItem.users.Where(u => u.Guid != user.Guid).ToList();
                SelectedGroupItem.users = new List<UserPresenter>(updatedUsers);
            }

            SetUsers();
            SelectedUsers.Clear();
            this.RaisePropertyChanged(nameof(CanDelete));
            this.RaisePropertyChanged(nameof(CanEdit));
        }

        public async void OnEditUserClick()
        {
            var user = SelectedUsers.FirstOrDefault();
            if (user == null) return;

            var groups = _groupUseCase.GetAllGroups();

            // Преобразуем группы из domain.Models.Group в GroupPresenter
            var groupPresenters = groups.Select(g => new GroupPresenter
            {
                Id = g.Id,
                Name = g.Name,
                users = g.Users?.Select(u => new UserPresenter
                {
                    Name = u.FIO,
                    Guid = u.Guid,
                    Group = new GroupPresenter { Id = g.Id, Name = g.Name }
                }).ToList()
            }).ToList();

            var editDialog = new EditUserDialog(user.Guid, user.Name, user.Group.Id, groupPresenters);

            var mainWindow = (Application.Current.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.MainWindow;
            if (mainWindow == null) return;

            var result = await editDialog.ShowDialog(mainWindow);

            if (result != (null, null))
            {
                var newName = result.Item1;
                var newGroup = result.Item2;

                user.Name = newName;
                user.Group = newGroup;

                _groupUseCase.UpdateUser(user.Guid, user.Name, user.Group.Id);

                SetUsers();
                SelectedUsers.Clear();
                this.RaisePropertyChanged(nameof(CanEdit));
                this.RaisePropertyChanged(nameof(CanDelete));
            }
            RefreshGroups();
        }

        private void RefreshGroups()
        {
            groupPresentersDataSource.Clear();
            foreach (var item in _groupUseCase.GetAllGroups())
            {
                GroupPresenter groupPresenter = new GroupPresenter
                {
                    Id = item.Id,
                    Name = item.Name,
                    users = item.Users?.Select(user => new UserPresenter
                    {
                        Name = user.FIO,
                        Guid = user.Guid,
                        Group = new GroupPresenter { Id = item.Id, Name = item.Name }
                    }).ToList()
                };
                groupPresentersDataSource.Add(groupPresenter);
            }
            _groups = new ObservableCollection<GroupPresenter>(groupPresentersDataSource);
        }
    }
}