using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
using InkCanvasForClass.IccInkCanvas.Settings;
using InkCanvasForClass.IccInkCanvas.Utils.Threading;
using JetBrains.Annotations;
using MatrixTransform = System.Windows.Media.MatrixTransform;

namespace InkCanvasForClass.IccInkCanvas {

    public class IccInnerInkCanvasInfo {
        public Guid GUID { get; set; }
        public Dispatcher Dispatcher { get; set; }
        public DispatcherContainer Container { get; set; }
    }

    public class TimeMachineStatusUpdatedEventArgs : EventArgs {
        public TimeMachineStatusUpdatedEventArgs(IccBoardPage page) {
            Page = page;
            CanUndo = page.TimeMachine.CanUndo;
            CanRedo = page.TimeMachine.CanRedo;
            HistoriesCount = page.TimeMachine.CurrentHistoriesCount;
        }

        public IccBoardPage Page { get; private set; }
        public bool CanUndo { get; private set; }
        public bool CanRedo { get; private set; }
        public int HistoriesCount { get; private set; }
    }

    /// <summary>
    /// 基于InkCanvas封装的墨迹书写控件
    /// </summary>
    public partial class IccBoard : UserControl {

        public BoardSettings BoardSettings { get; private set; } = new BoardSettings();

        private List<IccInnerInkCanvasInfo> DispatcherInkCanvasList { get; set; } =
            new List<IccInnerInkCanvasInfo>();

        private List<IccBoardPage> BoardPages { get; set; } = new List<IccBoardPage>();

        private int CurrentPageIndex;

        #region Properties

        private bool _isEditingModePropertyAccessdByCodeBehind = false;
        public EditingMode EditingMode {
            get => (EditingMode)GetValue(EditingModeProperty);
            set {
                if (value == EditingMode.ShapeDrawing) throw new Exception("EditingMode.ShapeDrawing 不能被用户手动设定");
                _isEditingModePropertyAccessdByCodeBehind = true;
                SetValue(EditingModeProperty, value);
                _isEditingModePropertyAccessdByCodeBehind = false;
                UpdateEditingMode();
            }
        }
        public static readonly System.Windows.DependencyProperty EditingModeProperty =
            System.Windows.DependencyProperty.Register(
                nameof(EditingMode),
                typeof(EditingMode),
                typeof(IccBoard),
                new FrameworkPropertyMetadata(EditingMode.Writing,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    propertyChangedCallback: OnEditingModePropertyChanged));
        private static void OnEditingModePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
            var iccboard = d as IccBoard;
            if (iccboard != null && iccboard._isEditingModePropertyAccessdByCodeBehind) return;
            iccboard?.UpdateEditingMode();
        }

        #endregion

        #region EditingMode

        private EditingMode _edittingMode;

        private void UpdateEditingMode() {
            _edittingMode = EditingMode;
            if (EditingMode == EditingMode.None || EditingMode == EditingMode.NoneWithHitTest) 
                WrapperInkCanvas.EditingMode = InkCanvasEditingMode.None;
            IsHitTestVisible = EditingMode != EditingMode.None;
            if (EditingMode == EditingMode.Writing) WrapperInkCanvas.EditingMode = InkCanvasEditingMode.Ink;
            EraserCanvas.Visibility = EditingMode == EditingMode.GeometryErasing ? Visibility.Visible : Visibility.Collapsed;
            RectangleAreaEraserCanvas.Visibility =
                EditingMode == EditingMode.AreaErasing ? Visibility.Visible : Visibility.Collapsed;
            RoamingHitTestBorder.Visibility = EditingMode == EditingMode.RoamingMode ? Visibility.Visible : Visibility.Collapsed;
        }

        #endregion

        #region Events

        private static readonly System.Windows.RoutedEvent EditingModeChangedEvent = EventManager.RegisterRoutedEvent(
            name: "EditingModeChanged",
            routingStrategy: RoutingStrategy.Bubble,
            handlerType: typeof(System.Windows.RoutedEventHandler),
            ownerType: typeof(IccBoard));
        private static readonly System.Windows.RoutedEvent ActiveEditingModeChangedEvent = EventManager.RegisterRoutedEvent(
            name: "ActiveEditingModeChanged",
            routingStrategy: RoutingStrategy.Bubble,
            handlerType: typeof(System.Windows.RoutedEventHandler),
            ownerType: typeof(IccBoard));
        private static readonly System.Windows.RoutedEvent CurrentPageChangedEvent = EventManager.RegisterRoutedEvent(
            name: "CurrentPageChanged",
            routingStrategy: RoutingStrategy.Bubble,
            handlerType: typeof(System.Windows.RoutedEventHandler),
            ownerType: typeof(IccBoard));
        private static readonly System.Windows.RoutedEvent UndoRedoStateChangedEvent = EventManager.RegisterRoutedEvent(
            name: "UndoRedoStateChanged",
            routingStrategy: RoutingStrategy.Bubble,
            handlerType: typeof(System.Windows.RoutedEventHandler),
            ownerType: typeof(IccBoard));

        public event System.Windows.RoutedEventHandler EditingModeChanged {
            add => AddHandler(EditingModeChangedEvent, value);
            remove => RemoveHandler(EditingModeChangedEvent, value);
        }
        public event System.Windows.RoutedEventHandler ActiveEditingModeChanged {
            add => AddHandler(ActiveEditingModeChangedEvent, value);
            remove => RemoveHandler(ActiveEditingModeChangedEvent, value);
        }
        public event System.Windows.RoutedEventHandler CurrentPageChanged {
            add => AddHandler(CurrentPageChangedEvent, value);
            remove => RemoveHandler(CurrentPageChangedEvent, value);
        }
        /// <summary>
        /// 该事件接收撤销和重做状态变更的事件（注意，当前页面变更也会触发该事件。该事件接收每一页撤销和重做状态变更的事件，但是不提供具体是哪一页的时光机发生了状态变更，可以用这个事件来更新当前页面的时光机UI状态）
        /// </summary>
        public event System.Windows.RoutedEventHandler UndoRedoStateChanged {
            add => AddHandler(UndoRedoStateChangedEvent, value);
            remove => RemoveHandler(UndoRedoStateChangedEvent, value);
        }

        private bool isIgnoreRaiseCurrentPageChangedEvent = false;

        private void RaiseEditingModeChangedEvent() {
            RoutedEventArgs routedEventArgs = new RoutedEventArgs(routedEvent: EditingModeChangedEvent);
            RaiseEvent(routedEventArgs);
        }
        private void RaiseActiveEditingModeChangedEvent() {
            RoutedEventArgs routedEventArgs = new RoutedEventArgs(routedEvent: ActiveEditingModeChangedEvent);
            RaiseEvent(routedEventArgs);
        }
        private void RaiseCurrentPageChangedEvent() {
            if (isIgnoreRaiseCurrentPageChangedEvent) return;
            RoutedEventArgs routedEventArgs = new RoutedEventArgs(routedEvent: CurrentPageChangedEvent);
            RaiseEvent(routedEventArgs);
            RaiseUndoRedoStateChangedEvent(null);
        }
        private void RaiseUndoRedoStateChangedEvent(TimeMachine t) {
            RoutedEventArgs routedEventArgs = new RoutedEventArgs(routedEvent: UndoRedoStateChangedEvent);
            RaiseEvent(routedEventArgs);
            if (t != null) TimeMachineStatusUpdated?.Invoke(this, new TimeMachineStatusUpdatedEventArgs(BoardPages.Find(page=>page.TimeMachine.Equals(t))));
        }

        /// <summary>
        /// 该事件用于接收时光机状态变更的事件（接收所有页面的时光机状态变化）
        /// </summary>
        public event EventHandler<TimeMachineStatusUpdatedEventArgs> TimeMachineStatusUpdated;

        #endregion

        #region BoardSettings

        private void RegisterEventsForBoardSettings() {
            BoardSettings.NibWidthChanged += (s,e)=>WrapperInkCanvas.DefaultDrawingAttributes.Width = BoardSettings.NibWidth;
            BoardSettings.NibHeightChanged += (s,e)=>WrapperInkCanvas.DefaultDrawingAttributes.Height = BoardSettings.NibHeight;
            BoardSettings.NibColorChanged += (s,e)=>WrapperInkCanvas.DefaultDrawingAttributes.Color = BoardSettings.NibColor;
        }

        #endregion

        #region InkCanvas Manager

        /// <summary>
        /// 记录所有已注册了Strokes_OnStrokesChanged事件的InkCanvas的GUID
        /// </summary>
        private Dictionary<Guid, StrokeCollectionChangedEventHandler>
            _innerInkCanvas_Strokes_OnStrokesChanged_wrappers = new Dictionary<Guid, StrokeCollectionChangedEventHandler>();

        /// <summary>
        /// 记录所有已登记要触发Stroke_OnDrawingAttributesChanged事件的InkCanvas的GUID
        /// （为什么不是已注册？因为这个事件是针对一条Stroke而言的，这里只是记录这个InkCanvas将会调用这个事件）
        /// </summary>
        private Dictionary<Guid, PropertyDataChangedEventHandler>
            _innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers = new Dictionary<Guid, PropertyDataChangedEventHandler>();

        /// <summary>
        /// 记录所有已登记要触发Stroke_OnStylusPointsChanged事件的InkCanvas的GUID
        /// （为什么不是已注册？因为这个事件是针对一条Stroke而言的，这里只是记录这个InkCanvas将会调用这个事件）
        /// </summary>
        private Dictionary<Guid, EventHandler>
            _innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers = new Dictionary<Guid, EventHandler>();

        /// <summary>
        /// 记录所有已登记要触发Stroke_OnStylusPointsChanged事件的InkCanvas的GUID
        /// （为什么不是已注册？因为这个事件是针对一条Stroke而言的，这里只是记录这个InkCanvas将会调用这个事件）
        /// </summary>
        private Dictionary<Guid, StylusPointsReplacedEventHandler>
            _innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers = new Dictionary<Guid, StylusPointsReplacedEventHandler>();

        private async Task<IccInnerInkCanvasInfo> AddIccInkCanvas() {
            var screenW = SystemParameters.PrimaryScreenWidth;
            var screenH = SystemParameters.PrimaryScreenHeight;

            var fullWidth = screenW * 257;
            var fullHeight = screenH * 417;

            var left = 0 - screenW * 128;
            var top = 0 - screenH * 208;

            var di = new IccDispatcherInkCanvasInfo();
            await di.InitDispatcher();
            var control = await di.Dispatcher.InvokeAsync(() => new InkCanvas() {
                Background = new SolidColorBrush(Colors.White),
                Width = fullWidth,
                Height = fullHeight,
            });
            var dc = new DispatcherContainer() {
                Width = fullWidth,
                Height = fullHeight,
            };
            await dc.SetChildAsync(control);
            InkCanvasHostCanvas.Children.Add(dc);
            Canvas.SetTop(dc, top);
            Canvas.SetLeft(dc, left);
            var info = new IccInnerInkCanvasInfo() {
                GUID = di.GUID,
                Dispatcher = di.Dispatcher,
                Container = dc
            };
            DispatcherInkCanvasList.Add(info);

            // 注册事件
            RegisterTimeMachineEventsToInkCanvas(info.Dispatcher, info.Container, info.GUID);

            return info;
        }

        private void RemoveIccInkCanvas(IccInnerInkCanvasInfo item) {
            item.Dispatcher.BeginInvokeShutdown(DispatcherPriority.Render);
            InkCanvasHostCanvas.Children.Remove(item.Container);
            DispatcherInkCanvasList.Remove(item);
        }

        private void UpdateInnerInkCanvasVisibility(IccBoardPage item) {
            WrapperInkCanvas.Strokes.Clear();
            foreach (UIElement child in InkCanvasHostCanvas.Children) {
                child.Visibility = Visibility.Collapsed;
                if (child.Equals(item.Container)) child.Visibility = Visibility.Visible;
            }
        }

        /// <summary>
        /// 添加时光机支持到DispatcherInkCanvas中（这里是直接以GUID为标识符的）
        /// </summary>
        /// <param name="dispatcher"></param>
        /// <param name="container"></param>
        /// <param name="GUID"></param>
        private void RegisterTimeMachineEventsToInkCanvas(Dispatcher dispatcher, DispatcherContainer container, Guid GUID) {
            Task.Run(() => {
                dispatcher.Invoke(() => {
                    var ic = container.Child as InkCanvas;
                    // Strokes_OnStrokesChanged
                    if (!_innerInkCanvas_Strokes_OnStrokesChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Strokes_OnStrokesChanged_wrappers.Add(GUID, (o, args) => {
                            InnerInkCanvas_Strokes_OnStrokesChanged(o, dispatcher, container, GUID, args);
                        });
                        ic.Strokes.StrokesChanged += _innerInkCanvas_Strokes_OnStrokesChanged_wrappers[GUID];
                    }
                    // Stroke_OnDrawingAttributesChanged
                    if (!_innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers.Add(GUID, (o, args) => {
                            InnerInkCanvas_Stroke_OnDrawingAttributesChanged(o, dispatcher, container, GUID, args);
                        });
                    }
                    // Stroke_OnStylusPointsChanged
                    if (!_innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers.Add(GUID, (o, args) => {
                            InnerInkCanvas_Stroke_OnStylusPointsChanged(o, dispatcher, container, GUID, args);
                        });
                    }
                    // Stroke_OnStylusPointsReplaced
                    if (!_innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers.Add(GUID, (o, args) => {
                            InnerInkCanvas_Stroke_OnStylusPointsReplaced(o, dispatcher, container, GUID, args);
                        });
                    }
                });
            });
        }

        /// <summary>
        /// 取消注册时光机支持
        /// </summary>
        /// <param name="dispatcher"></param>
        /// <param name="container"></param>
        /// <param name="GUID"></param>
        private void UnRegisterTimeMachineEventsToInkCanvas(Dispatcher dispatcher, DispatcherContainer container, Guid GUID) {
            Task.Run(() => {
                dispatcher.Invoke(() => {
                    var ic = container.Child as InkCanvas;
                    // Strokes_OnStrokesChanged
                    if (_innerInkCanvas_Strokes_OnStrokesChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Strokes_OnStrokesChanged_wrappers.Remove(GUID);
                        ic.Strokes.StrokesChanged -= _innerInkCanvas_Strokes_OnStrokesChanged_wrappers[GUID];
                    }
                    // Stroke_OnDrawingAttributesChanged
                    if (_innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers.Remove(GUID);
                    }
                    // Stroke_OnStylusPointsChanged
                    if (_innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers.Remove(GUID);
                    }
                    // Stroke_OnStylusPointsReplaced
                    if (_innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers.ContainsKey(GUID)) {
                        _innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers.Remove(GUID);
                    }
                });
            });
        }

        #endregion

        #region Multi-Pages

        /// <summary>
        /// 根据索引值获取页面
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public IccBoardPage this[int index] => BoardPages[index];

        /// <summary>
        /// 根据InkCanvas的GUID获取页面
        /// </summary>
        /// <param name="GUID"></param>
        /// <returns></returns>
        public IccBoardPage this[Guid GUID] => BoardPages.Find(page => page.GUID == GUID);

        /// <summary>
        /// 获取总页数
        /// </summary>
        public int PagesCount {
            get => BoardPages.Count;
        }

        /// <summary>
        /// 获取当前页面的索引值（如果需要展示页数的话，获取到的还需要加1）
        /// </summary>
        public int CurrentPage {
            get => CurrentPageIndex;
        }

        /// <summary>
        /// 获取到当前页面的 IccBoardPage 对象
        /// </summary>
        public IccBoardPage CurrentPageItem {
            get => BoardPages[CurrentPageIndex];
        }

        /// <summary>
        /// 添加新的白板页面（同时会创建新的DispatcherInkCanvas，如果想用现有的DispatcherInkCanvas插入为新页面的话，请使用 <see cref="AddPageFromExistedDispatcherInkCanvas"/> ）
        /// </summary>
        /// <param name="boardPageAppendMode">选择页面插入的模式</param>
        /// <param name="jumpToPageWhenAdded">指定是否在插入页面后跳转到该页面</param>
        /// <returns></returns>
        public async Task<IccBoardPage> AddPage(BoardPageAppendMode? boardPageAppendMode = BoardPageAppendMode.AppendAfterItem, bool? jumpToPageWhenAdded = true) {
            var info = await AddIccInkCanvas();
            
            var page = new IccBoardPage() {
                Container = info.Container,
                GUID = info.GUID,
                Dispatcher = info.Dispatcher,
                InkCanvas = await info.Dispatcher.InvokeAsync(() => info.Container.Child) as InkCanvas
            };

            page.TimeMachine.UndoRedoStateChanged += RaiseUndoRedoStateChangedEvent;

            var appendMode = boardPageAppendMode ?? BoardPageAppendMode.AppendAfterItem;
            var insertP = 0;

            if (appendMode == BoardPageAppendMode.AppendAfterItem) {
                insertP = Math.Max(Math.Min(CurrentPageIndex + 1, BoardPages.Count),0);
            } else if (appendMode == BoardPageAppendMode.AppendBeforeItem) {
                insertP = Math.Max(Math.Min(CurrentPageIndex - 1, BoardPages.Count),0);
            } else if (appendMode == BoardPageAppendMode.AppendToListStart) {
                insertP = 0;
            } else if (appendMode == BoardPageAppendMode.AppendToListEnd) {
                insertP = BoardPages.Count;
            }
            BoardPages.Insert(insertP, page);

            isIgnoreRaiseCurrentPageChangedEvent = false;

            if (jumpToPageWhenAdded??true) {
                UpdateInnerInkCanvasVisibility(page);
                CurrentPageIndex = BoardPages.IndexOf(page);
                RaiseCurrentPageChangedEvent();
            }
            
            return page;
        }

        /// <summary>
        /// 从现有的DispatcherInkCanvas中添加页面（和AddPage的区别就是不会调用AddIccInkCanvas，不会注册事件，也不会对DispatcherInkCanvas做任何初始化操作）
        /// （注意：如果使用该方法，需要自行处理TimeMachine相关的东西！）
        /// </summary>
        /// <param name="container"></param>
        /// <param name="dispatcher"></param>
        /// <param name="GUID"></param>
        /// <param name="boardPageAppendMode"></param>
        /// <param name="jumpToPageWhenAdded"></param>
        /// <returns></returns>
        public IccBoardPage AddPageFromExistedDispatcherInkCanvas(DispatcherContainer container, Dispatcher dispatcher, Guid? GUID, 
            BoardPageAppendMode? boardPageAppendMode = BoardPageAppendMode.AppendAfterItem, bool? jumpToPageWhenAdded = true) {
            var page = new IccBoardPage() {
                Container = container,
                GUID = GUID??Guid.NewGuid(),
                Dispatcher = dispatcher,
                InkCanvas = dispatcher.Invoke(() => container.Child) as InkCanvas
            };

            var appendMode = boardPageAppendMode ?? BoardPageAppendMode.AppendAfterItem;
            var insertP = 0;

            if (appendMode == BoardPageAppendMode.AppendAfterItem) {
                insertP = Math.Max(Math.Min(CurrentPageIndex + 1, BoardPages.Count),0);
            } else if (appendMode == BoardPageAppendMode.AppendBeforeItem) {
                insertP = Math.Max(Math.Min(CurrentPageIndex - 1, BoardPages.Count),0);
            } else if (appendMode == BoardPageAppendMode.AppendToListStart) {
                insertP = 0;
            } else if (appendMode == BoardPageAppendMode.AppendToListEnd) {
                insertP = BoardPages.Count;
            }
            BoardPages.Insert(insertP, page);

            isIgnoreRaiseCurrentPageChangedEvent = false;

            if (jumpToPageWhenAdded??true) {
                UpdateInnerInkCanvasVisibility(page);
                CurrentPageIndex = BoardPages.IndexOf(page);
                RaiseCurrentPageChangedEvent();
            }
            
            return page;
        }

        /// <summary>
        /// 切换到上一页
        /// </summary>
        /// <param name="step">跳转的页数，默认为1</param>
        public void GoToPreviousPage(int? step = 1) {
            var ci = CurrentPageIndex - step??1;
            if (ci < 0) ci = 0;

            var page = BoardPages[ci];
            UpdateInnerInkCanvasVisibility(page);

            if (!ci.Equals(CurrentPageIndex)) {
                CurrentPageIndex = ci;
                RaiseCurrentPageChangedEvent();
            }
        }

        /// <summary>
        /// 切换到下一页
        /// </summary>
        /// <param name="step">跳转的页数，默认为1</param>
        public void GoToNextPage(int? step = 1) {
            var ci = CurrentPageIndex + step??1;
            if (ci > BoardPages.Count - 1) ci = BoardPages.Count - 1;

            var page = BoardPages[ci];
            UpdateInnerInkCanvasVisibility(page);

            if (!ci.Equals(CurrentPageIndex)) {
                CurrentPageIndex = ci;
                RaiseCurrentPageChangedEvent();
            }
        }

        /// <summary>
        /// 跳转到指定索引的页面
        /// </summary>
        /// <param name="index">索引</param>
        public void GotoPage(int index) {
            UpdateInnerInkCanvasVisibility(BoardPages[index]);

            if (!index.Equals(CurrentPageIndex)) {
                CurrentPageIndex = index;
                RaiseCurrentPageChangedEvent();
            }
        }

        /// <summary>
        /// 跳转到指定页面
        /// </summary>
        /// <param name="page">页面</param>
        public void GotoPage(IccBoardPage page) {
            var index = BoardPages.IndexOf(page);
            UpdateInnerInkCanvasVisibility(page);

            if (!index.Equals(CurrentPageIndex)) {
                CurrentPageIndex = index;
                RaiseCurrentPageChangedEvent();
            }
        }

        /// <summary>
        /// 指示当前页面是否是最后一页，如果只有一页会返回true
        /// </summary>
        public bool IsCurrentLastPage => CurrentPageIndex == BoardPages.Count - 1;

        /// <summary>
        /// 指示当前页面是否是第一页，如果只有一页会返回true
        /// </summary>
        public bool IsCurrentFirstPage => CurrentPageIndex == 0;

        private async Task _RemovePage(IccBoardPage page, bool? isDisposeInstance = true, PageSwitchMode? pageSwitchMode = PageSwitchMode.SwitchToPreviousPage) {
            var isCurrent = CurrentPageItem == page;
            isIgnoreRaiseCurrentPageChangedEvent = true;
            if (isDisposeInstance??true) RemoveIccInkCanvas(DispatcherInkCanvasList.Find(info => info.GUID.Equals(page.GUID)));
            if (isCurrent) {
                var switchMode = pageSwitchMode ?? PageSwitchMode.SwitchToPreviousPage;
                if (IsCurrentFirstPage) GoToNextPage();
                else if (IsCurrentLastPage) GoToPreviousPage();
                else if (!IsCurrentFirstPage && !IsCurrentLastPage) {
                    if (switchMode == PageSwitchMode.SwitchToPreviousPage) GoToPreviousPage();
                    else if (switchMode == PageSwitchMode.SwitchToNextPage) GoToNextPage();
                }
            }
            page.TimeMachine.UndoRedoStateChanged -= RaiseUndoRedoStateChangedEvent;
            BoardPages.Remove(page);
            isIgnoreRaiseCurrentPageChangedEvent = false;
            if (BoardPages.Count == 0) await AddPage(BoardPageAppendMode.AppendToListEnd);
            else RaiseCurrentPageChangedEvent();
        }

        /// <summary>
        /// 移除指定索引的页面，如果只有1页，执行该方法会删除该页面并新建一个页面。
        /// </summary>
        /// <param name="index">索引</param>
        /// <param name="isDisposeInstance">指定是否销毁该页面的Dispatcher，销毁后无法再使用该实例添加到Board！</param>
        /// <param name="pageSwitchMode">删除当前激活页面后切换到临近页面的行为，如果删除的页面不是当前页面则不会生效</param>
        public async Task RemovePageAt(int index, bool? isDisposeInstance = true, PageSwitchMode? pageSwitchMode = PageSwitchMode.SwitchToPreviousPage) {
            var page = BoardPages[index];
            await _RemovePage(page, isDisposeInstance, pageSwitchMode);
        }

        /// <summary>
        /// 移除当前页面，如果只有1页，执行该方法会删除当前页面并新建一个页面。
        /// </summary>
        /// <param name="isDisposeInstance">指定是否销毁该页面的Dispatcher，销毁后无法再使用该实例添加到Board！</param>
        /// <param name="pageSwitchMode">删除当前激活页面后切换到临近页面的行为，如果删除的页面不是当前页面则不会生效</param>
        public async Task RemovePage(bool? isDisposeInstance = true, PageSwitchMode? pageSwitchMode = PageSwitchMode.SwitchToPreviousPage) {
            var page = CurrentPageItem;
            await _RemovePage(page, isDisposeInstance, pageSwitchMode);
        }

        /// <summary>
        /// 移除指定的页面，如果只有1页，执行该方法会删除该页面并新建一个页面。
        /// </summary>
        /// <param name="page">页面</param>
        /// <param name="isDisposeInstance">指定是否销毁该页面的Dispatcher，销毁后无法再使用该实例添加到Board！</param>
        /// <param name="pageSwitchMode">删除当前激活页面后切换到临近页面的行为，如果删除的页面不是当前页面则不会生效</param>
        public async Task RemovePage(IccBoardPage page, bool? isDisposeInstance = true, PageSwitchMode? pageSwitchMode = PageSwitchMode.SwitchToPreviousPage) {
            await _RemovePage(page, isDisposeInstance, pageSwitchMode);
        }

        #endregion

        #region Dynamic Renderer

        public static readonly Guid StrokeUniqueIdKeyGuid = Guid.Parse("71600a68-0a93-4e71-8120-5a7fad5de7e2");

        private async void WrapperInkCanvas_Loaded(object sender, RoutedEventArgs e) {
            var ic = (IccInkCanvas)sender;

            // 启动时自动修改 InkCanvas 的大小
            var screenW = SystemParameters.PrimaryScreenWidth;
            var screenH = SystemParameters.PrimaryScreenHeight;

            var fullWidth = screenW * 257;
            var fullHeight = screenH * 417;

            var left = 0 - screenW * 128;
            var top = 0 - screenH * 208;

            ic.Width = fullWidth;
            ic.Height = fullHeight;
            Canvas.SetLeft(ic, left);
            Canvas.SetTop(ic, top);

            ic.DefaultDrawingAttributes.Width = BoardSettings.NibWidth;
            ic.DefaultDrawingAttributes.Height = BoardSettings.NibHeight;
            ic.DefaultDrawingAttributes.Color = BoardSettings.NibColor;

            ic.StrokeCollected += IccWrapperInkCanvas_StrokeCollected;

            ic.BoardSettings = BoardSettings;

            // BoardSettings 事件注册
            RegisterEventsForBoardSettings();

            if (BoardPages.Count == 0) {
                await AddPage();
            }
        }

        private void IccWrapperInkCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e) {
            var ic = (IccInkCanvas)sender;

            // add unique id to stroke
            e.Stroke.AddPropertyData(StrokeUniqueIdKeyGuid, BoardPages[CurrentPageIndex].LastStrokeID);
            BoardPages[CurrentPageIndex].LastStrokeID += 1L;

            Task.Run(() => {
                BoardPages[CurrentPageIndex].Dispatcher.Invoke(() => {
                    var _c = (InkCanvas)BoardPages[CurrentPageIndex].Container.Child;
                    _c.Strokes.Add(e.Stroke);
                });
                Task.Delay(100);
                Dispatcher.InvokeAsync(()=>ic.Strokes.Remove(e.Stroke));
            });
        }

        #endregion

        #region Eraser Overlay

        private IncrementalStrokeHitTester eraserStrokeHitTester;
        private bool isEraserOverlayPointerDown = false;

        private void EraserOverlayCanvas_Loaded(object sender, RoutedEventArgs e) {
            var bd = (Canvas)sender;
            bd.StylusDown += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Canvas)o).CaptureStylus();
                EraserOverlay_PointerDown(sender);
            });
            bd.StylusUp += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Canvas)o).ReleaseStylusCapture();
                EraserOverlay_PointerUp(sender);
            });
            bd.StylusMove += ((o, args) => {
                e.Handled = true;
                EraserOverlay_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(this));
            });
            bd.MouseDown += ((o, args) => {
                ((Canvas)o).CaptureMouse();
                EraserOverlay_PointerDown(sender);
            });
            bd.MouseUp += ((o, args) => {
                ((Canvas)o).ReleaseMouseCapture();
                EraserOverlay_PointerUp(sender);
            });
            bd.MouseMove += ((o, args) => {
                EraserOverlay_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(this));
            });
            BoardSettings.EraserTypeChanged += (o, args) => {
                if (BoardSettings.EraserType == EraserType.Rectangle)
                    EraserFeedback.Source = FindResource("RectangleEraserImageSource") as DrawingImage;
                else if (BoardSettings.EraserType == EraserType.Ellipse)
                    EraserFeedback.Source = FindResource("EllipseEraserImageSource") as DrawingImage;
            };
            EraserFeedback.Source = FindResource("RectangleEraserImageSource") as DrawingImage;
        }

        private void EraserOverlay_PointerDown(object sender) {
            if (isEraserOverlayPointerDown) return;
            if (CurrentPageItem.Dispatcher.Invoke(() =>
                    ((InkCanvas)CurrentPageItem.Container.Child).Strokes.Count) == 0) return;
            isEraserOverlayPointerDown = true;
            EraserFeedback.Width = Math.Max(BoardSettings.EraserSize,10);
            EraserFeedback.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
            EraserFeedback.Visibility = Visibility.Collapsed;


            StylusShape stylusTipShape;
            if (BoardSettings.EraserType == EraserType.Ellipse)
                stylusTipShape = new EllipseStylusShape(Math.Max(BoardSettings.EraserSize-4, 10),
                    Math.Max(BoardSettings.EraserSize-4, 10));
            else stylusTipShape = new RectangleStylusShape(BoardSettings.EraserSize - 4, (BoardSettings.EraserSize-4) * 56 / 38);

            // init hittester
            Task.Run(() => {
                eraserStrokeHitTester = CurrentPageItem.Dispatcher.Invoke(() =>
                    ((InkCanvas)CurrentPageItem.Container.Child).Strokes.GetIncrementalStrokeHitTester(stylusTipShape));
                CurrentPageItem.Dispatcher.Invoke(() => {
                    eraserStrokeHitTester.StrokeHit += (obj, e) => {
                        var stks = ((InkCanvas)CurrentPageItem.Container.Child).Strokes;
                        StrokeCollection eraseResult = e.GetPointEraseResults();
                        StrokeCollection strokesToReplace = new StrokeCollection { e.HitStroke };
                        if (eraseResult.Any()) {
                            stks.Replace(strokesToReplace, eraseResult);
                        } else {
                            stks.Remove(strokesToReplace);
                        }
                    };
                });
            });
        }

        private void EraserOverlay_PointerUp(object sender) {
            if (!isEraserOverlayPointerDown) return;
            isEraserOverlayPointerDown = false;
            EraserFeedback.Visibility = Visibility.Collapsed;

            if (ReplacedStroke != null || AddedStroke != null) {
                CurrentPageItem.TimeMachine.CommitStrokeEraseHistory(ReplacedStroke, AddedStroke);
                AddedStroke = null;
                ReplacedStroke = null;
            }

            Task.Run(() => {
                CurrentPageItem.Dispatcher.Invoke(() => {
                    eraserStrokeHitTester.EndHitTesting();
                });
                eraserStrokeHitTester = null;
            });
        }

        private void EraserOverlay_PointerMove(object sender, Point ptInInkCanvas, Point ptInEraserOverlay) {
            if (!isEraserOverlayPointerDown) return;
            if (EraserFeedback.Visibility == Visibility.Collapsed) EraserFeedback.Visibility = Visibility.Visible;
            EraserFeedbackTranslateTransform.X = ptInEraserOverlay.X - EraserFeedback.ActualWidth /2;
            EraserFeedbackTranslateTransform.Y = ptInEraserOverlay.Y  - EraserFeedback.ActualHeight /2;

            // erase stroke
            try {
                CurrentPageItem.Dispatcher.Invoke(() => {
                    eraserStrokeHitTester.AddPoint(ptInInkCanvas);
                });
            }
            catch{}
        }

        #endregion

        #region Rectangle Area Eraser

        private bool isRectangleAreaEraserCanvasPointerDown = false;
        private Point? rectangleAreaEraserCanvas_firstPt;
        private Point? rectangleAreaEraserCanvas_firstPtInIC;
        private Point? rectangleAreaEraserCanvas_lastPt;
        private Point? rectangleAreaEraserCanvas_lastPtInIC;

        private void HostCanvas_Loaded(object sender, RoutedEventArgs e) {
            var ca = (Canvas)sender;
            HostCanvasClipGeometry1.Rect = new Rect(new Size(ca.Width, ca.Height));
        }

        private void HostCanvas_SizeChanged(object sender, SizeChangedEventArgs e) {
            HostCanvasClipGeometry1.Rect = new Rect(e.NewSize);
        }

        private void RectangleAreaEraserCanvas_Loaded(object sender, RoutedEventArgs e) {
            var ca = (Canvas)sender;

            ca.StylusDown += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Canvas)o).CaptureStylus();
                RectangleAreaEraserCanvas_PointerDown(sender);
            });
            ca.StylusUp += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Canvas)o).ReleaseStylusCapture();
                RectangleAreaEraserCanvas_PointerUp(sender);
            });
            ca.StylusMove += ((o, args) => {
                e.Handled = true;
                RectangleAreaEraserCanvas_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(this));
            });
            ca.MouseDown += ((o, args) => {
                ((Canvas)o).CaptureMouse();
                RectangleAreaEraserCanvas_PointerDown(sender);
            });
            ca.MouseUp += ((o, args) => {
                ((Canvas)o).ReleaseMouseCapture();
                RectangleAreaEraserCanvas_PointerUp(sender);
            });
            ca.MouseMove += ((o, args) => {
                RectangleAreaEraserCanvas_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(this));
            });

            AreaErasingFeedback.Visibility = Visibility.Collapsed;
        }

        private void RectangleAreaEraserCanvas_PointerDown(object sender) {
            if (isRectangleAreaEraserCanvasPointerDown) return;
            isRectangleAreaEraserCanvasPointerDown = true;

            HostCanvasClipGeometry.Geometry2 = new RectangleGeometry();
            rectangleAreaEraserCanvas_firstPt = null;
            rectangleAreaEraserCanvas_lastPt = null;
            rectangleAreaEraserCanvas_firstPtInIC = null;
            rectangleAreaEraserCanvas_lastPtInIC = null;
        }

        private void RectangleAreaEraserCanvas_PointerUp(object sender) {
            if (!isRectangleAreaEraserCanvasPointerDown) return;
            isRectangleAreaEraserCanvasPointerDown = false;

            HostCanvasClipGeometry.Geometry2 = Geometry.Empty;

            var rect = new Rect(rectangleAreaEraserCanvas_firstPtInIC ?? new Point(0, 0),
                rectangleAreaEraserCanvas_lastPtInIC ?? new Point(0, 0));

            var stylusShape = new RectangleStylusShape(rect.Width, rect.Height);
            Task.Run(() => {
                CurrentPageItem.Dispatcher.Invoke(() => {
                    ((InkCanvas)CurrentPageItem.Container.Child).Strokes.Erase(
                        new Point[] { new Point(rect.Left + rect.Width / 2, rect.Top + rect.Height / 2) }, stylusShape);
                });
                if (ReplacedStroke != null || AddedStroke != null) {
                    CurrentPageItem.TimeMachine.CommitStrokeEraseHistory(ReplacedStroke, AddedStroke);
                    AddedStroke = null;
                    ReplacedStroke = null;
                }
            });

            rectangleAreaEraserCanvas_firstPt = null;
            rectangleAreaEraserCanvas_lastPt = null;
            rectangleAreaEraserCanvas_firstPtInIC = null;
            rectangleAreaEraserCanvas_lastPtInIC = null;

            AreaErasingFeedback.Visibility = Visibility.Collapsed;

        }

        private void RectangleAreaEraserCanvas_PointerMove(object sender, Point ptInInkCanvas, Point ptInEraserOverlay) {
            if (!isRectangleAreaEraserCanvasPointerDown) return;

            if (rectangleAreaEraserCanvas_firstPt == null) {
                rectangleAreaEraserCanvas_firstPt = ptInEraserOverlay;
                rectangleAreaEraserCanvas_firstPtInIC = ptInInkCanvas;
            }
            rectangleAreaEraserCanvas_lastPt = ptInEraserOverlay;
            rectangleAreaEraserCanvas_lastPtInIC = ptInInkCanvas;

            // update geometry clip
            ((RectangleGeometry)HostCanvasClipGeometry.Geometry2).Rect = new Rect(
                rectangleAreaEraserCanvas_firstPt ?? new Point(0, 0),
                rectangleAreaEraserCanvas_lastPt ?? new Point(0, 0));

            // update fedback
            if (AreaErasingFeedback.Visibility == Visibility.Collapsed)
                AreaErasingFeedback.Visibility = Visibility.Visible;
            Canvas.SetTop(AreaErasingFeedback,Math.Min(((Point)rectangleAreaEraserCanvas_firstPt).Y,((Point)rectangleAreaEraserCanvas_lastPt).Y));
            Canvas.SetLeft(AreaErasingFeedback,Math.Min(((Point)rectangleAreaEraserCanvas_firstPt).X,((Point)rectangleAreaEraserCanvas_lastPt).X));
            AreaErasingFeedback.Width = Math.Abs(((Point)rectangleAreaEraserCanvas_firstPt).X - ((Point)rectangleAreaEraserCanvas_lastPt).X);
            AreaErasingFeedback.Height = Math.Abs(((Point)rectangleAreaEraserCanvas_firstPt).Y - ((Point)rectangleAreaEraserCanvas_lastPt).Y);
        }

        #endregion

        #region TimeMachine

        private bool _isTimeMachineThreadTaskDone = true;

        // 指示时光机该怎么判定本次历史记录提交
        private CommitReason _currentCommitType = CommitReason.UserInput;

        private StrokeCollection ReplacedStroke;
        private StrokeCollection AddedStroke;

        private Dictionary<Stroke, Tuple<StylusPointCollection, StylusPointCollection>> StylusPointsChangedHistory;

        private Dictionary<Stroke, StylusPointCollection> StrokeInitialHistory =
            new Dictionary<Stroke, StylusPointCollection>();

        private Dictionary<Stroke, Tuple<DrawingAttributes, DrawingAttributes>> DrawingAttributesHistory =
            new Dictionary<Stroke, Tuple<DrawingAttributes, DrawingAttributes>>();

        private Dictionary<Guid, List<Stroke>> DrawingAttributesHistoryFlag = new Dictionary<Guid, List<Stroke>>() {
            { DrawingAttributeIds.Color, new List<Stroke>() },
            { DrawingAttributeIds.DrawingFlags, new List<Stroke>() },
            { DrawingAttributeIds.IsHighlighter, new List<Stroke>() },
            { DrawingAttributeIds.StylusHeight, new List<Stroke>() },
            { DrawingAttributeIds.StylusTip, new List<Stroke>() },
            { DrawingAttributeIds.StylusTipTransform, new List<Stroke>() },
            { DrawingAttributeIds.StylusWidth, new List<Stroke>() }
        };

        /// <summary>
        /// 根据传入的History项目，将历史记录应用到指定页面上去
        /// </summary>
        /// <param name="page"></param>
        /// <param name="history"></param>
        private void ApplyHistoryToPage(IccBoardPage page, TimeMachineHistory history) {
            _currentCommitType = CommitReason.CodeInput;

            page.Dispatcher.InvokeAsync(() => {
                var inkcanvas = page.Container.Child as InkCanvas;

                while (!_isTimeMachineThreadTaskDone) {
                    Thread.Sleep(1);
                }

                _isTimeMachineThreadTaskDone = false;

                if (history.CommitType == TimeMachineHistoryType.UserInput) {
                    foreach (var strokes in history.CurrentStroke) {
                        Trace.WriteLine(strokes);
                        if (!inkcanvas.Strokes.Contains(strokes) && !history.StrokeHasBeenCleared) inkcanvas.Strokes.Add(strokes);
                        else if (inkcanvas.Strokes.Contains(strokes) && history.StrokeHasBeenCleared) {
                            foreach (var _stroke in inkcanvas.Strokes.Where(s =>
                                         s.ContainsPropertyData(StrokeUniqueIdKeyGuid) &&
                                         s.GetPropertyData(StrokeUniqueIdKeyGuid) ==
                                         strokes.GetPropertyData(StrokeUniqueIdKeyGuid)).ToArray()) inkcanvas.Strokes.Remove(_stroke);
                        }
                    }
                } else if (history.CommitType == TimeMachineHistoryType.ShapeRecognition) {
                    foreach (var strokes in history.CurrentStroke) {
                        if (inkcanvas.Strokes.Contains(strokes) && history.StrokeHasBeenCleared) 
                            foreach (var _stroke in inkcanvas.Strokes.Where(s =>
                                         s.ContainsPropertyData(StrokeUniqueIdKeyGuid) &&
                                         s.GetPropertyData(StrokeUniqueIdKeyGuid) ==
                                         strokes.GetPropertyData(StrokeUniqueIdKeyGuid)).ToArray()) inkcanvas.Strokes.Remove(_stroke);
                        else if (!inkcanvas.Strokes.Contains(strokes) && !history.StrokeHasBeenCleared) inkcanvas.Strokes.Add(strokes);
                    }
                    foreach (var strokes in history.ReplacedStroke) {
                        if (!inkcanvas.Strokes.Contains(strokes) && !history.StrokeHasBeenCleared) 
                            foreach (var _stroke in inkcanvas.Strokes.Where(s =>
                                         s.ContainsPropertyData(StrokeUniqueIdKeyGuid) &&
                                         s.GetPropertyData(StrokeUniqueIdKeyGuid) ==
                                         strokes.GetPropertyData(StrokeUniqueIdKeyGuid)).ToArray()) inkcanvas.Strokes.Remove(_stroke);
                        else if (inkcanvas.Strokes.Contains(strokes) && history.StrokeHasBeenCleared) inkcanvas.Strokes.Add(strokes);
                    }
                } else if (history.CommitType == TimeMachineHistoryType.StylusPoints) {
                    foreach (var currentStroke in history.StylusPointsDictionary) {
                        if (inkcanvas.Strokes.Contains(currentStroke.Key)) 
                            currentStroke.Key.StylusPoints = history.StrokeHasBeenCleared ? currentStroke.Value.Item1 : currentStroke.Value.Item2;
                    }
                } else if (history.CommitType == TimeMachineHistoryType.DrawingAttributes) {
                    foreach (var currentStroke in history.DrawingAttributes) {
                        if (inkcanvas.Strokes.Contains(currentStroke.Key))
                            currentStroke.Key.DrawingAttributes = history.StrokeHasBeenCleared ? currentStroke.Value.Item1 : currentStroke.Value.Item2;
                    }
                } else if (history.CommitType == TimeMachineHistoryType.Erased) {
                    if (!history.StrokeHasBeenCleared) {
                        if (history.CurrentStroke != null)
                            foreach (var currentStroke in history.CurrentStroke)
                                if (!inkcanvas.Strokes.Contains(currentStroke))
                                    inkcanvas.Strokes.Add(currentStroke);

                        if (history.ReplacedStroke != null)
                            foreach (var replacedStroke in history.ReplacedStroke)
                                if (inkcanvas.Strokes.Contains(replacedStroke))
                                    inkcanvas.Strokes.Remove(replacedStroke);
                    } else {
                        if (history.ReplacedStroke != null)
                            foreach (var replacedStroke in history.ReplacedStroke)
                                if (!inkcanvas.Strokes.Contains(replacedStroke))
                                    inkcanvas.Strokes.Add(replacedStroke);

                        if (history.CurrentStroke != null)
                            foreach (var currentStroke in history.CurrentStroke)
                                if (inkcanvas.Strokes.Contains(currentStroke))
                                    inkcanvas.Strokes.Remove(currentStroke);
                    }
                }

                _currentCommitType = CommitReason.UserInput;
                _isTimeMachineThreadTaskDone = true;
            });
        }

        /// <summary>
        /// 批量应用多个历史记录到页面上
        /// </summary>
        /// <param name="page"></param>
        /// <param name="histories"></param>
        private void ApplyHistoriesToPage(IccBoardPage page, TimeMachineHistory[] histories) {
            foreach (var timeMachineHistory in histories) {
                ApplyHistoryToPage(page,timeMachineHistory);
            }
        }

        /// <summary>
        /// 内部的InkCanvas触发了Strokes.StrokesChanged事件
        /// </summary>
        /// <param name="sender">发送事件的InkCanvas（需要用传入的Dispatcher操作）</param>
        /// <param name="dispatcher">这个InkCanvas所在的Dispatcher对象</param>
        /// <param name="container">这个InkCanvas所存放的DispatcherContainer</param>
        /// <param name="GUID">InkCanvas（也是页面的）GUID</param>
        /// <param name="eventArgs">StrokeCollectionChangedEventArgs事件</param>
        private void InnerInkCanvas_Strokes_OnStrokesChanged(object sender, Dispatcher dispatcher,
            DispatcherContainer container, Guid GUID, StrokeCollectionChangedEventArgs eventArgs) {
            Trace.WriteLine($"GUID：{GUID} 触发了Strokes_OnStrokesChanged，第{BoardPages.IndexOf(BoardPages.Find(page=>page.GUID.Equals(GUID)))+1}页");

            foreach (var stroke in eventArgs?.Removed) {
                stroke.DrawingAttributesChanged -=
                    _innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers[GUID];
                stroke.StylusPointsReplaced -=
                    _innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers[GUID];
                stroke.StylusPointsChanged -=
                    _innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers[GUID];
            }
            foreach (var stroke in eventArgs?.Added) {
                stroke.DrawingAttributesChanged +=
                    _innerInkCanvas_Stroke_OnDrawingAttributesChanged_wrappers[GUID];
                stroke.StylusPointsReplaced +=
                    _innerInkCanvas_Stroke_OnStylusPointsReplaced_wrappers[GUID];
                stroke.StylusPointsChanged +=
                    _innerInkCanvas_Stroke_OnStylusPointsChanged_wrappers[GUID];
            }

            if (_currentCommitType == CommitReason.CodeInput || _currentCommitType == CommitReason.ShapeDrawing) return;

            // 橡皮擦擦除墨迹和时光机对接
            if ((eventArgs?.Added.Count != 0 || eventArgs?.Removed.Count != 0) &&
                (_edittingMode == EditingMode.GeometryErasing || _edittingMode == EditingMode.AreaErasing)) {
                if (AddedStroke == null) AddedStroke = new StrokeCollection();
                if (ReplacedStroke == null) ReplacedStroke = new StrokeCollection();
                try {
                    AddedStroke.Add(eventArgs.Added);
                    ReplacedStroke.Add(eventArgs.Removed);
                }
                catch {}
                Trace.WriteLine(ReplacedStroke.Count);
                return;
            }

            // 有新墨迹
            if (eventArgs.Added.Count != 0) {
                // 判断是否是形状识别新增的墨迹
                if (_currentCommitType == CommitReason.ShapeRecognition) {
                    BoardPages.Find(page=>page.GUID==GUID).TimeMachine.CommitStrokeShapeHistory(ReplacedStroke, eventArgs.Added);
                    ReplacedStroke = null;
                    return;
                } else {
                    BoardPages.Find(page=>page.GUID==GUID).TimeMachine.CommitStrokeUserInputHistory(eventArgs.Added);
                    return;
                }
            }

            // 有被删除的墨迹
            if (eventArgs.Removed.Count != 0) {
                if (_currentCommitType == CommitReason.ShapeRecognition) {
                    ReplacedStroke = eventArgs.Removed;
                    return;
                } else if ((_edittingMode == EditingMode.GeometryErasing || _edittingMode == EditingMode.AreaErasing) || _currentCommitType == CommitReason.ClearingCanvas) {
                    BoardPages.Find(page=>page.GUID==GUID).TimeMachine.CommitStrokeEraseHistory(eventArgs.Removed);
                    return;
                }
            }
        }

        /// <summary>
        /// 内部的InkCanvas的Stroke触发了Stroke.DrawingAttributesChanged事件
        /// </summary>
        /// <param name="sender">发送事件的Stroke（需要用传入的Dispatcher操作）</param>
        /// <param name="dispatcher">这个InkCanvas所在的Dispatcher对象</param>
        /// <param name="container">这个InkCanvas所存放的DispatcherContainer</param>
        /// <param name="GUID">InkCanvas（也是页面的）GUID</param>
        /// <param name="eventArgs">PropertyDataChangedEventArgs事件</param>
        private void InnerInkCanvas_Stroke_OnDrawingAttributesChanged(object sender, Dispatcher dispatcher,
            DispatcherContainer container, Guid GUID, PropertyDataChangedEventArgs eventArgs) {
            Trace.WriteLine($"GUID：{GUID} 触发了Stroke_OnDrawingAttributesChanged，第{BoardPages.IndexOf(BoardPages.Find(page=>page.GUID.Equals(GUID)))+1}页");
        }

        /// <summary>
        /// 内部的InkCanvas的Stroke触发了Stroke.StylusPointsChanged事件
        /// </summary>
        /// <param name="sender">发送事件的Stroke（需要用传入的Dispatcher操作）</param>
        /// <param name="dispatcher">这个InkCanvas所在的Dispatcher对象</param>
        /// <param name="container">这个InkCanvas所存放的DispatcherContainer</param>
        /// <param name="GUID">InkCanvas（也是页面的）GUID</param>
        /// <param name="eventArgs">EventArgs事件</param>
        private void InnerInkCanvas_Stroke_OnStylusPointsChanged(object sender, Dispatcher dispatcher,
            DispatcherContainer container, Guid GUID, EventArgs eventArgs) {
            Trace.WriteLine($"GUID：{GUID} 触发了Stroke_OnStylusPointsChanged，第{BoardPages.IndexOf(BoardPages.Find(page=>page.GUID.Equals(GUID)))+1}页");
        }

        /// <summary>
        /// 内部的InkCanvas的Stroke触发了Stroke.StylusPointsReplaced事件
        /// </summary>
        /// <param name="sender">发送事件的Stroke（需要用传入的Dispatcher操作）</param>
        /// <param name="dispatcher">这个InkCanvas所在的Dispatcher对象</param>
        /// <param name="container">这个InkCanvas所存放的DispatcherContainer</param>
        /// <param name="GUID">InkCanvas（也是页面的）GUID</param>
        /// <param name="eventArgs">StylusPointsReplacedEventArgs事件</param>
        private void InnerInkCanvas_Stroke_OnStylusPointsReplaced(object sender, Dispatcher dispatcher,
            DispatcherContainer container, Guid GUID, StylusPointsReplacedEventArgs eventArgs) {
            Trace.WriteLine($"GUID：{GUID} 触发了Stroke_OnStylusPointsReplaced，第{BoardPages.IndexOf(BoardPages.Find(page=>page.GUID.Equals(GUID)))+1}页");
        }

        #endregion

        #region TimeMachine Public APIs

        /// <summary>
        /// 当前页面的历史记录数量
        /// </summary>
        public int CurrentPageHistoriesCount => CurrentPageItem.TimeMachine.CurrentHistoriesCount;

        /// <summary>
        /// 获取当前页面能否撤销
        /// </summary>
        public bool CanUndo => CurrentPageItem.TimeMachine.CanUndo;

        /// <summary>
        /// 获取当前页面能否重做
        /// </summary>
        public bool CanRedo => CurrentPageItem.TimeMachine.CanRedo;

        /// <summary>
        /// 撤销（仅针对当前激活页面）
        /// </summary>
        public void Undo() {
            if (!_isTimeMachineThreadTaskDone) return;
            var history = CurrentPageItem.TimeMachine.Undo(false);
            if (history != null) ApplyHistoryToPage(CurrentPageItem,history);
        }

        /// <summary>
        /// 多步撤销（仅针对当前激活页面）
        /// </summary>
        public void Undo(int steps = 1) {
            if (!_isTimeMachineThreadTaskDone) return;
            var histories = CurrentPageItem.TimeMachine.Undo(steps);
            if (histories.Length <= 0) return;
            foreach (var history in histories) {
                ApplyHistoryToPage(CurrentPageItem,history);
            }
        }

        /// <summary>
        /// 重做（仅针对当前激活页面）
        /// </summary>
        public void Redo() {
            if (!_isTimeMachineThreadTaskDone) return;
            var history = CurrentPageItem.TimeMachine.Redo(false);
            if (history != null) ApplyHistoryToPage(CurrentPageItem,history);
        }

        /// <summary>
        /// 多步撤销（仅针对当前激活页面）
        /// </summary>
        public void Redo(int steps = 1) {
            if (!_isTimeMachineThreadTaskDone) return;
            var histories = CurrentPageItem.TimeMachine.Redo(steps);
            if (histories.Length <= 0) return;
            foreach (var history in histories) {
                ApplyHistoryToPage(CurrentPageItem,history);
            }
        }

        #endregion

        #region 漫游相关代码 Roaming

        private bool isRoamingHitTestBorderPointerDown = false;

        private Point? roamingFirstPoint;
        private Point? roamingLastPoint;
        private Matrix? roamingMatrix = null;

        private void RoamingHitTestBorder_Loaded(object sender, RoutedEventArgs e) {
            var rh = (Border)sender;

            rh.StylusDown += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Border)o).CaptureStylus();
                RoamingHitTestBorder_PointerDown(sender);
            });
            rh.StylusUp += ((o, args) => {
                e.Handled = true;
                if (args.StylusDevice.TabletDevice.Type == TabletDeviceType.Stylus) ((Border)o).ReleaseStylusCapture();
                RoamingHitTestBorder_PointerUp(sender);
            });
            rh.StylusMove += ((o, args) => {
                e.Handled = true;
                RoamingHitTestBorder_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(null));
            });
            rh.MouseDown += ((o, args) => {
                ((Border)o).CaptureMouse();
                RoamingHitTestBorder_PointerDown(sender);
            });
            rh.MouseUp += ((o, args) => {
                ((Border)o).ReleaseMouseCapture();
                RoamingHitTestBorder_PointerUp(sender);
            });
            rh.MouseMove += ((o, args) => {
                RoamingHitTestBorder_PointerMove(sender, args.GetPosition(WrapperInkCanvas), args.GetPosition(null));
            });
        }

        /// <summary>
        /// TODO: 设置页面的MatrixTransform（还没有正式完工）
        /// </summary>
        /// <param name="page"></param>
        /// <param name="matrix"></param>
        private void _SetPageMatrixTransform(IccBoardPage page, Matrix matrix) {
            if (page.Container.RenderTransformOrigin != new Point(0, 0))
                page.Container.RenderTransformOrigin = new Point(0, 0);
            page.Container.RenderTransform = new MatrixTransform(matrix);
            WrapperInkCanvasMatrixTransform.Matrix = matrix;
        }

        private void RoamingHitTestBorder_PointerDown(object sender) {
            if (isRoamingHitTestBorderPointerDown) return;
            isRoamingHitTestBorderPointerDown = true;

            roamingFirstPoint = null;
            roamingLastPoint = null;
            roamingMatrix = null;
        }

        private void RoamingHitTestBorder_PointerUp(object sender) {
            if (!isRoamingHitTestBorderPointerDown) return;
            isRoamingHitTestBorderPointerDown = false;

            CurrentPageItem.TransformMatrix = (CurrentPageItem.Container.RenderTransform as MatrixTransform).Value;

            roamingFirstPoint = null;
            roamingLastPoint = null;
            roamingMatrix = null;
        }

        private void RoamingHitTestBorder_PointerMove(object sender, Point ptInInkCanvas, Point ptAbsolute) {
            if (!isRoamingHitTestBorderPointerDown) return;

            if (roamingFirstPoint == null) roamingFirstPoint = ptAbsolute;
            roamingLastPoint = ptAbsolute;

            if (roamingMatrix == null) roamingMatrix = CurrentPageItem.TransformMatrix;
            
            var deltaX = (roamingLastPoint ?? new Point(0, 0)).X - (roamingFirstPoint ?? new Point(0, 0)).X;
            var deltaY = (roamingLastPoint ?? new Point(0, 0)).Y - (roamingFirstPoint ?? new Point(0, 0)).Y;

            var mt = roamingMatrix??new Matrix();
            mt.Translate(deltaX,deltaY);
            
            _SetPageMatrixTransform(CurrentPageItem,mt);
        }

        #endregion

        public IccBoard() {
            InitializeComponent();
        }

    }
}