using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows.Input;
using BD_empresa.Data;

namespace BD_empresa.ViewModels
{
    public class MainWindowViewModel : INotifyPropertyChanged
    {
        private readonly IClienteRepository _clienteRepository;
        private string? _searchText;
        private bool _isLoading;
        private string? _errorMessage;

        public ObservableCollection<ClienteSmart> Clientes { get; } = [];

        public string? SearchText
        {
            get => _searchText;
            set
            {
                if (_searchText != value)
                {
                    _searchText = value;
                    OnPropertyChanged();
                    _ = SearchAsync();
                }
            }
        }

        public bool IsLoading
        {
            get => _isLoading;
            set { _isLoading = value; OnPropertyChanged(); }
        }

        public string? ErrorMessage
        {
            get => _errorMessage;
            set { _errorMessage = value; OnPropertyChanged(); }
        }

        public ICommand RefreshCommand { get; }

        public MainWindowViewModel(IClienteRepository clienteRepository)
        {
            _clienteRepository = clienteRepository;
            RefreshCommand = new RelayCommand(async _ => await RefreshAsync());
            _ = RefreshAsync();
        }

        public async Task SearchAsync()
        {
            if (string.IsNullOrWhiteSpace(SearchText))
            {
                await RefreshAsync();
                return;
            }
            IsLoading = true;
            ErrorMessage = null;
            try
            {
                var results = await _clienteRepository.SearchClientesAsync(SearchText);
                Clientes.Clear();
                foreach (var cliente in results)
                    Clientes.Add(cliente);
                if (Clientes.Count == 0)
                    ErrorMessage = "Nenhum resultado encontrado.";
            }
            catch (Exception ex)
            {
                ErrorMessage = $"Erro: {ex.Message}";
            }
            finally
            {
                IsLoading = false;
            }
        }

        public async Task RefreshAsync()
        {
            IsLoading = true;
            ErrorMessage = null;
            try
            {
                var results = await _clienteRepository.GetAllClientesAsync();
                Clientes.Clear();
                foreach (var cliente in results)
                    Clientes.Add(cliente);
            }
            catch (Exception ex)
            {
                ErrorMessage = $"Erro: {ex.Message}";
            }
            finally
            {
                IsLoading = false;
            }
        }

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

    // RelayCommand para ICommand
    public class RelayCommand(Func<object?, Task> execute, Predicate<object?>? canExecute = null) : ICommand
    {
        private readonly Func<object?, Task> _execute = execute;
        private readonly Predicate<object?>? _canExecute = canExecute;

        public bool CanExecute(object? parameter) => _canExecute?.Invoke(parameter) ?? true;
        public async void Execute(object? parameter) => await _execute(parameter);
        public event EventHandler? CanExecuteChanged;
        public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}