Teti/Teti/ViewModels/MediaBrowserViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using InstaArchive.Models;
using InstaArchive.Repositories;

namespace InstaArchive.ViewModels;

public partial class MediaBrowserViewModel : ObservableObject
{
    private readonly FileBasedMediaRepository _mediaRepository;
    private readonly FileBasedUserRepository _userRepository;

    [ObservableProperty]
    private ObservableCollection<MediaItem> allMedia = new();

    [ObservableProperty]
    private ObservableCollection<MediaItem> filteredMedia = new();

    [ObservableProperty]
    private ObservableCollection<InstagramUser> allUsers = new();

    [ObservableProperty]
    private InstagramUser? selectedUserFilter;

    [ObservableProperty]
    private string searchQuery = string.Empty;

    [ObservableProperty]
    private MediaItem? selectedMedia;

    public MediaBrowserViewModel(
        FileBasedMediaRepository mediaRepository,
        FileBasedUserRepository userRepository)
    {
        _mediaRepository = mediaRepository;
        _userRepository = userRepository;

        _ = LoadDataAsync();
    }

    partial void OnSearchQueryChanged(string value)
    {
        FilterMedia();
    }

    partial void OnSelectedUserFilterChanged(InstagramUser? value)
    {
        FilterMedia();
    }

    private void FilterMedia()
    {
        var filtered = AllMedia.AsEnumerable();

        // Filter by search query
        if (!string.IsNullOrWhiteSpace(SearchQuery))
        {
            var query = SearchQuery.ToLower();
            filtered = filtered.Where(m =>
                m.FileName.ToLower().Contains(query) ||
                m.Caption?.ToLower().Contains(query) == true
            );
        }

        // Filter by user
        if (SelectedUserFilter != null)
        {
            filtered = filtered.Where(m => m.UserId == SelectedUserFilter.UserId);
        }

        FilteredMedia.Clear();
        foreach (var item in filtered)
        {
            FilteredMedia.Add(item);
        }
    }

    [RelayCommand]
    private async Task RefreshAsync()
    {
        await LoadDataAsync();
    }

    [RelayCommand]
    private void OpenMedia(MediaItem media)
    {
        if (media == null)
        {
            return;
        }

        // Open media in default application
        _ = Windows.System.Launcher.LaunchUriAsync(
            new System.Uri($"file:///{media.LocalPath}")
        );
    }

    [RelayCommand]
    private async Task DeleteMediaAsync(MediaItem media)
    {
        if (media == null)
        {
            return;
        }

        // TODO: Implement delete confirmation and deletion
        AllMedia.Remove(media);
        FilterMedia();
        await Task.CompletedTask;
    }

    private async Task LoadDataAsync()
    {
        var mediaList = await _mediaRepository.GetAllMediaAsync();
        var userList = await _userRepository.GetAllUsersAsync();

        AllMedia.Clear();
        foreach (var item in mediaList.OrderByDescending(m => m.DownloadedAt))
        {
            AllMedia.Add(item);
        }

        AllUsers.Clear();
        foreach (var user in userList)
        {
            AllUsers.Add(user);
        }

        FilterMedia();
    }
}