using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Input;
using WPFBeginner.Models;
using WPFBeginner.Services;
using WPFBeginner.Views;

namespace WPFBeginner.ViewModels
{
    public partial class MainWindowViewModel : ObservableRecipient
    {
        private ObservableCollection<Member> members;
        public ObservableCollection<Member> Members
        {
            get
            {
                if(filterMemebers != null)
                    return filterMemebers;

                return members;
            }
            set => SetProperty(ref members, value);
        }

        private ObservableCollection<Member> filterMemebers;

        [ObservableProperty]
        private Member selectedMember;

        private Member searchModel;

        public string MemberName
        {
            get => searchModel?.Name;
            set
            {
                if (searchModel == null)
                    searchModel = new Member();

                searchModel.Name = value;
                OnPropertyChanged();
            }
        }

        public string Call
        {
            get => searchModel?.Call;
            set
            {
                if (searchModel == null)
                    searchModel = new Member();

                searchModel.Call = value;
                OnPropertyChanged();
            }
        }
        public string EmployeeNo
        {
            get => searchModel?.EmployeeNo;
            set
            {
                if (searchModel == null)
                    searchModel = new Member();

                searchModel.EmployeeNo = value;
                OnPropertyChanged();
            }
        }

        public string EMail
        {
            get => searchModel.EMail;
            set
            {
                if (searchModel == null)
                    searchModel = new Member();

                searchModel.EMail = value;
                OnPropertyChanged();
            }
        }

        private bool isKorean;
        public bool IsKorean
        {
            get => isKorean;
            set
            {
                SetProperty(ref isKorean, value);
                App.Config.Language = value ? "ko-KR" : "en-US";
            }
        }

        private bool isDefaultTheme;
        public bool IsDefaultTheme
        {
            get => isDefaultTheme;
            set
            {
                SetProperty(ref isDefaultTheme, value);
                App.Config.Theme = value ? "DefaultTheme" : "LightTheme";
            }
        }

        public ICommand SearchClickCommand => new RelayCommand(() =>
        {
            var errorMessage = ValidateSearchValues();
            if (errorMessage != null)
            {
                MessageBox.Show(errorMessage);
                filterMemebers = null;
                return;
            }


            IEnumerable<Member> result = Members;    

            if (!string.IsNullOrWhiteSpace(MemberName))
                result = result.Where(i => i.Name?.Contains(MemberName) ?? false);

            if (!string.IsNullOrWhiteSpace(EMail))
                result = result.Where(i => i.EMail?.Contains(EMail) ?? false);

            if (!string.IsNullOrWhiteSpace(Call))
                result = result.Where(i => i.Call?.Contains(Call) ?? false);

            if (!string.IsNullOrWhiteSpace(EmployeeNo))
                result = result.Where(i => i.EmployeeNo?.Contains(EmployeeNo) ?? false);

            if (result == null)
                filterMemebers = new ObservableCollection<Member>();
            else
                filterMemebers = new ObservableCollection<Member>(result);

            OnPropertyChanged(nameof(Members));
        });


        private string ValidateSearchValues()
        {
            if (string.IsNullOrWhiteSpace(MemberName)
                && string.IsNullOrWhiteSpace(EmployeeNo)
                && string.IsNullOrWhiteSpace(Call)
                && string.IsNullOrWhiteSpace(EMail))
                return ResourceExplorer.GetStringResource("Cultures.MainWindow.ErrorMessage.SearchConditionEmpty");

            return null;
        }

        public ICommand DeleteClickCommand => new RelayCommand(() =>
        {
            if (SelectedMember == null)
                return;

            Members.Remove(SelectedMember);
        });

        public ICommand InitClickCommand => new RelayCommand(() =>
        {
            filterMemebers = null;
            searchModel = new Member();
            OnPropertyChanged(nameof(MemberName));
            OnPropertyChanged(nameof(EmployeeNo));
            OnPropertyChanged(nameof(EMail));
            OnPropertyChanged(nameof(Call));
            OnPropertyChanged(nameof(Members));
        });

        public ICommand AddClickCommand => new RelayCommand(() =>
        {
            var registDialog = new RegistMemberWindow();
            var result = registDialog.ShowDialog();
            if (result == true)
            {
                var dx = registDialog.DataContext as RegistMemberWindowViewModel;
                if (dx == null)
                    return;
                Members.Add(Member.Create(dx.MemberName, dx.Call, dx.Email, dx.EmployeeNo));
            }
        });


        public MainWindowViewModel()
        {
            CreateDefaultMember();
            searchModel = new Member();
            isKorean = App.Config.Language.Equals("ko-KR", StringComparison.OrdinalIgnoreCase);
            isDefaultTheme = App.Config.Theme.Equals("DefaultTheme", StringComparison.OrdinalIgnoreCase);
        }

        private void CreateDefaultMember()
        {
            members = new ObservableCollection<Member>();
            foreach (var member in App.Config.Members)
                members.Add(Member.Create(member.Name, member.Call, member.EMail, member.EmployeeNo));
            OnPropertyChanged(nameof(Members));
        }
    }
}