using DevExpress.XtraGrid.Views.Grid;
using DevExpress.XtraGrid.Views.BandedGrid;
using DevExpress.XtraTab;
using Lskj.Control.ZKFinger;
using Lskj.Model;
using Lskj.Util;
using System;
using System.Collections.Generic;
using System.Data;
using System.Runtime.CompilerServices;
using System.Windows.Forms;
using WinFormsControl = System.Windows.Forms.Control;

namespace Lskj.Control.Model
{
    /// <summary>
    /// WinForms-owned runtime state. A module registers the objects it creates
    /// while it is being opened; closing a module disposes only that module's
    /// scope. This deliberately has no control-tree traversal.
    /// </summary>
    public static class StaticControl
    {
        private static readonly object ModuleRegistrySync = new object();

        /// <summary>
        /// Owns cleanup callbacks for one opened module instance.
        /// </summary>
        public sealed class ModuleResourceScope : IDisposable
        {
            private sealed class Registration
            {
                internal readonly object Owner;
                internal readonly Action Cleanup;

                internal Registration(object owner, Action cleanup)
                {
                    Owner = owner;
                    Cleanup = cleanup;
                }
            }

            private readonly object _sync = new object();
            private readonly List<Registration> _registrations =
                new List<Registration>();
            private bool _disposed;

            public ModuleResourceScope(string moduleId)
            {
                ModuleId = moduleId ?? string.Empty;
                TrackModuleScope(this);
            }

            public string ModuleId { get; private set; }

            public bool IsDisposed
            {
                get
                {
                    lock (_sync)
                    {
                        return _disposed;
                    }
                }
            }

            public void Register(object owner, Action cleanup)
            {
                if (cleanup == null)
                    return;

                bool runImmediately = false;
                lock (_sync)
                {
                    if (_disposed)
                        runImmediately = true;
                    else
                        _registrations.Add(new Registration(owner, cleanup));
                }

                if (runImmediately)
                    InvokeCleanup(cleanup);
            }

            public void Unregister(object owner)
            {
                lock (_sync)
                {
                    for (int index = _registrations.Count - 1; index >= 0; index--)
                        if (ReferenceEquals(_registrations[index].Owner, owner))
                            _registrations.RemoveAt(index);
                }
            }

            public void Dispose()
            {
                List<Registration> registrations;
                lock (_sync)
                {
                    if (_disposed)
                        return;

                    _disposed = true;
                    registrations = new List<Registration>(_registrations);
                    _registrations.Clear();
                }

                // Reverse order mirrors normal ownership: the last registered
                // helper is released before its owner.
                for (int index = registrations.Count - 1; index >= 0; index--)
                    InvokeCleanup(registrations[index].Cleanup);

                UntrackModuleScope(this);
            }

            private static void InvokeCleanup(Action cleanup)
            {
                try
                {
                    cleanup();
                }
                catch (Exception exception)
                {
                    System.Diagnostics.Debug.WriteLine(
                        "释放模块登记资源失败：" + exception);
                }
            }
        }

        private static void TrackModuleScope(ModuleResourceScope scope)
        {
            if (scope == null)
                return;

            lock (ActiveModuleScopesSync)
            {
                if (!ActiveModuleScopes.Contains(scope))
                    ActiveModuleScopes.Add(scope);
            }
        }

        private static void UntrackModuleScope(ModuleResourceScope scope)
        {
            if (scope == null)
                return;

            lock (ActiveModuleScopesSync)
            {
                ActiveModuleScopes.Remove(scope);
            }
        }

        /// <summary>
        /// Releases scopes created by legacy page-open paths that are not
        /// present in Manager.ModuleScopes. Dispose is idempotent, so this is
        /// safe to call after the managed module close pass.
        /// </summary>
        public static void CompleteAllModuleResourceScopes()
        {
            ModuleResourceScope[] scopes;
            lock (ActiveModuleScopesSync)
            {
                scopes = ActiveModuleScopes.ToArray();
            }

            foreach (ModuleResourceScope scope in scopes)
            {
                if (scope != null)
                    scope.Dispose();
            }
        }

        private sealed class ScopeCookie : IDisposable
        {
            private readonly ModuleResourceScope _previous;
            private bool _disposed;

            internal ScopeCookie(ModuleResourceScope previous)
            {
                _previous = previous;
            }

            public void Dispose()
            {
                if (_disposed)
                    return;

                _disposed = true;
                _currentModuleScope = _previous;
            }
        }

        [ThreadStatic]
        private static ModuleResourceScope _currentModuleScope;

        // The table does not keep a disposed control alive. A short parent
        // chain lookup is used only for controls created after PushModuleScope;
        // there is never a global scan of the module's control tree.
        private static readonly ConditionalWeakTable<WinFormsControl, ModuleResourceScope>
            ModuleScopeOwners =
                new ConditionalWeakTable<WinFormsControl, ModuleResourceScope>();
        private static readonly object ActiveModuleScopesSync = new object();
        private static readonly List<ModuleResourceScope> ActiveModuleScopes =
            new List<ModuleResourceScope>();
        private static readonly Dictionary<string, MyControl> ModuleSearchControls =
            new Dictionary<string, MyControl>(StringComparer.OrdinalIgnoreCase);

        public static ModuleResourceScope CurrentModuleScope
        {
            get { return _currentModuleScope; }
        }

        public static IDisposable PushModuleScope(ModuleResourceScope scope)
        {
            ModuleResourceScope previous = _currentModuleScope;
            _currentModuleScope = scope != null && !scope.IsDisposed ? scope : null;
            return new ScopeCookie(previous);
        }

        private static ModuleResourceScope GetLiveCurrentModuleScope()
        {
            return _currentModuleScope != null && !_currentModuleScope.IsDisposed
                ? _currentModuleScope
                : null;
        }

        public static void AttachModuleScope(
            WinFormsControl owner,
            ModuleResourceScope scope)
        {
            if (owner == null || scope == null || scope.IsDisposed)
                return;

            ModuleScopeOwners.Remove(owner);
            ModuleScopeOwners.Add(owner, scope);
        }

        /// <summary>
        /// Finds a scope attached to the owner or one of its parents without
        /// falling back to the calling thread's current scope.
        /// </summary>
        public static ModuleResourceScope FindAttachedModuleScope(
            WinFormsControl owner)
        {
            ModuleResourceScope scope = FindParentModuleScope(owner);
            if (scope != null)
                return scope;

            if (owner != null && ModuleScopeOwners.TryGetValue(owner, out scope) &&
                scope != null && !scope.IsDisposed)
                return scope;
            return null;
        }

        public static ModuleResourceScope FindModuleScope(WinFormsControl owner)
        {
            ModuleResourceScope parentScope = FindParentModuleScope(owner);
            if (parentScope != null)
                return parentScope;

            ModuleResourceScope scope;
            if (owner != null && ModuleScopeOwners.TryGetValue(owner, out scope) &&
                scope != null && !scope.IsDisposed)
                return scope;
            return _currentModuleScope != null && !_currentModuleScope.IsDisposed
                ? _currentModuleScope
                : null;
        }

        /// <summary>
        /// Registers a page created by a legacy caller that cannot go through
        /// Manager.AddModuleToTab. The page GUID is made the module GUID as
        /// well, and the page/form roots are attached to one scope so the
        /// normal close path can discover and dispose that scope.
        /// </summary>
        public static ModuleResourceScope RegisterModulePage(
            DllModule module,
            XtraTabPage page,
            Form form)
        {
            if (page == null)
                return null;

            string moduleId = Convert.ToString(page.Tag);
            if (string.IsNullOrWhiteSpace(moduleId))
            {
                moduleId = Guid.NewGuid().ToString();
                page.Tag = moduleId;
            }

            if (module != null)
            {
                module.Tag = moduleId;
                if (form != null)
                    module.ModuleForm = form;
            }

            ModuleResourceScope scope = FindAttachedModuleScope(form) ??
                FindAttachedModuleScope(page);
            if (scope == null)
                scope = new ModuleResourceScope(moduleId);

            AttachModuleScope(page, scope);
            AttachModuleScope(form, scope);
            scope.Register(page, () =>
            {
                if (!page.IsDisposed)
                    page.Dispose();
            });
            if (form != null)
            {
                scope.Register(form, () =>
                {
                    if (!form.IsDisposed)
                        form.Dispose();
                });
            }
            return scope;
        }

        public static void RegisterModuleResource(
            object owner,
            Action cleanup)
        {
            RegisterModuleResource(owner, owner as WinFormsControl, cleanup);
        }

        public static void RegisterModuleResource(
            object owner,
            WinFormsControl context,
            Action cleanup)
        {
            ModuleResourceScope scope = null;
            if (context != null)
                scope = FindModuleScope(context);
            if (scope == null)
                scope = GetLiveCurrentModuleScope();
            if (scope != null)
                scope.Register(owner, cleanup);
        }

        /// <summary>
        /// Registers one visual control as owned by its current module. A
        /// ParentChanged subscription updates ownership when the same control
        /// is explicitly moved to another live module; it never walks children.
        /// </summary>
        public static void RegisterOwnedControl(WinFormsControl owner)
        {
            if (owner == null)
                return;

            // A legacy control can be constructed before it is parented. Keep
            // one exact ParentChanged hook so ownership is registered as soon
            // as it joins a module, including controls prepared off the UI path.
            owner.ParentChanged -= OnOwnedControlParentChanged;
            owner.ParentChanged += OnOwnedControlParentChanged;

            ModuleResourceScope scope = GetLiveCurrentModuleScope();
            if (scope == null)
                scope = FindParentModuleScope(owner);
            if (scope == null)
                return;

            ModuleResourceScope existing;
            if (ModuleScopeOwners.TryGetValue(owner, out existing) &&
                ReferenceEquals(existing, scope))
            {
                return;
            }

            AttachModuleScope(owner, scope);
            scope.Register(owner, () =>
            {
                // A complete subtree may have been moved to another module
                // without changing every descendant's Parent. Follow the live
                // parent scope and leave that subtree owned by the open module.
                ModuleResourceScope parentScope = FindParentModuleScope(owner);
                if (parentScope != null && !ReferenceEquals(parentScope, scope))
                {
                    ModuleResourceScope previous = _currentModuleScope;
                    _currentModuleScope = parentScope;
                    try
                    {
                        RegisterOwnedControl(owner);
                    }
                    finally
                    {
                        _currentModuleScope = previous;
                    }
                    return;
                }

                ModuleResourceScope current;
                if (!ModuleScopeOwners.TryGetValue(owner, out current) ||
                    !ReferenceEquals(current, scope))
                {
                    return;
                }

                owner.ParentChanged -= OnOwnedControlParentChanged;
                ModuleScopeOwners.Remove(owner);
                if (!owner.IsDisposed)
                    owner.Dispose();
            });
        }

        private static ModuleResourceScope FindParentModuleScope(WinFormsControl owner)
        {
            for (WinFormsControl current = owner == null ? null : owner.Parent;
                current != null;
                current = current.Parent)
            {
                ModuleResourceScope scope;
                if (ModuleScopeOwners.TryGetValue(current, out scope) &&
                    scope != null && !scope.IsDisposed)
                    return scope;
            }
            return null;
        }

        private static void OnOwnedControlParentChanged(object sender, EventArgs args)
        {
            WinFormsControl owner = sender as WinFormsControl;
            if (owner == null || owner.IsDisposed)
                return;

            ModuleResourceScope parentScope = FindParentModuleScope(owner);
            ModuleResourceScope currentScope;
            if (parentScope != null &&
                (!ModuleScopeOwners.TryGetValue(owner, out currentScope) ||
                 !ReferenceEquals(parentScope, currentScope)))
            {
                ModuleResourceScope previous = _currentModuleScope;
                _currentModuleScope = parentScope;
                try
                {
                    RegisterOwnedControl(owner);
                }
                finally
                {
                    _currentModuleScope = previous;
                }
            }
        }

        public static void RegisterModuleSearchControl(
            WinFormsControl context,
            MyControl searchControl)
        {
            if (searchControl == null)
                return;

            ModuleResourceScope scope = context == null
                ? GetLiveCurrentModuleScope()
                : FindModuleScope(context);
            if (scope == null || string.IsNullOrWhiteSpace(scope.ModuleId))
                return;

            string moduleId = scope.ModuleId;
            lock (ModuleRegistrySync)
            {
                MyControl existing;
                if (ModuleSearchControls.TryGetValue(moduleId, out existing))
                {
                    if (ReferenceEquals(existing, searchControl))
                        return;
                    if (existing != null && !existing.IsDisposed)
                        return;
                    ModuleSearchControls.Remove(moduleId);
                }
                ModuleSearchControls[moduleId] = searchControl;
            }
            EventHandler disposed = null;
            disposed = (sender, args) =>
            {
                searchControl.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    MyControl current;
                    if (ModuleSearchControls.TryGetValue(moduleId, out current) &&
                        ReferenceEquals(current, searchControl))
                    {
                        ModuleSearchControls.Remove(moduleId);
                    }
                }
            };
            searchControl.Disposed += disposed;
            scope.Register(searchControl, () =>
            {
                searchControl.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    MyControl current;
                    if (ModuleSearchControls.TryGetValue(moduleId, out current) &&
                        ReferenceEquals(current, searchControl))
                    {
                        ModuleSearchControls.Remove(moduleId);
                    }
                }
            });
        }

        public static MyControl FindModuleSearchControl(string moduleId)
        {
            if (string.IsNullOrWhiteSpace(moduleId))
                return null;

            lock (ModuleRegistrySync)
            {
                MyControl searchControl;
                if (!ModuleSearchControls.TryGetValue(moduleId, out searchControl))
                    return null;
                if (searchControl == null || searchControl.IsDisposed)
                {
                    ModuleSearchControls.Remove(moduleId);
                    return null;
                }
                return searchControl;
            }
        }

        public static void RegisterConditionPanel(
            string key,
            ModuleConditionsPanelEx panel)
        {
            if (panel == null)
                return;

            key = key ?? string.Empty;
            lock (ModuleRegistrySync)
            {
                ModuleConditionsPanelEx previous;
                if (ConditionsPanelDic.TryGetValue(key, out previous) &&
                    previous != null && previous.IsDisposed)
                {
                    ConditionsPanelDic.Remove(key);
                }

                // A key can be reused by a second module instance. Never
                // dispose the first live dialog from the second registration.
                ConditionsPanelDic[key] = panel;
            }
            EventHandler disposed = null;
            disposed = (sender, args) =>
            {
                panel.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    ModuleConditionsPanelEx current;
                    if (ConditionsPanelDic.TryGetValue(key, out current) &&
                        ReferenceEquals(current, panel))
                    {
                        ConditionsPanelDic.Remove(key);
                    }
                }
            };
            panel.Disposed += disposed;
            RegisterModuleResource(panel, panel, () =>
            {
                panel.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    ModuleConditionsPanelEx current;
                    if (ConditionsPanelDic.TryGetValue(key, out current) &&
                        ReferenceEquals(current, panel))
                    {
                        ConditionsPanelDic.Remove(key);
                    }
                }
                if (!panel.IsDisposed)
                {
                    panel.Dispose();
                }
            });
        }

        public static void RegisterProtectedPage(XtraTabPage page)
        {
            if (page == null)
                return;
            lock (ModuleRegistrySync)
            {
                if (!DogVerifyModuleForms.Contains(page))
                    DogVerifyModuleForms.Add(page);
            }

            EventHandler disposed = null;
            disposed = (sender, args) =>
            {
                page.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    DogVerifyModuleForms.Remove(page);
                }
            };
            page.Disposed += disposed;
            RegisterModuleResource(page, () =>
            {
                page.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    DogVerifyModuleForms.Remove(page);
                }
            });
        }

        public static void RegisterProtectedForm(IForm form)
        {
            if (form == null || form.SubForm == null)
                return;
            lock (ModuleRegistrySync)
            {
                if (!DogVerifyNoPageForms.Contains(form))
                    DogVerifyNoPageForms.Add(form);
            }

            Form subForm = form.SubForm;
            EventHandler disposed = null;
            disposed = (sender, args) =>
            {
                subForm.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    DogVerifyNoPageForms.Remove(form);
                }
            };
            subForm.Disposed += disposed;
            RegisterModuleResource(subForm, () =>
            {
                subForm.Disposed -= disposed;
                lock (ModuleRegistrySync)
                {
                    DogVerifyNoPageForms.Remove(form);
                }
            });
        }

        internal static void ReleaseGridViewReferences(GridView gridView)
        {
            if (gridView == null)
                return;

            GridDragGrid.DisposeRegistrations(
                GridViewDragGridDic,
                TargetViewDragGridDic,
                gridView);
            BandedGridDragGrid.DisposeRegistrations(
                StaticBandedControl.BandedGridViewDragGridDic,
                StaticBandedControl.BandedTargetViewDragGridDic,
                gridView as BandedGridView,
                gridView);
            GridDragGrid.ClearSourceReferenceIfUnused(gridView);
            if (ReferenceEquals(_RightMenuGridView, gridView))
                RightMenuGridView = null;
        }

        private static void OnRightMenuGridViewDisposed(object sender, EventArgs args)
        {
            GridView view = sender as GridView;
            if (ReferenceEquals(_RightMenuGridView, view))
                RightMenuGridView = null;
        }

        private static void OnBomUnionPageDisposed(object sender, EventArgs args)
        {
            XtraTabPage page = sender as XtraTabPage;
            if (ReferenceEquals(BomUnionPage, page))
                SetBomUnionPage(null);
        }

        private static void OnRightMenuMyControlDisposed(object sender, EventArgs args)
        {
            MyControl control = sender as MyControl;
            if (ReferenceEquals(RightMenuMyControl, control))
                SetRightMenuMyControl(null);
        }

        private static void OnAddParentGridDisposed(object sender, EventArgs args)
        {
            GridControlEx grid = sender as GridControlEx;
            if (ReferenceEquals(AddParentGrid.Value, grid))
                SetAddParentGrid(new KeyValuePair<string, GridControlEx>());
        }

        /// <summary>
        /// 记录当前U盾权限窗口
        /// </summary>
        public static List<XtraTabPage> DogVerifyModuleForms =
            new List<XtraTabPage>();
        public static List<IForm> DogVerifyNoPageForms =
            new List<IForm>();

        /// <summary>
        /// 模块打开时的条件界面
        /// </summary>
        public static Dictionary<string, ModuleConditionsPanelEx> ConditionsPanelDic =
            new Dictionary<string, ModuleConditionsPanelEx>();

        /// <summary>
        /// 表格拖拽类，key值为源表
        /// </summary>
        public static Dictionary<GridView, List<GridDragGrid>> GridViewDragGridDic =
            new Dictionary<GridView, List<GridDragGrid>>();
        /// <summary>
        /// 表格拖拽类，key值为目标表
        /// </summary>
        public static Dictionary<GridView, List<GridDragGrid>> TargetViewDragGridDic =
            new Dictionary<GridView, List<GridDragGrid>>();
        /// <summary>
        /// 当前拖拽源表格
        /// </summary>
        public static GridView SourceDragGridView;
        /// <summary>
        /// 指纹识别模块
        /// </summary>
        public static FingerHelper fingerHelper;

        public static KeyValuePair<string, GridControlEx> AddParentGrid =
            new KeyValuePair<string, GridControlEx>();
        public static void SetAddParentGrid(
            KeyValuePair<string, GridControlEx> value)
        {
            if (ReferenceEquals(AddParentGrid.Value, value.Value) &&
                string.Equals(AddParentGrid.Key, value.Key, StringComparison.Ordinal))
            {
                return;
            }

            GridControlEx previous = AddParentGrid.Value;
            if (previous != null)
                previous.Disposed -= OnAddParentGridDisposed;

            AddParentGrid = value;
            GridControlEx current = value.Value;
            if (current == null)
                return;

            current.Disposed += OnAddParentGridDisposed;
            RegisterModuleResource(current, () =>
            {
                current.Disposed -= OnAddParentGridDisposed;
                if (ReferenceEquals(AddParentGrid.Value, current))
                    AddParentGrid = new KeyValuePair<string, GridControlEx>();
            });
        }

        /// <summary>
        /// 当前右键点击时的表格
        /// </summary>
        public static GridView _RightMenuGridView;
        public static GridView RightMenuGridView
        {
            get { return _RightMenuGridView; }
            set
            {
                if (ReferenceEquals(_RightMenuGridView, value))
                {
                    Comprefix = string.Empty;
                    ReturnRowLisy.Clear();
                    return;
                }

                if (_RightMenuGridView != null)
                    _RightMenuGridView.Disposed -= OnRightMenuGridViewDisposed;

                _RightMenuGridView = value;
                Comprefix = string.Empty;
                ReturnRowLisy.Clear();
                if (value == null)
                    return;

                value.Disposed += OnRightMenuGridViewDisposed;
                RegisterModuleResource(
                    value,
                    value.GridControl as WinFormsControl,
                    () =>
                {
                    value.Disposed -= OnRightMenuGridViewDisposed;
                    if (ReferenceEquals(_RightMenuGridView, value))
                        _RightMenuGridView = null;
                });
            }
        }

        /// <summary>
        /// bom附件修改时的关联页签
        /// </summary>
        public static XtraTabPage BomUnionPage;
        public static void SetBomUnionPage(XtraTabPage value)
        {
            if (ReferenceEquals(BomUnionPage, value))
                return;

            if (BomUnionPage != null)
                BomUnionPage.Disposed -= OnBomUnionPageDisposed;

            BomUnionPage = value;
            if (value == null)
                return;

            value.Disposed += OnBomUnionPageDisposed;
            RegisterModuleResource(value, () =>
            {
                value.Disposed -= OnBomUnionPageDisposed;
                if (ReferenceEquals(BomUnionPage, value))
                    BomUnionPage = null;
            });
        }

        /// <summary>
        /// 当前右键点击时的控件对象
        /// </summary>
        public static MyControl RightMenuMyControl;
        public static void SetRightMenuMyControl(MyControl value)
        {
            if (ReferenceEquals(RightMenuMyControl, value))
                return;

            if (RightMenuMyControl != null)
                RightMenuMyControl.Disposed -= OnRightMenuMyControlDisposed;

            RightMenuMyControl = value;
            if (value == null)
                return;

            value.Disposed += OnRightMenuMyControlDisposed;
            RegisterModuleResource(
                value,
                value.MainGridEx,
                () =>
            {
                value.Disposed -= OnRightMenuMyControlDisposed;
                if (ReferenceEquals(RightMenuMyControl, value))
                    RightMenuMyControl = null;
            });
        }

        /// <summary>
        /// 当前右键点击时的表格的列前缀
        /// </summary>
        public static string Comprefix;
        /// <summary>
        /// 浏览器返回数据
        /// </summary>
        public static List<DataRow> ReturnRowLisy = new List<DataRow>();
    }
}