using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
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? _searchEmpresaText;
        private string? _searchUnidadeText;
        private bool _isLoading;
        private string? _errorMessage;
        private UnidadeSmart? _selectedCliente;
        private List<UnidadeSmart> _allUnidades = [];

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

        public string? SearchEmpresaText
        {
            get => _searchEmpresaText;
            set
            {
                if (_searchEmpresaText != value)
                {
                    _searchEmpresaText = value;
                    SearchUnidadeText = null; // Limpa o filtro de unidades ao mudar a empresa
                    OnPropertyChanged();
                    FiltrarClientes();
                    AtualizarUnidadesSelecionadas();
                }
            }
        }

        public string? SearchUnidadeText
        {
            get => _searchUnidadeText;
            set
            {
                _searchUnidadeText = value;
                OnPropertyChanged();
                AtualizarUnidadesSelecionadas();
            }
        }

        public UnidadeSmart? SelectedCliente
        {
            get => _selectedCliente;
            set
            {
                if (_selectedCliente != value)
                {
                    _selectedCliente = value;
                    OnPropertyChanged();
                    AtualizarUnidadesSelecionadas();
                }
            }
        }

        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();
        }

        private void FiltrarClientes()
        {
            Clientes.Clear();
            ErrorMessage = null;
            var _search = SearchEmpresaText;
            if (string.IsNullOrWhiteSpace(_search))
            {
                _search = string.Empty;
            }
            var filtrados = _allUnidades
                .Where(c => (c.CNPJ_CPF?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                         || (c.Codigo_Instalacao?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                         || (c.Razao_Social?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                         || (c.Unidade?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                         || (c.Cliente?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false))
                .GroupBy(c => c.Cod_Smart_cliente)
                .Select(g => g.First())
                .Take(9)
                .ToList();
            foreach (var cliente in filtrados)
                Clientes.Add(cliente);
            if (Clientes.Count == 0)
                ErrorMessage = "Nenhum resultado encontrado.";
            else
                SelectedCliente = Clientes.First();
        }

        private void AtualizarUnidadesSelecionadas()
        {
            UnidadesSelecionadas.Clear();
            ErrorMessage = null;
            var _search = SearchUnidadeText;
            if (string.IsNullOrWhiteSpace(_search))
            {
                _search = "";
            }
            var cliente = SelectedCliente;
            if (Clientes.Count > 0)
            {
                cliente ??= Clientes.First();
                var unidades = _allUnidades.Where(c => c.Cod_Smart_cliente == cliente.Cod_Smart_cliente)
                    .Where(c => (c.CNPJ_CPF?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                             || (c.Codigo_Instalacao?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
                             || (c.Unidade?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false))
                    .ToList();
                foreach (var unidade in unidades)
                    UnidadesSelecionadas.Add(unidade);
            }
            if (UnidadesSelecionadas.Count == 0)
                ErrorMessage = "Nenhum resultado encontrado.";
        }

        public async Task RefreshAsync()
        {
            IsLoading = true;
            ErrorMessage = null;
            try
            {
                var results = await _clienteRepository.GetAllClientesAsync();
                _allUnidades = [.. results.OrderBy(u => u.Gestao).ThenBy(c => c.Cliente).ThenBy(g => g.Unidade)];
                FiltrarClientes();
                AtualizarUnidadesSelecionadas();
            }
            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);
    }
}