using Elwig.Helpers;
using Elwig.Models.Entities;
using Elwig.Services;
using Elwig.ViewModels;
using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Elwig.Windows {
    public partial class MemberBusinessSharesAdminWindow : AdministrationWindow {

        public MemberBusinessSharesViewModel ViewModel => (MemberBusinessSharesViewModel)DataContext;

        public MemberBusinessSharesAdminWindow(int mgnr) {
            InitializeComponent();
            using var ctx = new AppDbContext();
            ViewModel.FilterMember = ctx.Members.Find(mgnr) ?? throw new ArgumentException("MgNr argument has invalid value");
            ViewModel.Title = $"Geschäftsanteilbewegungen - {ViewModel.FilterMember.AdministrativeName} - Elwig";
            ExemptInputs = [
                MemberHistoryList, TotalAmountInput
            ];
            RequiredInputs = [
                ReasonInput, DateNoticeInput, DateEffeciveInput, SharesInput
           ];
        }

        public void FocusMemberHistory(int histnr) {
            if (IsEditing || IsCreating) return;
            var item = ViewModel.History.FirstOrDefault(h => h.HistNr == histnr);
            if (item != null) {
                ControlUtils.SelectItem(MemberHistoryList, item);
            }
        }

        private async Task RefreshList() {
            var vm = ViewModel;
            var cursor = Mouse.OverrideCursor != null;
            if (!cursor) Mouse.OverrideCursor = Cursors.Wait;
            var history = await Task.Run(async () => {
                using var ctx = new AppDbContext();
                return await ctx.MemberHistory
                    .Where(h => h.FromMgNr == vm.FilterMember.MgNr || h.ToMgNr == vm.FilterMember.MgNr)
                    .OrderBy(h => h.DateNoticeString).ThenBy(h => h.HistNr)
                    .ToListAsync();
            });
            if (!cursor) Mouse.OverrideCursor = null;
            history.ForEach(h => h.PoVMgNr = vm.FilterMember.MgNr);

            ControlUtils.RenewItemsSource(MemberHistoryList, history,
                MemberHistoryList_SelectionChanged, ControlUtils.RenewSourceDefault.None);
            RefreshInputs();
        }


        private void RefreshInputs(bool validate = false) {
            ClearInputStates();
            if (ViewModel.SelectedHistoryEntry is MemberHistory h) {
                EditHistoryButton.IsEnabled = true;
                DeleteHistoryButton.IsEnabled = true;
                FillInputs(h);
            } else {
                EditHistoryButton.IsEnabled = false;
                DeleteHistoryButton.IsEnabled = false;
                ClearOriginalValues();
                ClearDefaultValues();
                ClearInputs(validate);
                ClearInputStates();
            }
            GC.Collect();
        }

        private void FillInputs(MemberHistory h) {
            ClearOriginalValues();
            ClearDefaultValues();
            ViewModel.FillInputs(h);
            ReasonInput.SelectedValue = h.Reason + (h.Reason == MemberHistory.REASON_TRANSFER ? $"_{(h.FromMgNr == ViewModel.FilterMember.MgNr ? "to" : "from")}" : "");
            FinishInputFilling();
        }

        private async Task InitInputs() {
            ClearOriginalValues();
            ClearDefaultValues();
            await ViewModel.InitInputs();
            SetDefaultValue(DateNoticeInput);
            if (ViewModel.ValuePerShare != null)
                SetDefaultValue(ValuePerShareInput);
            ValidateRequiredInputs();
        }

        new protected void ClearInputs(bool validate = false) {
            ViewModel.ClearInputs();
            base.ClearInputs(validate);
        }

        override protected void UpdateButtons() {
            if (!IsEditing && !IsCreating) return;
            bool ch = HasChanged, v = IsValid;
            ResetButton.IsEnabled = ch;
            SaveButton.IsEnabled = v && ch;
        }

        protected override async Task OnRenewContext(AppDbContext ctx) {
            await base.OnRenewContext(ctx);

            if (await ctx.FetchMembers(ViewModel.FilterMember.MgNr).SingleOrDefaultAsync() is not Member m) {
                Close();
                return;
            }
            ViewModel.FilterMember = m;
            ViewModel.Title = $"Geschäftsanteilbewegungen - {ViewModel.FilterMember.AdministrativeName} - Elwig";

            ControlUtils.RenewItemsSource(OtherMemberInput, await ctx.FetchMembers(includeNotActive: true).ToListAsync());

            MemberInfo.Text = $"{m.FullAdministrativeName}\nGA: {m.Shares:N0} (normal) / {m.SharesRed:N0} (rot) / {m.SharesWhite:N0} (weiß) / {m.SharesDormant:N0} (ruhend)";

            await RefreshList();
        }

        private void MemberHistoryList_SelectionChanged(object? sender, SelectionChangedEventArgs? evt) {
            RefreshInputs();
        }

        protected override void ShortcutNew() {
            if (!NewHistoryButton.IsEnabled || NewHistoryButton.Visibility != Visibility.Visible)
                return;
            NewHistoryButton_Click(null, null);
        }

        private async void NewHistoryButton_Click(object? sender, RoutedEventArgs? evt) {
            IsCreating = true;
            MemberHistoryList.IsEnabled = false;
            ViewModel.SelectedHistoryEntry = null;
            HideNewEditDeleteButtons();
            ShowSaveResetCancelButtons();
            UnlockInputs();
            await InitInputs();
            DeductInput.IsEnabled = false;
            OtherMgNrInput.IsEnabled = false;
            OtherMemberInput.IsEnabled = false;
        }

        protected override void ShortcutEdit() {
            if (!EditHistoryButton.IsEnabled || EditHistoryButton.Visibility != Visibility.Visible)
                return;
            EditHistoryButton_Click(null, null);
        }

        private void EditHistoryButton_Click(object? sender, RoutedEventArgs? evt) {
            if (ViewModel.SelectedHistoryEntry == null) return;

            IsEditing = true;
            MemberHistoryList.IsEnabled = false;

            HideNewEditDeleteButtons();
            ShowSaveResetCancelButtons();
            UnlockInputs();

            DeductInput.IsEnabled = ViewModel.Reason == MemberHistory.REASON_PURCHASE || ViewModel.Reason == MemberHistory.REASON_PRESCRIPTION;
            OtherMgNrInput.IsEnabled = ViewModel.Reason?.StartsWith(MemberHistory.REASON_TRANSFER) ?? false;
            OtherMemberInput.IsEnabled = OtherMgNrInput.IsEnabled;
        }

        protected override void ShortcutDelete() {
            if (!DeleteHistoryButton.IsEnabled || DeleteHistoryButton.Visibility != Visibility.Visible)
                return;
            DeleteHistoryButton_Click(null, null);
        }

        private async void DeleteHistoryButton_Click(object? sender, RoutedEventArgs? evt) {
            if (ViewModel.SelectedHistoryEntry is not MemberHistory h)
                return;

            if (InteractionService.AskContinueYesNo("Geschäftsanteilbewegung löschen", $"Soll die Geschäftsanteilbewegung wirklich unwiderruflich\ngelöscht werden?\n\nFalls ja:\nSoll die Änderung der aktuellen GA wieder rückgängig gemacht werden?") is bool enableTriggers) {
                Mouse.OverrideCursor = Cursors.Wait;
                try {
                    await MemberBusinessSharesService.DeleteMemberHistory(h.HistNr, enableTriggers);
                    App.HintContextChange();
                } catch (Exception exc) {
                    InteractionService.ShowDbException("Geschäftsanteilbewegung löschen", exc);
                }
                Mouse.OverrideCursor = null;
            }
        }

        protected override void ShortcutSave() {
            if (!SaveButton.IsEnabled || SaveButton.Visibility != Visibility.Visible)
                return;
            SaveButton_Click(null, null);
        }

        private async void SaveButton_Click(object? sender, RoutedEventArgs? evt) {
            Mouse.OverrideCursor = Cursors.Wait;
            SaveButton.IsEnabled = false;

            int mgnr;
            try {
                mgnr = await ViewModel.UpdateMemberHistory(ViewModel.SelectedHistoryEntry?.HistNr, IsEditing || ViewModel.DateNotice >= DateOnly.FromDateTime(Utils.Today).AddDays(-14));
                App.HintContextChange();
            } catch (Exception exc) {
                InteractionService.ShowDbException("Geschäftsanteilbewegung aktualisieren", exc);
                SaveButton.IsEnabled = true;
                Mouse.OverrideCursor = null;
                return;
            }

            IsEditing = false;
            IsCreating = false;
            MemberHistoryList.IsEnabled = true;
            OtherMgNrInput.IsEnabled = true;
            HideSaveResetCancelButtons();
            ShowNewEditDeleteButtons();
            LockInputs();
            FinishInputFilling();
            await EnsureContextRenewed();
            Mouse.OverrideCursor = null;
            if (mgnr is int m)
                FocusMemberHistory(m);
        }

        protected override void ShortcutReset() {
            if (!ResetButton.IsEnabled || ResetButton.Visibility != Visibility.Visible)
                return;
            ResetButton_Click(null, null);
        }

        private async void ResetButton_Click(object? sender, RoutedEventArgs? evt) {
            if (IsEditing) {
                RefreshInputs();
            } else if (IsCreating) {
                ClearInputs();
                await InitInputs();
            }
            UpdateButtons();
        }

        private void CancelButton_Click(object sender, RoutedEventArgs evt) {
            IsEditing = false;
            IsCreating = false;
            MemberHistoryList.IsEnabled = true;
            OtherMgNrInput.IsEnabled = true;
            HideSaveResetCancelButtons();
            ShowNewEditDeleteButtons();
            RefreshInputs();
            LockInputs();
        }

        private void ShowSaveResetCancelButtons() {
            SaveButton.IsEnabled = false;
            ResetButton.IsEnabled = false;
            CancelButton.IsEnabled = true;
            ViewModel.EditingButtonsVisibility = Visibility.Visible;
        }

        private void HideSaveResetCancelButtons() {
            SaveButton.IsEnabled = false;
            ResetButton.IsEnabled = false;
            CancelButton.IsEnabled = false;
            ViewModel.EditingButtonsVisibility = Visibility.Hidden;
        }

        private void ShowNewEditDeleteButtons() {
            NewHistoryButton.IsEnabled = true;
            EditHistoryButton.IsEnabled = ViewModel.SelectedHistoryEntry != null;
            DeleteHistoryButton.IsEnabled = ViewModel.SelectedHistoryEntry != null;
            ViewModel.ControlButtonsVisibility = Visibility.Visible;
        }

        private void HideNewEditDeleteButtons() {
            NewHistoryButton.IsEnabled = false;
            EditHistoryButton.IsEnabled = false;
            DeleteHistoryButton.IsEnabled = false;
            ViewModel.ControlButtonsVisibility = Visibility.Hidden;
        }

        private void OtherMgNrInput_TextChanged(object sender, TextChangedEventArgs evt) {
            var valid = InputTextChanged((TextBox)sender, Validator.CheckMgNr);
            var text = OtherMgNrInput.Text;
            var caret = OtherMgNrInput.CaretIndex;
            ControlUtils.SelectItemWithPk(OtherMemberInput, valid ? ViewModel.OtherMgNr : null);
            OtherMgNrInput.Text = text;
            OtherMgNrInput.CaretIndex = caret;
        }

        private void OtherMgNrInput_LostFocus(object sender, RoutedEventArgs evt) {
            var valid = InputLostFocus((TextBox)sender, Validator.CheckMgNr);
            ControlUtils.SelectItemWithPk(OtherMemberInput, valid ? ViewModel.OtherMgNr : null);
        }

        private void OtherMemberInput_SelectionChanged(object? sender, SelectionChangedEventArgs? evt) {
            var m = OtherMemberInput.SelectedItem as Member;
            ViewModel.OtherMgNr = m?.MgNr;
        }

        private void OtherMemberReferenceButton_Click(object sender, RoutedEventArgs evt) {
            if (OtherMemberInput.SelectedItem is not Member m) return;
            App.FocusMember(m.MgNr);
        }

        private void ReasonInput_SelectionChanged(object sender, RoutedEventArgs evt) {
            ComboBox_SelectionChanged(sender, evt);
            if (!IsEditing && !IsCreating) return;
            if (ViewModel.DateNotice is not DateOnly d) return;
            if (ViewModel.Reason == MemberHistory.REASON_EXCLUSION || ViewModel.Reason == MemberHistory.REASON_DECEASED || ViewModel.Reason == MemberHistory.REASON_RETIREMENT) {
                ViewModel.DateEffectiveString = $"31.12.{d.Year + 1}";
            } else {
                ViewModel.DateEffectiveString = ViewModel.DateNoticeString;
            }
            DeductInput.IsEnabled = ViewModel.Reason == MemberHistory.REASON_PURCHASE || ViewModel.Reason == MemberHistory.REASON_PRESCRIPTION;
            if (!DeductInput.IsEnabled) DeductInput.IsChecked = false;
            OtherMgNrInput.IsEnabled = ViewModel.Reason?.StartsWith(MemberHistory.REASON_TRANSFER) ?? false;
            OtherMemberInput.IsEnabled = OtherMgNrInput.IsEnabled;
            if (!OtherMgNrInput.IsEnabled) OtherMgNrInput.Text = "";
        }

        private void DateNoticeInput_TextChanged(object sender, TextChangedEventArgs evt) {
            DateInput_TextChanged(sender, evt);
            if (!IsEditing && !IsCreating) return;
            if (ViewModel.DateNotice is not DateOnly d) return;
            ViewModel.DeductYear = d.Year;
            if (ViewModel.DateEffective == null && ViewModel.Reason != null) {
                if (ViewModel.Reason == MemberHistory.REASON_EXCLUSION || ViewModel.Reason == MemberHistory.REASON_DECEASED || ViewModel.Reason == MemberHistory.REASON_RETIREMENT) {
                    ViewModel.DateEffectiveString = $"31.12.{d.Year + 1}";
                } else {
                    ViewModel.DateEffectiveString = ViewModel.DateNoticeString;
                }
            }
        }

        private void UpdateAmount() {
            ViewModel.TotalAmount = $"{ViewModel.Shares * ViewModel.ValuePerShare:N2}";
        }

        private void SharesInput_TextChanged(object sender, TextChangedEventArgs evt) {
            IntegerInput_TextChanged(sender, evt);
            UpdateAmount();
        }

        private void AmountPerShareInput_TextChanged(object sender, TextChangedEventArgs evt) {
            InputTextChanged((TextBox)sender, Validator.CheckDecimal((TextBox)sender, false, 3, 2));
            UpdateAmount();
        }
    }
}