namespace ViewModel;

using System.Collections.ObjectModel;
using System.Diagnostics;
using Model;
using MyToolkitMVVM;

public class ManagerVM : BaseViewModel<Manager>
{
    public ReadOnlyObservableCollection<BookVM> Books { get; set; }

    private readonly ObservableCollection<BookVM> books = new ObservableCollection<BookVM>();

    public RelayCommand<string> LoadBooks { get; private set; }

    public IEnumerable<IGrouping<string, BookVM>> GroupedBooks => books.GroupBy(b => b.BookFirstAuthor).OrderBy(group => group.Key);
    public IEnumerable<IGrouping<string, BookVM>> GroupedLaterBooks => books.Where(book => book.BookStatus == Status.ToBeRead).GroupBy(book => book.BookFirstAuthor).OrderBy(group => group.Key);
    public BookVM SelectedBook
    {
        get => selectedBook;
        set => SetProperty(ref selectedBook, value);
    }

    private BookVM selectedBook;

    public ManagerVM(ILibraryManager libraryManager,IUserLibraryManager userLibraryManager)
    :this(new Manager(libraryManager,userLibraryManager))
    {}

    public async void LoadBooksFromManager()
    {
        var result = await Model.GetBooksFromCollection(index, 5, "");
        NbBook = (int)result.count;
        books.Clear();

        foreach (Book book in result.books)
        {
            books.Add(new BookVM(book));
        }
        Refresh();
    }

    public async void LoadBooksReadLaterFromManager()
    {
        var result = await Model.GetBooksFromCollection(indexLater, 5, "");
        books.Clear();
        nbBookLater = 0;
        foreach (Book book in result.books)
        {
            if (book.Status == Status.ToBeRead)
            {
                books.Add(new BookVM(book));
                nbBookLater++;
            }
        }
        Refresh();
    }

    public void ChangeStatut(string statut)
    {
        switch (statut)
        {
            case "Terminé":
                SelectedBook.BookStatus = Status.Finished;
                break;
            case "Non lu":
                SelectedBook.BookStatus = Status.NotRead;
                break;
            case "À lire":
                SelectedBook.BookStatus = Status.ToBeRead;
                break;
            case "En lecture":
                SelectedBook.BookStatus = Status.Reading;
                break;
            case "Unknown":
                SelectedBook.BookStatus = Status.NotRead;
                break;
        }
        Refresh();
    }

    public void Refresh()
    {
        OnPropertyChanged(nameof(GroupedBooks));
        OnPropertyChanged(nameof(GroupedLaterBooks));
        //NbBookLater=books.Where(book => book.BookStatus == Status.ToBeRead).Count();
        Debug.WriteLine(NbBookLater);
    }

    public ManagerVM(Manager model) : base(model)
    {
        LoadBooks = new RelayCommand<string>(o => LoadBooksFromManager());
        Books = new ReadOnlyObservableCollection<BookVM>(books);
    }

    public int Index
    {
        get => index;
        set
        {
            SetProperty(ref index, value);
        }
    }

    private int index;

    public int Count
    {
        get => count;
        set => SetProperty(ref count, value);

    }
    private int count;


    public int NbBook
    {
        get => nbBook;
        set => SetProperty(ref nbBook, value);
    }

    private int nbBook;

    public int NbBookLater
    {
        get => nbBookLater;
        set => SetProperty(ref nbBookLater, value);
    }

    private int nbBookLater;

    public int IndexLater
    {
        get => indexLater;
        set
        {
            SetProperty(ref indexLater, value);
        }
    }

    private int indexLater;

}