import { IconProp } from '@fortawesome/fontawesome-svg-core';
import { Dropdown, DropdownType, Type } from 'browndash-components';
import { Howl } from 'howler';
import { IReactionDisposer, action, computed, makeObservable, observable, reaction, runInAction } from 'mobx';
import { observer } from 'mobx-react';
import { computedFn } from 'mobx-utils';
import * as React from 'react';
import { Bounce, Fade, Flip, JackInTheBox, Roll, Rotate, Zoom } from 'react-awesome-reveal';
import { Utils, emptyFunction, isTargetChildOf as isParentOf, lightOrDark, returnEmptyString, returnFalse, returnTrue, returnVal, simulateMouseClick } from '../../../Utils';
import { Doc, DocListCast, Field, Opt, StrListCast } from '../../../fields/Doc';
import { AclPrivate, Animation, AudioPlay, DocViews } from '../../../fields/DocSymbols';
import { Id } from '../../../fields/FieldSymbols';
import { InkTool } from '../../../fields/InkField';
import { List } from '../../../fields/List';
import { RefField } from '../../../fields/RefField';
import { listSpec } from '../../../fields/Schema';
import { ScriptField } from '../../../fields/ScriptField';
import { BoolCast, Cast, DocCast, ImageCast, NumCast, ScriptCast, StrCast } from '../../../fields/Types';
import { AudioField } from '../../../fields/URLField';
import { GetEffectiveAcl, TraceMobx } from '../../../fields/util';
import { DocServer } from '../../DocServer';
import { Networking } from '../../Network';
import { GooglePhotos } from '../../apis/google_docs/GooglePhotosClientUtils';
import { CollectionViewType, DocumentType } from '../../documents/DocumentTypes';
import { DocOptions, DocUtils, Docs, FInfo } from '../../documents/Documents';
import { DictationManager } from '../../util/DictationManager';
import { DocumentManager } from '../../util/DocumentManager';
import { DragManager, dropActionType } from '../../util/DragManager';
import { FollowLinkScript } from '../../util/LinkFollower';
import { LinkManager } from '../../util/LinkManager';
import { ScriptingGlobals } from '../../util/ScriptingGlobals';
import { SelectionManager } from '../../util/SelectionManager';
import { SettingsManager } from '../../util/SettingsManager';
import { SharingManager } from '../../util/SharingManager';
import { SnappingManager } from '../../util/SnappingManager';
import { Transform } from '../../util/Transform';
import { UndoManager, undoBatch } from '../../util/UndoManager';
import { ContextMenu } from '../ContextMenu';
import { ContextMenuProps } from '../ContextMenuItem';
import { DocComponent } from '../DocComponent';
import { EditableView } from '../EditableView';
import { GestureOverlay } from '../GestureOverlay';
import { LightboxView } from '../LightboxView';
import { ObservableReactComponent } from '../ObservableReactComponent';
import { StyleProp } from '../StyleProvider';
import { UndoStack } from '../UndoStack';
import { CollectionFreeFormDocumentView } from './CollectionFreeFormDocumentView';
import { DocumentContentsView, ObserverJsxParser } from './DocumentContentsView';
import { DocumentLinksButton } from './DocumentLinksButton';
import './DocumentView.scss';
import { FieldViewProps } from './FieldView';
import { KeyValueBox } from './KeyValueBox';
import { LinkAnchorBox } from './LinkAnchorBox';
import { FormattedTextBox } from './formattedText/FormattedTextBox';
import { PresEffect, PresEffectDirection } from './trails';
import { PinProps, PresBox } from './trails/PresBox';

interface Window {
    MediaRecorder: MediaRecorder;
}

declare class MediaRecorder {
    // whatever MediaRecorder has
    constructor(e: any);
}

export enum OpenWhereMod {
    none = '',
    left = 'left',
    right = 'right',
    top = 'top',
    bottom = 'bottom',
    keyvalue = 'keyValue',
}
export enum OpenWhere {
    lightbox = 'lightbox',
    add = 'add',
    addLeft = 'add:left',
    addRight = 'add:right',
    addBottom = 'add:bottom',
    close = 'close',
    toggle = 'toggle',
    toggleRight = 'toggle:right',
    replace = 'replace',
    replaceRight = 'replace:right',
    replaceLeft = 'replace:left',
    inParent = 'inParent',
    inParentFromScreen = 'inParentFromScreen',
    overlay = 'overlay',
    addRightKeyvalue = 'add:right:keyValue',
}

export interface DocFocusOptions {
    willPan?: boolean; // determines whether to pan to target document
    willZoomCentered?: boolean; // determines whether to zoom in on target document.  if zoomScale is 0, this just centers the document
    zoomScale?: number; // percent of containing frame to zoom into document
    zoomTime?: number;
    didMove?: boolean; // whether a document was changed during the showDocument process
    docTransform?: Transform; // when a document can't be panned and zoomed within its own container (say a group), then we need to continue to move up the render hierarchy to find something that can pan and zoom.  when this happens the docTransform must accumulate all the transforms of each level of the hierarchy
    instant?: boolean; // whether focus should happen instantly (as opposed to smooth zoom)
    preview?: boolean; // whether changes should be previewed by the componentView or written to the document
    effect?: Doc; // animation effect for focus
    noSelect?: boolean; // whether target should be selected after focusing
    playAudio?: boolean; // whether to play audio annotation on focus
    playMedia?: boolean; // whether to play start target videos
    openLocation?: OpenWhere; // where to open a missing document
    zoomTextSelections?: boolean; // whether to display a zoomed overlay of anchor text selections
    toggleTarget?: boolean; // whether to toggle target on and off
    anchorDoc?: Doc; // doc containing anchor info to apply at end of focus to target doc
    easeFunc?: 'linear' | 'ease'; // transition method for scrolling
}
export type DocFocusFunc = (doc: Doc, options: DocFocusOptions) => Opt<number>;
export type StyleProviderFunc = (doc: Opt<Doc>, props: Opt<DocumentViewProps | FieldViewProps>, property: string) => any;
export interface DocComponentView {
    fieldKey?: string;
    annotationKey?: string;
    updateIcon?: () => void; // updates the icon representation of the document
    getAnchor?: (addAsAnnotation: boolean, pinData?: PinProps) => Doc; // returns an Anchor Doc that represents the current state of the doc's componentview (e.g., the current playhead location of a an audio/video box)
    restoreView?: (viewSpec: Doc) => boolean;
    scrollPreview?: (docView: DocumentView, doc: Doc, focusSpeed: number, options: DocFocusOptions) => Opt<number>; // returns the duration of the focus
    brushView?: (view: { width: number; height: number; panX: number; panY: number }, transTime: number, holdTime: number) => void; // highlight a region of a view (used by freeforms)
    getView?: (doc: Doc) => Promise<Opt<DocumentView>>; // returns a nested DocumentView for the specified doc or undefined
    addDocTab?: (doc: Doc, where: OpenWhere) => boolean; // determines how to add a document - used in following links to open the target ina local lightbox
    addDocument?: (doc: Doc | Doc[], annotationKey?: string) => boolean; // add a document (used only by collections)
    select?: (ctrlKey: boolean, shiftKey: boolean) => void;
    focus?: (textAnchor: Doc, options: DocFocusOptions) => Opt<number>;
    isAnyChildContentActive?: () => boolean; // is any child content of the document active
    onClickScriptDisable?: () => 'never' | 'always'; // disable click scripts : never, always, or undefined = only when selected
    getKeyFrameEditing?: () => boolean; // whether the document is in keyframe editing mode (if it is, then all hidden documents that are not active at the keyframe time will still be shown)
    setKeyFrameEditing?: (set: boolean) => void; // whether the document is in keyframe editing mode (if it is, then all hidden documents that are not active at the keyframe time will still be shown)
    playFrom?: (time: number, endTime?: number) => void;
    Pause?: () => void; // pause a media document (eg, audio/video)
    IsPlaying?: () => boolean; // is a media document playing
    TogglePause?: (keep?: boolean) => void; // toggle media document playing state
    setFocus?: () => void; // sets input focus to the componentView
    setData?: (data: Field | Promise<RefField | undefined>) => boolean;
    componentUI?: (boundsLeft: number, boundsTop: number) => JSX.Element | null;
    dragStarting?: (snapToDraggedDoc: boolean, showGroupDragTarget: boolean, visited: Set<Doc>) => void;
    incrementalRendering?: () => void;
    infoUI?: () => JSX.Element | null;
    screenBounds?: () => Opt<{ left: number; top: number; right: number; bottom: number; center?: { X: number; Y: number } }>;
    ptToScreen?: (pt: { X: number; Y: number }) => { X: number; Y: number };
    ptFromScreen?: (pt: { X: number; Y: number }) => { X: number; Y: number };
    snapPt?: (pt: { X: number; Y: number }, excludeSegs?: number[]) => { nearestPt: { X: number; Y: number }; distance: number };
    search?: (str: string, bwd?: boolean, clear?: boolean) => boolean;
}
// These props are passed to both FieldViews and DocumentViews
export interface DocumentViewSharedProps {
    renderDepth: number;
    Document: Doc;
    TemplateDataDocument?: Doc;
    scriptContext?: any; // can be assigned anything and will be passed as 'scriptContext' to any OnClick script that executes on this document
    DocumentView?: () => DocumentView;
    CollectionFreeFormDocumentView?: () => CollectionFreeFormDocumentView;
    fitContentsToBox?: () => boolean; // used by freeformview to fit its contents to its panel. corresponds to _freeform_fitContentsToBox property on a Document
    isGroupActive?: () => string | undefined; // is this document part of a group that is active
    setContentView?: (view: DocComponentView) => any;
    PanelWidth: () => number;
    PanelHeight: () => number;
    docViewPath: () => DocumentView[];
    childFilters: () => string[];
    childFiltersByRanges: () => string[];
    styleProvider: Opt<StyleProviderFunc>;
    setTitleFocus?: () => void;
    focus: DocFocusFunc;
    layout_fitWidth?: (doc: Doc) => boolean | undefined;
    searchFilterDocs: () => Doc[];
    layout_showTitle?: () => string;
    whenChildContentsActiveChanged: (isActive: boolean) => void;
    rootSelected?: () => boolean; // whether the root of a template has been selected
    addDocTab: (doc: Doc, where: OpenWhere) => boolean;
    filterAddDocument?: (doc: Doc[]) => boolean; // allows a document that renders a Collection view to filter or modify any documents added to the collection (see PresBox for an example)
    addDocument?: (doc: Doc | Doc[], annotationKey?: string) => boolean;
    removeDocument?: (doc: Doc | Doc[], annotationKey?: string) => boolean;
    moveDocument?: (doc: Doc | Doc[], targetCollection: Doc | undefined, addDocument: (document: Doc | Doc[], annotationKey?: string) => boolean) => boolean;
    pinToPres: (document: Doc, pinProps: PinProps) => void;
    ScreenToLocalTransform: () => Transform;
    bringToFront: (doc: Doc, sendToBack?: boolean) => void;
    waitForDoubleClickToClick?: () => 'never' | 'always' | undefined;
    defaultDoubleClick?: () => 'default' | 'ignore' | undefined;
    pointerEvents?: () => Opt<string>;
    treeViewDoc?: Doc;
    xPadding?: number;
    yPadding?: number;
    dontRegisterView?: boolean;
    childHideDecorationTitle?: boolean;
    childHideResizeHandles?: boolean;
    childDragAction?: dropActionType; // allows child documents to be dragged out of collection without holding the embedKey or dragging the doc decorations title bar.
    dropAction?: dropActionType;
    dragAction?: dropActionType;
    dragWhenActive?: boolean;
    dontHideOnDrag?: boolean;
    hideLinkButton?: boolean;
    hideCaptions?: boolean;
    ignoreAutoHeight?: boolean;
    forceAutoHeight?: boolean;
    suppressSetHeight?: boolean;
    disableBrushing?: boolean; // should highlighting for this view be disabled when same document in another view is hovered over.
    onClickScriptDisable?: 'never' | 'always'; // undefined = only when selected
}

// these props are specific to DocuentViews
export interface DocumentViewProps extends DocumentViewSharedProps {
    // properties specific to DocumentViews but not to FieldView
    hideDecorations?: boolean; // whether to suppress all DocumentDecorations when doc is selected
    hideResizeHandles?: boolean; // whether to suppress resized handles on doc decorations when this document is selected
    hideTitle?: boolean; // forces suppression of title. e.g, treeView document labels suppress titles in case they are globally active via settings
    hideDecorationTitle?: boolean; // forces suppression of title. e.g, treeView document labels suppress titles in case they are globally active via settings
    hideDocumentButtonBar?: boolean;
    hideOpenButton?: boolean;
    hideDeleteButton?: boolean;
    hideLinkAnchors?: boolean;
    contentPointerEvents?: 'none' | 'all' | undefined; // pointer events allowed for content of a document view.  eg. set to "none" in menuSidebar for sharedDocs so that you can select a document, but not interact with its contents
    LayoutTemplateString?: string;
    dontCenter?: 'x' | 'y' | 'xy';
    isDocumentActive?: () => boolean | undefined; // whether a document should handle pointer events
    isContentActive: () => boolean | undefined; // whether document contents should handle pointer events
    NativeWidth?: () => number;
    NativeHeight?: () => number;
    NativeDimScaling?: () => number; // scaling the DocumentView does to transform its contents into its panel & needed by ScreenToLocal NOTE: Must also be added to FieldViewProps
    LayoutTemplate?: () => Opt<Doc>;
    contextMenuItems?: () => { script: ScriptField; filter?: ScriptField; label: string; icon: string }[];
    onClick?: () => ScriptField;
    onDoubleClick?: () => ScriptField;
    onPointerDown?: () => ScriptField;
    onPointerUp?: () => ScriptField;
    onBrowseClick?: () => ScriptField | undefined;
    onKey?: (e: React.KeyboardEvent, fieldProps: FieldViewProps) => boolean | undefined;
    dragStarting?: () => void;
    dragEnding?: () => void;
}

// these props are only available in DocumentViewIntenral
export interface DocumentViewInternalProps extends DocumentViewProps {
    isSelected: () => boolean;
    select: (ctrlPressed: boolean, shiftPress?: boolean) => void;
    DocumentView: () => DocumentView;
    viewPath: () => DocumentView[];
}

@observer
export class DocumentViewInternal extends DocComponent<DocumentViewInternalProps>() {
    public static SelectAfterContextMenu = true; //  whether a document should be selected after it's contextmenu is triggered.
    private _disposers: { [name: string]: IReactionDisposer } = {};
    private _doubleClickTimeout: NodeJS.Timeout | undefined;
    private _singleClickFunc: undefined | (() => any);
    private _longPressSelector: NodeJS.Timeout | undefined;
    private _downX: number = 0;
    private _downY: number = 0;
    private _downTime: number = 0;
    private _lastTap: number = 0;
    private _doubleTap = false;
    private _mainCont = React.createRef<HTMLDivElement>();
    private _titleRef = React.createRef<EditableView>();
    private _dropDisposer?: DragManager.DragDropDisposer;
    constructor(props: any) {
        super(props);
        makeObservable(this);
    }

    @observable _componentView: Opt<DocComponentView> = undefined; // needs to be accessed from DocumentView wrapper class
    @observable _animateScaleTime: Opt<number> = undefined; // milliseconds for animating between views.  defaults to 300 if not uset
    @observable _animateScalingTo = 0;

    public get animateScaleTime() {
        return this._animateScaleTime ?? 100;
    }
    public get displayName() {
        return 'DocumentViewInternal(' + this._props.Document.title + ')';
    } // this makes mobx trace() statements more descriptive

    public get ContentDiv() {
        return this._mainCont.current;
    }
    public get LayoutFieldKey() {
        return Doc.LayoutFieldKey(this.layoutDoc);
    }
    @computed get layout_showTitle() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.ShowTitle) as Opt<string>;
    }
    @computed get NativeDimScaling() {
        return this._props.NativeDimScaling?.() || 1;
    }
    @computed get thumb() {
        return ImageCast(this.layoutDoc['thumb-frozen'], ImageCast(this.layoutDoc.thumb))?.url?.href.replace('.png', '_m.png');
    }
    @computed get opacity() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.Opacity);
    }
    @computed get boxShadow() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.BoxShadow);
    }
    @computed get borderRounding() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.BorderRounding);
    }
    @computed get widgetDecorations() {
        TraceMobx();
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.Decorations);
    }
    @computed get backgroundBoxColor() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.BackgroundColor + ':box');
    }
    @computed get docContents() {
        return this._props.styleProvider?.(this.Document, this._props, StyleProp.DocContents);
    }
    @computed get headerMargin() {
        return this._props?.styleProvider?.(this.layoutDoc, this._props, StyleProp.HeaderMargin) || 0;
    }
    @computed get layout_showCaption() {
        return this._props?.styleProvider?.(this.layoutDoc, this._props, StyleProp.ShowCaption) || 0;
    }
    @computed get titleHeight() {
        return this._props?.styleProvider?.(this.layoutDoc, this._props, StyleProp.TitleHeight) || 0;
    }
    @observable _pointerEvents: 'none' | 'all' | 'visiblePainted' | undefined = undefined;
    @computed get pointerEvents(): 'none' | 'all' | 'visiblePainted' | undefined {
        return this._pointerEvents;
    }
    @computed get finalLayoutKey() {
        return StrCast(this.Document.layout_fieldKey, 'layout');
    }
    @computed get disableClickScriptFunc() {
        const onScriptDisable = this._props.onClickScriptDisable ?? this._componentView?.onClickScriptDisable?.() ?? this.layoutDoc.onClickScriptDisable;
        // prettier-ignore
        return (
            DocumentView.LongPress ||
            onScriptDisable === 'always' ||
            (onScriptDisable !== 'never' && (this.rootSelected() || this._componentView?.isAnyChildContentActive?.()))
        );
    }
    @computed get onClickHandler() {
        return this._props.onClick?.() ?? this._props.onBrowseClick?.() ?? Cast(this.Document.onClick, ScriptField, Cast(this.layoutDoc.onClick, ScriptField, null));
    }
    @computed get onDoubleClickHandler() {
        return this._props.onDoubleClick?.() ?? Cast(this.layoutDoc.onDoubleClick, ScriptField, null) ?? this.Document.onDoubleClick;
    }
    @computed get onPointerDownHandler() {
        return this._props.onPointerDown?.() ?? ScriptCast(this.Document.onPointerDown);
    }
    @computed get onPointerUpHandler() {
        return this._props.onPointerUp?.() ?? ScriptCast(this.Document.onPointerUp);
    }

    componentWillUnmount() {
        this.cleanupHandlers(true);
    }
    @observable _mounted = false; // turn off all pointer events if component isn't yet mounted (enables nested Docs in alternate UI textboxes that appear on hover which otherwise would grab focus from the text box, reverting to the original UI )

    componentDidMount() {
        runInAction(() => (this._mounted = true));
        this.setupHandlers();
        this._disposers.contentActive = reaction(
            () => {
                //  true  - if the document has been activated directly or indirectly (by having its children selected)
                //  false - if its pointer events are explicitly turned off or if it's container tells it that it's inactive
                // undefined - it is not active, but it should be responsive to actions that might activate it or its contents (eg clicking)
                return this._props.isContentActive() === false || this._props.pointerEvents?.() === 'none'
                    ? false
                    : Doc.ActiveTool !== InkTool.None || SnappingManager.CanEmbed || this.rootSelected() || this.Document.forceActive || this._componentView?.isAnyChildContentActive?.() || this._props.isContentActive()
                      ? true
                      : undefined;
            },
            active => (this._isContentActive = active),
            { fireImmediately: true }
        );
        this._disposers.pointerevents = reaction(
            () => this._props.styleProvider?.(this.Document, this._props, StyleProp.PointerEvents),
            pointerevents => (this._pointerEvents = pointerevents),
            { fireImmediately: true }
        );
    }
    preDropFunc = (e: Event, de: DragManager.DropEvent) => {
        const dropAction = this.layoutDoc.dropAction as dropActionType;
        if (de.complete.docDragData && this.isContentActive() && !this._props.treeViewDoc) {
            dropAction && (de.complete.docDragData.dropAction = dropAction);
            e.stopPropagation();
        }
    };
    setupHandlers() {
        this.cleanupHandlers(false);
        if (this._mainCont.current) {
            this._dropDisposer = DragManager.MakeDropTarget(this._mainCont.current, this.drop.bind(this), this._props.Document, this.preDropFunc);
        }
    }

    cleanupHandlers(unbrush: boolean) {
        this._dropDisposer?.();
        unbrush && Doc.UnBrushDoc(this._props.Document);
        Object.values(this._disposers).forEach(disposer => disposer?.());
    }

    startDragging(x: number, y: number, dropAction: dropActionType, hideSource = false) {
        if (this._mainCont.current) {
            const views = SelectionManager.Views.filter(dv => dv.docView?._mainCont.current);
            const selected = views.length > 1 && views.some(dv => dv.Document === this.Document) ? views : [this._props.DocumentView()];
            const dragData = new DragManager.DocumentDragData(selected.map(dv => dv.Document));
            const [left, top] = this._props.ScreenToLocalTransform().scale(this.NativeDimScaling).inverse().transformPoint(0, 0);
            dragData.offset = this._props
                .ScreenToLocalTransform()
                .scale(this.NativeDimScaling)
                .transformDirection(x - left, y - top);
            dragData.dropAction = dropAction;
            dragData.treeViewDoc = this._props.treeViewDoc;
            dragData.removeDocument = this._props.removeDocument;
            dragData.moveDocument = this._props.moveDocument;
            dragData.draggedViews = [this._props.DocumentView()];
            dragData.canEmbed = this.Document.dragAction ?? this._props.dragAction ? true : false;
            DragManager.StartDocumentDrag(
                selected.map(dv => dv.docView!._mainCont.current!),
                dragData,
                x,
                y,
                { hideSource: hideSource || (!dropAction && !this.layoutDoc.onDragStart && !this._props.dontHideOnDrag) }
            ); // this needs to happen after the drop event is processed.
        }
    }

    defaultRestoreTargetView = (docView: DocumentView, anchor: Doc, focusSpeed: number, options: DocFocusOptions) => {
        const targetMatch =
            Doc.AreProtosEqual(anchor, this.Document) || // anchor is this document, so anchor's properties apply to this document
            (DocCast(anchor)?.layout_unrendered && Doc.AreProtosEqual(DocCast(anchor.annotationOn), this.Document)) // the anchor is an layout_unrendered annotation on this document, so anchor properties apply to this document
                ? true
                : false;
        return targetMatch && PresBox.restoreTargetDocView(docView, anchor, focusSpeed) ? focusSpeed : undefined;
    };

    // switches text input focus to the title bar of the document (and displays the title bar if it hadn't been)
    setTitleFocus = () => {
        if (!StrCast(this.layoutDoc._layout_showTitle)) this.layoutDoc._layout_showTitle = 'title';
        setTimeout(() => this._titleRef.current?.setIsFocused(true)); // use timeout in case title wasn't shown to allow re-render so that titleref will be defined
    };

    public static addDocTabFunc: (doc: Doc, location: OpenWhere) => boolean = returnFalse;

    onClick = action((e: React.MouseEvent | React.PointerEvent) => {
        if (this._props.isGroupActive?.() === 'child' && !this._props.isDocumentActive?.()) return;
        if (!this.Document.ignoreClick && this._props.renderDepth >= 0 && Utils.isClick(e.clientX, e.clientY, this._downX, this._downY, this._downTime)) {
            let stopPropagate = true;
            let preventDefault = true;
            !this.layoutDoc._keepZWhenDragged && this._props.bringToFront(this.Document);
            if (this._doubleTap) {
                const defaultDblclick = this._props.defaultDoubleClick?.() || this.Document.defaultDoubleClick;
                if (this.onDoubleClickHandler?.script) {
                    const { clientX, clientY, shiftKey, altKey, ctrlKey } = e; // or we could call e.persist() to capture variables
                    // prettier-ignore
                    const func = () => this.onDoubleClickHandler.script.run( {
                            this: this.Document,
                            scriptContext: this._props.scriptContext,
                            documentView: this._props.DocumentView(),
                            clientX, clientY,  altKey,  shiftKey,  ctrlKey,
                            value: undefined,
                        }, console.log  );
                    UndoManager.RunInBatch(() => (func().result?.select === true ? this._props.select(false) : ''), 'on double click');
                } else if (!Doc.IsSystem(this.Document) && (defaultDblclick === undefined || defaultDblclick === 'default')) {
                    UndoManager.RunInBatch(() => LightboxView.Instance.AddDocTab(this.Document, OpenWhere.lightbox), 'double tap');
                    SelectionManager.DeselectAll();
                    Doc.UnBrushDoc(this._props.Document);
                } else {
                    this._singleClickFunc?.();
                }
                this._doubleClickTimeout && clearTimeout(this._doubleClickTimeout);
                this._doubleClickTimeout = undefined;
                this._singleClickFunc = undefined;
            } else {
                let clickFunc: undefined | (() => any);
                if (!this.disableClickScriptFunc && this.onClickHandler?.script) {
                    const { clientX, clientY, shiftKey, altKey, metaKey } = e;
                    const func = () => {
                        // replace default add doc func with this view's add doc func.
                        // to allow override behaviors for how to display links to undisplayed documents.
                        // e.g., if this document is part of a labeled 'lightbox' container, then documents will be shown in place
                        // instead of in the global lightbox
                        const oldFunc = DocumentViewInternal.addDocTabFunc;
                        DocumentViewInternal.addDocTabFunc = this._props.addDocTab;
                        this.onClickHandler?.script.run(
                            {
                                this: this.Document,
                                _readOnly_: false,
                                scriptContext: this._props.scriptContext,
                                documentView: this._props.DocumentView(),
                                clientX,
                                clientY,
                                shiftKey,
                                altKey,
                                metaKey,
                            },
                            console.log
                        ).result?.select === true
                            ? this._props.select(false)
                            : '';
                        DocumentViewInternal.addDocTabFunc = oldFunc;
                    };
                    clickFunc = () => UndoManager.RunInBatch(func, 'click ' + this.Document.title);
                } else {
                    // onDragStart implies a button doc that we don't want to select when clicking. RootDocument & isTemplateForField implies we're clicking on part of a template instance and we want to select the whole template, not the part
                    if ((this.layoutDoc.onDragStart || this._props.TemplateDataDocument) && !(e.ctrlKey || e.button > 0)) {
                        stopPropagate = false; // don't stop propagation for field templates -- want the selection to propagate up to the root document of the template
                    }
                    preventDefault = false;
                }
                const sendToBack = e.altKey;
                this._singleClickFunc =
                    // prettier-ignore
                    clickFunc ?? (() => (sendToBack ? this._props.DocumentView()._props.bringToFront(this.Document, true) : 
                                                      this._componentView?.select?.(e.ctrlKey || e.metaKey, e.shiftKey) ?? 
                                        this._props.select(e.ctrlKey||e.shiftKey, e.metaKey)));
                const waitFordblclick = this._props.waitForDoubleClickToClick?.() ?? this.Document.waitForDoubleClickToClick;
                if ((clickFunc && waitFordblclick !== 'never') || waitFordblclick === 'always') {
                    this._doubleClickTimeout && clearTimeout(this._doubleClickTimeout);
                    this._doubleClickTimeout = setTimeout(this._singleClickFunc, 300);
                } else if (!DocumentView.LongPress) {
                    this._singleClickFunc();
                    this._singleClickFunc = undefined;
                }
            }
            stopPropagate && e.stopPropagation();
            preventDefault && e.preventDefault();
        }
    });

    onPointerDown = (e: React.PointerEvent): void => {
        if (this._props.isGroupActive?.() === 'child' && !this._props.isDocumentActive?.()) return;
        this._longPressSelector = setTimeout(() => {
            if (DocumentView.LongPress) {
                if (this.Document.undoIgnoreFields) {
                    runInAction(() => (UndoStack.HideInline = !UndoStack.HideInline));
                } else {
                    this._props.select(false);
                }
            }
        }, 1000);
        if (!GestureOverlay.DownDocView) GestureOverlay.DownDocView = this._props.DocumentView();

        this._downX = e.clientX;
        this._downY = e.clientY;
        this._downTime = Date.now();
        if ((Doc.ActiveTool === InkTool.None || this._props.addDocTab === returnFalse) && !(this._props.TemplateDataDocument && !(e.ctrlKey || e.button > 0))) {
            // click events stop here if the document is active and no modes are overriding it
            // if this is part of a template, let the event go up to the template root unless right/ctrl clicking
            if (
                // prettier-ignore
                (this._props.isDocumentActive?.() || this._props.isContentActive?.()) &&
                !this._props.onBrowseClick?.() &&
                !this.Document.ignoreClick &&
                e.button === 0 &&
                !Doc.IsInMyOverlay(this.layoutDoc)
            ) {
                e.stopPropagation();
                // don't preventDefault anymore.  Goldenlayout, PDF text selection and RTF text selection all need it to go though
                //if (this._props.isSelected(true) && this.Document.type !== DocumentType.PDF && this.layoutDoc._type_collection !== CollectionViewType.Docking) e.preventDefault();

                // listen to move events if document content isn't active or document is draggable
                if (!this.layoutDoc._lockedPosition && (!this.isContentActive() || BoolCast(this.layoutDoc._dragWhenActive, this._props.dragWhenActive))) {
                    document.addEventListener('pointermove', this.onPointerMove);
                }
            }
            document.addEventListener('pointerup', this.onPointerUp);
        }
    };

    onPointerMove = (e: PointerEvent): void => {
        if (e.buttons !== 1 || [InkTool.Highlighter, InkTool.Pen, InkTool.Write].includes(Doc.ActiveTool)) return;

        if (!Utils.isClick(e.clientX, e.clientY, this._downX, this._downY, Date.now())) {
            this.cleanupPointerEvents();
            this._longPressSelector && clearTimeout(this._longPressSelector);
            this.startDragging(this._downX, this._downY, ((e.ctrlKey || e.altKey) && 'embed') || ((this.Document.dragAction || this._props.dragAction || undefined) as dropActionType));
        }
    };

    cleanupPointerEvents = () => {
        document.removeEventListener('pointermove', this.onPointerMove);
        document.removeEventListener('pointerup', this.onPointerUp);
    };

    onPointerUp = (e: PointerEvent): void => {
        this.cleanupPointerEvents();
        this._longPressSelector && clearTimeout(this._longPressSelector);

        if (this.onPointerUpHandler?.script) {
            this.onPointerUpHandler.script.run({ this: this.Document }, console.log);
        } else if (e.button === 0 && Utils.isClick(e.clientX, e.clientY, this._downX, this._downY, this._downTime)) {
            this._doubleTap = (this.onDoubleClickHandler?.script || this.Document.defaultDoubleClick !== 'ignore') && Date.now() - this._lastTap < Utils.CLICK_TIME;
            if (!this.isContentActive()) this._lastTap = Date.now(); // don't want to process the start of a double tap if the doucment is selected
        }
        if (DocumentView.LongPress) e.preventDefault();
    };

    @undoBatch
    toggleFollowLink = (zoom?: boolean, setTargetToggle?: boolean): void => {
        const hadOnClick = this.Document.onClick;
        this.noOnClick();
        this.Document.onClick = hadOnClick ? undefined : FollowLinkScript();
        this.Document.waitForDoubleClickToClick = hadOnClick ? undefined : 'never';
    };
    @undoBatch
    followLinkOnClick = () => {
        this.Document.ignoreClick = false;
        this.Document.onClick = FollowLinkScript();
        this.Document.followLinkToggle = false;
        this.Document.followLinkZoom = false;
        this.Document.followLinkLocation = undefined;
    };
    @undoBatch
    noOnClick = () => {
        this.Document.ignoreClick = false;
        this.Document.onClick = Doc.GetProto(this.Document).onClick = undefined;
    };

    @undoBatch deleteClicked = () => this._props.removeDocument?.(this._props.Document);
    @undoBatch setToggleDetail = () =>
        (this.Document.onClick = ScriptField.MakeScript(
            `toggleDetail(documentView, "${StrCast(this.Document.layout_fieldKey)
                .replace('layout_', '')
                .replace(/^layout$/, 'detail')}")`,
            { documentView: 'any' }
        ));

    @undoBatch
    drop = (e: Event, de: DragManager.DropEvent) => {
        if (this._props.dontRegisterView || this._props.LayoutTemplateString?.includes(LinkAnchorBox.name)) return false;
        if (this._props.Document === Doc.ActiveDashboard) {
            e.stopPropagation();
            e.preventDefault();
            alert(
                (e.target as any)?.closest?.('*.lm_content')
                    ? "You can't perform this move most likely because you didn't drag the document's title bar to enable embedding in a different document."
                    : 'Linking to document tabs not yet supported. Drop link on document content.'
            );
            return true;
        }
        const linkdrag = de.complete.annoDragData ?? de.complete.linkDragData;
        if (linkdrag) {
            linkdrag.linkSourceDoc = linkdrag.linkSourceGetAnchor();
            if (linkdrag.linkSourceDoc && linkdrag.linkSourceDoc !== this.Document) {
                if (de.complete.annoDragData && !de.complete.annoDragData.dropDocument) {
                    de.complete.annoDragData.dropDocument = de.complete.annoDragData.dropDocCreator(undefined);
                }
                if (de.complete.annoDragData || this.Document !== linkdrag.linkSourceDoc.embedContainer) {
                    const dropDoc = de.complete.annoDragData?.dropDocument ?? this._componentView?.getAnchor?.(true) ?? this.Document;
                    de.complete.linkDocument = DocUtils.MakeLink(linkdrag.linkSourceDoc, dropDoc, {}, undefined, [de.x, de.y - 50]);
                    if (de.complete.linkDocument) {
                        de.complete.linkDocument.layout_isSvg = true;
                        this._props.DocumentView().CollectionFreeFormView?.addDocument(de.complete.linkDocument);
                    }
                }
                e.stopPropagation();
                return true;
            }
        }
        return false;
    };

    @undoBatch
    makeIntoPortal = () => {
        const portalLink = this.allLinks.find(d => d.link_anchor_1 === this._props.Document && d.link_relationship === 'portal to:portal from');
        if (!portalLink) {
            DocUtils.MakeLink(
                this._props.Document,
                Docs.Create.FreeformDocument([], {
                    _width: NumCast(this.layoutDoc._width) + 10,
                    _height: Math.max(NumCast(this.layoutDoc._height), NumCast(this.layoutDoc._width) + 10),
                    _isLightbox: true,
                    _layout_fitWidth: true,
                    title: StrCast(this._props.Document.title) + ' [Portal]',
                }),
                { link_relationship: 'portal to:portal from' }
            );
        }
        this.Document.followLinkLocation = OpenWhere.lightbox;
        this.Document.onClick = FollowLinkScript();
    };

    importDocument = () => {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = '.zip';
        input.onchange = _e => {
            if (input.files) {
                const batch = UndoManager.StartBatch('importing');
                Doc.importDocument(input.files[0]).then(doc => {
                    if (doc instanceof Doc) {
                        this._props.addDocTab(doc, OpenWhere.addRight);
                        batch.end();
                    }
                });
            }
        };
        input.click();
    };

    onContextMenu = (e?: React.MouseEvent, pageX?: number, pageY?: number) => {
        if (e && this.layoutDoc._layout_hideContextMenu && Doc.noviceMode) {
            e.preventDefault();
            e.stopPropagation();
            //!this._props.isSelected(true) && SelectionManager.SelectView(this._props.DocumentView(), false);
        }
        // the touch onContextMenu is button 0, the pointer onContextMenu is button 2
        if (e) {
            if ((e.button === 0 && !e.ctrlKey) || e.isDefaultPrevented()) {
                e.preventDefault();
                return;
            }
            e.preventDefault();
            e.stopPropagation();
            e.persist();

            if (!navigator.userAgent.includes('Mozilla') && (Math.abs(this._downX - e?.clientX) > 3 || Math.abs(this._downY - e?.clientY) > 3)) {
                return;
            }
        }

        const cm = ContextMenu.Instance;
        if (!cm || (e as any)?.nativeEvent?.SchemaHandled || SnappingManager.ExploreMode) return;

        if (e && !(e.nativeEvent as any).dash) {
            const onDisplay = () => {
                if (this.Document.type !== DocumentType.MAP) DocumentViewInternal.SelectAfterContextMenu && !this._props.isSelected() && SelectionManager.SelectView(this._props.DocumentView(), false); // on a mac, the context menu is triggered on mouse down, but a YouTube video becaomes interactive when selected which means that the context menu won't show up.  by delaying the selection until hopefully after the pointer up, the context menu will appear.
                setTimeout(() => simulateMouseClick(document.elementFromPoint(e.clientX, e.clientY), e.clientX, e.clientY, e.screenX, e.screenY));
            };
            if (navigator.userAgent.includes('Macintosh')) {
                cm.displayMenu((e?.pageX || pageX || 0) - 15, (e?.pageY || pageY || 0) - 15, undefined, undefined, onDisplay);
            } else {
                onDisplay();
            }
            return;
        }

        const customScripts = Cast(this._props.Document.contextMenuScripts, listSpec(ScriptField), []);
        StrListCast(this.Document.contextMenuLabels).forEach((label, i) =>
            cm.addItem({ description: label, event: () => customScripts[i]?.script.run({ documentView: this, this: this.Document, scriptContext: this._props.scriptContext }), icon: 'sticky-note' })
        );
        this._props.contextMenuItems?.().forEach(item => item.label && cm.addItem({ description: item.label, event: () => item.script.script.run({ this: this.Document, scriptContext: this._props.scriptContext }), icon: item.icon as IconProp }));

        if (!this._props.Document.isFolder) {
            const templateDoc = Cast(this._props.Document[StrCast(this._props.Document.layout_fieldKey)], Doc, null);
            const appearance = cm.findByDescription('Appearance...');
            const appearanceItems: ContextMenuProps[] = appearance && 'subitems' in appearance ? appearance.subitems : [];

            if (this._props.renderDepth === 0) {
                appearanceItems.splice(0, 0, { description: 'Open in Lightbox', event: () => LightboxView.Instance.SetLightboxDoc(this.Document), icon: 'external-link-alt' });
            }
            appearanceItems.push({ description: 'Pin', event: () => this._props.pinToPres(this.Document, {}), icon: 'eye' });
            !Doc.noviceMode && templateDoc && appearanceItems.push({ description: 'Open Template   ', event: () => this._props.addDocTab(templateDoc, OpenWhere.addRight), icon: 'eye' });
            !appearance && appearanceItems.length && cm.addItem({ description: 'Appearance...', subitems: appearanceItems, icon: 'compass' });

            if (!Doc.IsSystem(this.Document) && this.Document.type !== DocumentType.PRES && ![CollectionViewType.Docking, CollectionViewType.Tree].includes(this.Document._type_collection as any)) {
                const existingOnClick = cm.findByDescription('OnClick...');
                const onClicks: ContextMenuProps[] = existingOnClick && 'subitems' in existingOnClick ? existingOnClick.subitems : [];

                if (this._props.bringToFront !== emptyFunction) {
                    const zorders = cm.findByDescription('ZOrder...');
                    const zorderItems: ContextMenuProps[] = zorders && 'subitems' in zorders ? zorders.subitems : [];
                    zorderItems.push({ description: 'Bring to Front', event: () => SelectionManager.Views.forEach(dv => dv._props.bringToFront(dv.Document, false)), icon: 'arrow-up' });
                    zorderItems.push({ description: 'Send to Back', event: () => SelectionManager.Views.forEach(dv => dv._props.bringToFront(dv.Document, true)), icon: 'arrow-down' });
                    zorderItems.push({
                        description: !this.layoutDoc._keepZDragged ? 'Keep ZIndex when dragged' : 'Allow ZIndex to change when dragged',
                        event: undoBatch(action(() => (this.layoutDoc._keepZWhenDragged = !this.layoutDoc._keepZWhenDragged))),
                        icon: 'hand-point-up',
                    });
                    !zorders && cm.addItem({ description: 'Z Order...', addDivider: true, noexpand: true, subitems: zorderItems, icon: 'layer-group' });
                }

                onClicks.push({ description: 'Enter Portal', event: this.makeIntoPortal, icon: 'window-restore' });
                !Doc.noviceMode && onClicks.push({ description: 'Toggle Detail', event: this.setToggleDetail, icon: 'concierge-bell' });

                if (!this._props.treeViewDoc) {
                    if (!this.Document.annotationOn) {
                        const options = cm.findByDescription('Options...');
                        const optionItems: ContextMenuProps[] = options && 'subitems' in options ? options.subitems : [];
                        !options && cm.addItem({ description: 'Options...', subitems: optionItems, icon: 'compass' });

                        onClicks.push({ description: this.onClickHandler ? 'Remove Click Behavior' : 'Follow Link', event: () => this.toggleFollowLink(false, false), icon: 'link' });
                        !Doc.noviceMode && onClicks.push({ description: 'Edit onClick Script', event: () => UndoManager.RunInBatch(() => DocUtils.makeCustomViewClicked(this._props.Document, undefined, 'onClick'), 'edit onClick'), icon: 'terminal' });
                        !existingOnClick && cm.addItem({ description: 'OnClick...', noexpand: true, subitems: onClicks, icon: 'mouse-pointer' });
                    } else if (LinkManager.Links(this.Document).length) {
                        onClicks.push({ description: 'Restore On Click default', event: () => this.noOnClick(), icon: 'link' });
                        onClicks.push({ description: 'Follow Link on Click', event: () => this.followLinkOnClick(), icon: 'link' });
                        !existingOnClick && cm.addItem({ description: 'OnClick...', subitems: onClicks, icon: 'mouse-pointer' });
                    }
                }
            }

            const funcs: ContextMenuProps[] = [];
            if (!Doc.noviceMode && this.layoutDoc.onDragStart) {
                funcs.push({ description: 'Drag an Embedding', icon: 'edit', event: () => this.Document.dragFactory && (this.layoutDoc.onDragStart = ScriptField.MakeFunction('getEmbedding(this.dragFactory)')) });
                funcs.push({ description: 'Drag a Copy', icon: 'edit', event: () => this.Document.dragFactory && (this.layoutDoc.onDragStart = ScriptField.MakeFunction('getCopy(this.dragFactory, true)')) });
                funcs.push({ description: 'Drag Document', icon: 'edit', event: () => (this.layoutDoc.onDragStart = undefined) });
                cm.addItem({ description: 'OnDrag...', noexpand: true, subitems: funcs, icon: 'asterisk' });
            }

            const more = cm.findByDescription('More...');
            const moreItems = more && 'subitems' in more ? more.subitems : [];
            if (!Doc.IsSystem(this.Document)) {
                if (!Doc.noviceMode) {
                    moreItems.push({ description: 'Make View of Metadata Field', event: () => Doc.MakeMetadataFieldTemplate(this._props.Document, this._props.TemplateDataDocument), icon: 'concierge-bell' });
                    moreItems.push({ description: `${this.Document._chromeHidden ? 'Show' : 'Hide'} Chrome`, event: () => (this.Document._chromeHidden = !this.Document._chromeHidden), icon: 'project-diagram' });

                    if (Cast(Doc.GetProto(this._props.Document).data, listSpec(Doc))) {
                        moreItems.push({ description: 'Export to Google Photos Album', event: () => GooglePhotos.Export.CollectionToAlbum({ collection: this._props.Document }).then(console.log), icon: 'caret-square-right' });
                        moreItems.push({ description: 'Tag Child Images via Google Photos', event: () => GooglePhotos.Query.TagChildImages(this._props.Document), icon: 'caret-square-right' });
                        moreItems.push({ description: 'Write Back Link to Album', event: () => GooglePhotos.Transactions.AddTextEnrichment(this._props.Document), icon: 'caret-square-right' });
                    }
                    moreItems.push({ description: 'Copy ID', event: () => Utils.CopyText(Doc.globalServerPath(this._props.Document)), icon: 'fingerprint' });
                }
            }

            !more && moreItems.length && cm.addItem({ description: 'More...', subitems: moreItems, icon: 'compass' });
        }
        const constantItems: ContextMenuProps[] = [];
        if (!Doc.IsSystem(this.Document) && this.Document._type_collection !== CollectionViewType.Docking) {
            constantItems.push({ description: 'Zip Export', icon: 'download', event: async () => Doc.Zip(this._props.Document) });
            (this.Document._type_collection !== CollectionViewType.Docking || !Doc.noviceMode) && constantItems.push({ description: 'Share', event: () => SharingManager.Instance.open(this._props.DocumentView()), icon: 'users' });
            if (this._props.removeDocument && Doc.ActiveDashboard !== this._props.Document) {
                // need option to gray out menu items ... preferably with a '?' that explains why they're grayed out (eg., no permissions)
                constantItems.push({ description: 'Close', event: this.deleteClicked, icon: 'times' });
            }
        }
        constantItems.push({ description: 'Show Metadata', event: () => this._props.addDocTab(this._props.Document, OpenWhere.addRightKeyvalue), icon: 'table-columns' });
        cm.addItem({ description: 'General...', noexpand: false, subitems: constantItems, icon: 'question' });

        const help = cm.findByDescription('Help...');
        const helpItems: ContextMenuProps[] = help && 'subitems' in help ? help.subitems : [];
        !Doc.noviceMode && helpItems.push({ description: 'Text Shortcuts Ctrl+/', event: () => this._props.addDocTab(Docs.Create.PdfDocument('/assets/cheat-sheet.pdf', { _width: 300, _height: 300 }), OpenWhere.addRight), icon: 'keyboard' });
        !Doc.noviceMode && helpItems.push({ description: 'Print Document in Console', event: () => console.log(this.Document), icon: 'hand-point-right' });
        !Doc.noviceMode && helpItems.push({ description: 'Print DataDoc in Console', event: () => console.log(this.dataDoc), icon: 'hand-point-right' });

        let documentationDescription: string | undefined = undefined;
        let documentationLink: string | undefined = undefined;
        switch (this._props.Document.type) {
            case DocumentType.COL:
                documentationDescription = 'See collection documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/views/';
                break;
            case DocumentType.PDF:
                documentationDescription = 'See PDF node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/pdf/';
                break;
            case DocumentType.VID:
                documentationDescription = 'See video node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/tempMedia/video';
                break;
            case DocumentType.AUDIO:
                documentationDescription = 'See audio node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/tempMedia/audio';
                break;
            case DocumentType.WEB:
                documentationDescription = 'See webpage node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/webpage/';
                break;
            case DocumentType.IMG:
                documentationDescription = 'See image node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/images/';
                break;
            case DocumentType.RTF:
                documentationDescription = 'See text node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/text/';
                break;
            case DocumentType.DATAVIZ:
                documentationDescription = 'See DataViz node documentation';
                documentationLink = 'https://brown-dash.github.io/Dash-Documentation/documents/dataViz/';
                break;
        }
        // Add link to help documentation
        if (!this._props.treeViewDoc && documentationDescription && documentationLink) {
            helpItems.push({
                description: documentationDescription,
                event: () => window.open(documentationLink, '_blank'),
                icon: 'book',
            });
        }
        if (!help) cm.addItem({ description: 'Help...', noexpand: !Doc.noviceMode, subitems: helpItems, icon: 'question' });
        else cm.moveAfter(help);

        e?.stopPropagation(); // DocumentViews should stop propagation of this event
        cm.displayMenu((e?.pageX || pageX || 0) - 15, (e?.pageY || pageY || 0) - 15, undefined, undefined, undefined);
    };

    @computed get _rootSelected() {
        return this._props.isSelected() || BoolCast(this._props.TemplateDataDocument && this._props.rootSelected?.());
    }
    rootSelected = () => this._rootSelected;
    panelHeight = () => this._props.PanelHeight() - this.headerMargin;
    contentScreenToLocal = () => this._props.ScreenToLocalTransform().translate(0, -this.headerMargin);
    onClickFunc: any = () => (this.disableClickScriptFunc ? undefined : this.onClickHandler);
    setHeight = (height: number) => !this._props.suppressSetHeight && (this.layoutDoc._height = height);
    setContentView = action((view: { getAnchor?: (addAsAnnotation: boolean) => Doc; forward?: () => boolean; back?: () => boolean }) => (this._componentView = view));
    @observable _isContentActive: boolean | undefined = undefined;

    isContentActive = (): boolean | undefined => this._isContentActive;
    childFilters = () => [...this._props.childFilters(), ...StrListCast(this.layoutDoc.childFilters)];

    /// disable pointer events on content when there's an enabled onClick script (but not the browse script) and the contents aren't forced active, or if contents are marked inactive
    @computed get _contentPointerEvents() {
        TraceMobx();
        return this._props.contentPointerEvents ??
            ((!this.disableClickScriptFunc && //
                this.onClickHandler &&
                !this._props.onBrowseClick?.() &&
                this.isContentActive() !== true) ||
                this.isContentActive() === false)
            ? 'none'
            : this.pointerEvents;
    }
    contentPointerEvents = () => this._contentPointerEvents;
    @computed get contents() {
        TraceMobx();
        const isInk = this.layoutDoc._layout_isSvg && !this._props.LayoutTemplateString;
        const noBackground = this.Document.isGroup && !this._props.LayoutTemplateString?.includes(KeyValueBox.name) && (!this.layoutDoc.backgroundColor || this.layoutDoc.backgroundColor === 'transparent');
        return (
            <div
                className="documentView-contentsView"
                style={{
                    pointerEvents: (isInk || noBackground ? 'none' : this.contentPointerEvents()) ?? (this._mounted ? 'all' : 'none'),
                    height: this.headerMargin ? `calc(100% - ${this.headerMargin}px)` : undefined,
                }}>
                <DocumentContentsView
                    key={1}
                    {...this._props}
                    fieldKey=""
                    pointerEvents={this.contentPointerEvents}
                    docViewPath={this._props.viewPath}
                    setContentView={this.setContentView}
                    childFilters={this.childFilters}
                    PanelHeight={this.panelHeight}
                    setHeight={this.setHeight}
                    isContentActive={this.isContentActive}
                    ScreenToLocalTransform={this.contentScreenToLocal}
                    rootSelected={this.rootSelected}
                    onClick={this.onClickFunc}
                    setTitleFocus={this.setTitleFocus}
                    layout_fieldKey={this.finalLayoutKey}
                />
                {this.layoutDoc.layout_hideAllLinks ? null : this.allLinkEndpoints}
            </div>
        );
    }

    anchorPanelWidth = () => this._props.PanelWidth() || 1;
    anchorPanelHeight = () => this._props.PanelHeight() || 1;
    anchorStyleProvider = (doc: Opt<Doc>, props: Opt<DocumentViewProps>, property: string): any => {
        // prettier-ignore
        switch (property.split(':')[0]) {
            case StyleProp.ShowTitle:     return '';
            case StyleProp.PointerEvents: return 'none';
            case StyleProp.Highlighting:  return undefined;
            case StyleProp.Opacity:       {
                const filtered = DocUtils.FilterDocs(this.directLinks, this._props.childFilters?.() ?? [], []).filter(d => d.link_displayLine || Doc.UserDoc().showLinkLines);
                return filtered.some(link => link._link_displayArrow) ? 0 : undefined;
            }
        }
        return this._props.styleProvider?.(doc, props, property);
    };
    // We need to use allrelatedLinks to get not just links to the document as a whole, but links to
    // anchors that are not rendered as DocumentViews (marked as 'layout_unrendered' with their 'annotationOn' set to this document).  e.g.,
    //     - PDF text regions are rendered as an Annotations without generating a DocumentView, '
    //     - RTF selections are rendered via Prosemirror and have a mark which contains the Document ID for the annotation link
    //     - and links to PDF/Web docs at a certain scroll location never create an explicit view.
    // For each of these, we create LinkAnchorBox's on the border of the DocumentView.
    @computed get directLinks() {
        TraceMobx();
        return LinkManager.Instance.getAllRelatedLinks(this.Document).filter(
            link =>
                (link.link_matchEmbeddings ? link.link_anchor_1 === this.Document : Doc.AreProtosEqual(link.link_anchor_1 as Doc, this.Document)) ||
                (link.link_matchEmbeddings ? link.link_anchor_2 === this.Document : Doc.AreProtosEqual(link.link_anchor_2 as Doc, this.Document)) ||
                ((link.link_anchor_1 as Doc)?.layout_unrendered && Doc.AreProtosEqual((link.link_anchor_1 as Doc)?.annotationOn as Doc, this.Document)) ||
                ((link.link_anchor_2 as Doc)?.layout_unrendered && Doc.AreProtosEqual((link.link_anchor_2 as Doc)?.annotationOn as Doc, this.Document))
        );
    }
    @computed get allLinks() {
        TraceMobx();
        return LinkManager.Instance.getAllRelatedLinks(this.Document);
    }
    hideLink = computedFn((link: Doc) => () => (link.link_displayLine = false));
    @computed get allLinkEndpoints() {
        // the small blue dots that mark the endpoints of links
        TraceMobx();
        if (this._componentView instanceof KeyValueBox || this._props.hideLinkAnchors || this.layoutDoc.layout_hideLinkAnchors || this._props.dontRegisterView || this.layoutDoc.layout_unrendered) return null;
        const filtered = DocUtils.FilterDocs(this.directLinks, this._props.childFilters?.() ?? [], []).filter(d => d.link_displayLine || Doc.UserDoc().showLinkLines);
        return filtered.map(link => (
            <div className="documentView-anchorCont" key={link[Id]}>
                <DocumentView
                    {...this._props}
                    isContentActive={returnFalse}
                    Document={link}
                    docViewPath={this._props.viewPath}
                    PanelWidth={this.anchorPanelWidth}
                    PanelHeight={this.anchorPanelHeight}
                    dontRegisterView={false}
                    layout_showTitle={returnEmptyString}
                    hideCaptions={true}
                    hideLinkAnchors={true}
                    layout_fitWidth={returnTrue}
                    removeDocument={this.hideLink(link)}
                    styleProvider={this.anchorStyleProvider}
                    LayoutTemplate={undefined}
                    LayoutTemplateString={LinkAnchorBox.LayoutString(`link_anchor_${LinkManager.anchorIndex(link, this.Document)}`)}
                />
            </div>
        ));
    }

    static recordAudioAnnotation(dataDoc: Doc, field: string, onRecording?: (stop: () => void) => void, onEnd?: () => void) {
        let gumStream: any;
        let recorder: any;
        navigator.mediaDevices
            .getUserMedia({
                audio: true,
            })
            .then(function (stream) {
                let audioTextAnnos = Cast(dataDoc[field + '_audioAnnotations_text'], listSpec('string'), null);
                if (audioTextAnnos) audioTextAnnos.push('');
                else audioTextAnnos = dataDoc[field + '_audioAnnotations_text'] = new List<string>(['']);
                DictationManager.Controls.listen({
                    interimHandler: value => (audioTextAnnos[audioTextAnnos.length - 1] = value),
                    continuous: { indefinite: false },
                }).then(results => {
                    if (results && [DictationManager.Controls.Infringed].includes(results)) {
                        DictationManager.Controls.stop();
                    }
                    onEnd?.();
                });

                gumStream = stream;
                recorder = new MediaRecorder(stream);
                recorder.ondataavailable = async (e: any) => {
                    const [{ result }] = await Networking.UploadFilesToServer({ file: e.data });
                    if (!(result instanceof Error)) {
                        const audioField = new AudioField(result.accessPaths.agnostic.client);
                        const audioAnnos = Cast(dataDoc[field + '_audioAnnotations'], listSpec(AudioField), null);
                        if (audioAnnos === undefined) {
                            dataDoc[field + '_audioAnnotations'] = new List([audioField]);
                        } else {
                            audioAnnos.push(audioField);
                        }
                    }
                };
                //runInAction(() => (dataDoc.audioAnnoState = 'recording'));
                recorder.start();
                const stopFunc = () => {
                    recorder.stop();
                    DictationManager.Controls.stop(false);
                    runInAction(() => (dataDoc.audioAnnoState = 'stopped'));
                    gumStream.getAudioTracks()[0].stop();
                };
                if (onRecording) onRecording(stopFunc);
                else setTimeout(stopFunc, 5000);
            });
    }
    playAnnotation = () => {
        const self = this;
        const audioAnnoState = this.dataDoc.audioAnnoState ?? 'stopped';
        const audioAnnos = Cast(this.dataDoc[this.LayoutFieldKey + '_audioAnnotations'], listSpec(AudioField), null);
        const anno = audioAnnos?.lastElement();
        if (anno instanceof AudioField) {
            switch (audioAnnoState) {
                case 'stopped':
                    this.dataDoc[AudioPlay] = new Howl({
                        src: [anno.url.href],
                        format: ['mp3'],
                        autoplay: true,
                        loop: false,
                        volume: 0.5,
                        onend: action(() => (self.dataDoc.audioAnnoState = 'stopped')),
                    });
                    this.dataDoc.audioAnnoState = 'playing';
                    break;
                case 'playing':
                    this.dataDoc[AudioPlay]?.stop();
                    this.dataDoc.audioAnnoState = 'stopped';
                    break;
            }
        }
    };

    captionStyleProvider = (doc: Opt<Doc>, props: Opt<DocumentViewProps>, property: string) => this._props?.styleProvider?.(doc, props, property + ':caption');
    @observable _changingTitleField = false;
    @observable _dropDownInnerWidth = 0;
    fieldsDropdown = (inputOptions: string[], dropdownWidth: number, placeholder: string, onChange: (val: string | number) => void, onClose: () => void) => {
        const filteredOptions = new Set(inputOptions);
        const scaling = this.titleHeight / 30; /* height of Dropdown */
        Object.entries(DocOptions)
            .filter(opts => opts[1].filterable)
            .forEach((pair: [string, FInfo]) => filteredOptions.add(pair[0]));
        filteredOptions.add(StrCast(this.layoutDoc.layout_showTitle));
        const options = Array.from(filteredOptions)
            .filter(f => f)
            .map(facet => ({ val: facet, text: facet }));
        return (
            <div style={{ width: dropdownWidth }}>
                <div
                    ref={action((r: any) => r && (this._dropDownInnerWidth = Number(getComputedStyle(r).width.replace('px', ''))))}
                    onPointerDown={action(e => (this._changingTitleField = true))}
                    style={{ width: 'max-content', transformOrigin: 'left', transform: `scale(${scaling})` }}>
                    <Dropdown
                        activeChanged={action(isOpen => !isOpen && (this._changingTitleField = false))}
                        selectedVal={placeholder}
                        setSelectedVal={onChange}
                        color={SettingsManager.userColor}
                        background={SettingsManager.userVariantColor}
                        type={Type.TERT}
                        closeOnSelect={true}
                        dropdownType={DropdownType.SELECT}
                        items={options}
                        width={100}
                        fillWidth
                    />
                </div>
            </div>
        );
    };
    @computed get innards() {
        TraceMobx();
        const showTitle = this.layout_showTitle?.split(':')[0];
        const showTitleHover = this.layout_showTitle?.includes(':hover');
        const captionView = !this.layout_showCaption ? null : (
            <div
                className="documentView-captionWrapper"
                style={{
                    pointerEvents: this.Document.ignoreClick ? 'none' : this.isContentActive() || this._props.isDocumentActive?.() ? 'all' : undefined,
                    background: StrCast(this.layoutDoc._backgroundColor, 'rgba(0,0,0,0.2)'),
                    color: lightOrDark(StrCast(this.layoutDoc._backgroundColor, 'black')),
                }}>
                <FormattedTextBox
                    {...this._props}
                    yPadding={10}
                    xPadding={10}
                    fieldKey={this.layout_showCaption}
                    styleProvider={this.captionStyleProvider}
                    dontRegisterView={true}
                    noSidebar={true}
                    dontScale={true}
                    renderDepth={this._props.renderDepth}
                    isContentActive={this.isContentActive}
                />
            </div>
        );
        const targetDoc = showTitle?.startsWith('_') ? this.layoutDoc : this.Document;
        const background = StrCast(
            this.layoutDoc.layout_headingColor,
            StrCast(SharingManager.Instance.users.find(u => u.user.email === this.dataDoc.author)?.sharingDoc.headingColor, StrCast(Doc.SharingDoc().headingColor, SettingsManager.userBackgroundColor))
        );
        const dropdownWidth = this._titleRef.current?._editing || this._changingTitleField ? Math.max(10, (this._dropDownInnerWidth * this.titleHeight) / 30) : 0;
        const sidebarWidthPercent = +StrCast(this.layoutDoc.layout_sidebarWidthPercent).replace('%', '');
        // displays a 'title' at the top of a document. The title contents default to the 'title' field, but can be changed to one or more fields by
        // setting layout_showTitle using the format:   field1[;field2[...][:hover]]
        // from the UI, this is done by clicking the title field and prefixin the format with '#'.  eg.,  #field1[;field2;...][:hover]
        const titleView = !showTitle ? null : (
            <div
                className={`documentView-titleWrapper${showTitleHover ? '-hover' : ''}`}
                key="title"
                style={{
                    zIndex: 1,
                    position: this.headerMargin ? 'relative' : 'absolute',
                    height: this.titleHeight,
                    width: 100 - sidebarWidthPercent + '%',
                    color: background === 'transparent' ? SettingsManager.userColor : lightOrDark(background),
                    background,
                    pointerEvents: (!this.disableClickScriptFunc && this.onClickHandler) || this.Document.ignoreClick ? 'none' : this.isContentActive() || this._props.isDocumentActive?.() ? 'all' : undefined,
                }}>
                {!dropdownWidth
                    ? null
                    : this.fieldsDropdown(
                          [],
                          dropdownWidth,
                          StrCast(this.layoutDoc.layout_showTitle).split(':')[0],
                          action((field: string | number) => {
                              if (this.layoutDoc.layout_showTitle) {
                                  this.layoutDoc._layout_showTitle = field;
                              } else if (!this._props.layout_showTitle) {
                                  Doc.UserDoc().layout_showTitle = field;
                              }
                              this._changingTitleField = false;
                          }),
                          action(() => (this._changingTitleField = false))
                      )}
                <div
                    style={{
                        width: `calc(100% - ${dropdownWidth}px)`,
                        minWidth: '100px',
                        color: this._titleRef.current?._editing || this._changingTitleField ? 'black' : undefined,
                        background: this._titleRef.current?._editing || this._changingTitleField ? 'yellow' : undefined,
                    }}>
                    <EditableView
                        ref={this._titleRef}
                        contents={showTitle
                            .split(';')
                            .map(field => targetDoc[field.trim()]?.toString())
                            .join(' \\ ')}
                        display="block"
                        oneLine={true}
                        fontSize={(this.titleHeight / 15) * 10}
                        GetValue={() => (showTitle.split(';').length !== 1 ? '#' + showTitle : Field.toKeyValueString(this.Document, showTitle.split(';')[0]))}
                        SetValue={undoBatch((input: string) => {
                            if (input?.startsWith('#')) {
                                if (this.layoutDoc.layout_showTitle) {
                                    this.layoutDoc._layout_showTitle = input?.substring(1);
                                } else if (!this._props.layout_showTitle) {
                                    Doc.UserDoc().layout_showTitle = input?.substring(1) ?? 'author_date';
                                }
                            } else if (showTitle && !showTitle.includes('Date') && showTitle !== 'author') {
                                KeyValueBox.SetField(targetDoc, showTitle, input);
                            }
                            return true;
                        })}
                    />
                </div>
            </div>
        );
        return this._props.hideTitle || (!showTitle && !this.layout_showCaption) ? (
            this.contents
        ) : (
            <div className="documentView-styleWrapper">
                {titleView}
                {this.contents}
                {captionView}
            </div>
        );
    }

    renderDoc = (style: object) => {
        TraceMobx();
        return !DocCast(this.Document) || GetEffectiveAcl(this.dataDoc) === AclPrivate
            ? null
            : this.docContents ?? (
                  <div
                      className="documentView-node"
                      id={this.Document[Id]}
                      style={{
                          ...style,
                          background: this.backgroundBoxColor,
                          opacity: this.opacity,
                          cursor: Doc.ActiveTool === InkTool.None ? 'grab' : 'crosshair',
                          color: StrCast(this.layoutDoc.color, 'inherit'),
                          fontFamily: StrCast(this.Document._text_fontFamily, 'inherit'),
                          fontSize: Cast(this.Document._text_fontSize, 'string', null),
                          transform: this._animateScalingTo ? `scale(${this._animateScalingTo})` : undefined,
                          transition: !this._animateScalingTo ? StrCast(this.Document.dataTransition) : `transform ${this.animateScaleTime / 1000}s ease-${this._animateScalingTo < 1 ? 'in' : 'out'}`,
                      }}>
                      {this.innards}
                      {this.widgetDecorations ?? null}
                  </div>
              );
    };

    /**
     * returns an entrance animation effect function to wrap a JSX element
     * @param presEffectDoc presentation effects document that specifies the animation effect parameters
     * @returns a function that will wrap a JSX animation element wrapping any JSX element
     */
    public static AnimationEffect(renderDoc: JSX.Element, presEffectDoc: Opt<Doc>, root: Doc) {
        const dir = presEffectDoc?.presentation_effectDirection ?? presEffectDoc?.followLinkAnimDirection;
        const effectProps = {
            left: dir === PresEffectDirection.Left,
            right: dir === PresEffectDirection.Right,
            top: dir === PresEffectDirection.Top,
            bottom: dir === PresEffectDirection.Bottom,
            opposite: true,
            delay: 0,
            duration: Cast(presEffectDoc?.presentation_transition, 'number', Cast(presEffectDoc?.followLinkTransitionTime, 'number', null)),
        };
        //prettier-ignore
        switch (StrCast(presEffectDoc?.presentation_effect, StrCast(presEffectDoc?.followLinkAnimEffect))) {
            default: 
            case PresEffect.None:       return renderDoc;
            case PresEffect.Zoom:       return <Zoom {...effectProps}>{renderDoc}</Zoom>;
            case PresEffect.Fade:       return <Fade {...effectProps}>{renderDoc}</Fade>;
            case PresEffect.Flip:       return <Flip {...effectProps}>{renderDoc}</Flip>;
            case PresEffect.Rotate:     return <Rotate {...effectProps}>{renderDoc}</Rotate>;
            case PresEffect.Bounce:     return <Bounce {...effectProps}>{renderDoc}</Bounce>;
            case PresEffect.Roll:       return <Roll {...effectProps}>{renderDoc}</Roll>;
            case PresEffect.Lightspeed: return <JackInTheBox {...effectProps}>{renderDoc}</JackInTheBox>;
        }
    }
    @computed get highlighting() {
        return this._props.styleProvider?.(this.Document, this._props, StyleProp.Highlighting);
    }
    @computed get borderPath() {
        return this._props.styleProvider?.(this.Document, this._props, StyleProp.BorderPath);
    }
    render() {
        TraceMobx();
        const highlighting = this.highlighting;
        const borderPath = this.borderPath;
        const boxShadow =
            this._props.treeViewDoc || !highlighting
                ? this.boxShadow
                : highlighting && this.borderRounding && highlighting.highlightStyle !== 'dashed'
                  ? `0 0 0 ${highlighting.highlightIndex}px ${highlighting.highlightColor}`
                  : this.boxShadow || (this.Document.isTemplateForField ? 'black 0.2vw 0.2vw 0.8vw' : undefined);
        const renderDoc = this.renderDoc({
            borderRadius: this.borderRounding,
            outline: highlighting && !this.borderRounding && !highlighting.highlightStroke ? `${highlighting.highlightColor} ${highlighting.highlightStyle} ${highlighting.highlightIndex}px` : 'solid 0px',
            border: highlighting && this.borderRounding && highlighting.highlightStyle === 'dashed' ? `${highlighting.highlightStyle} ${highlighting.highlightColor} ${highlighting.highlightIndex}px` : undefined,
            boxShadow,
            clipPath: borderPath?.clipPath,
        });

        return (
            <div
                className={`${DocumentView.ROOT_DIV} docView-hack`}
                ref={this._mainCont}
                onContextMenu={this.onContextMenu}
                onPointerDown={this.onPointerDown}
                onClick={this.onClick}
                onPointerEnter={e => (!SnappingManager.IsDragging || SnappingManager.CanEmbed) && Doc.BrushDoc(this.Document)}
                onPointerOver={e => (!SnappingManager.IsDragging || SnappingManager.CanEmbed) && Doc.BrushDoc(this.Document)}
                onPointerLeave={e => !isParentOf(this.ContentDiv, document.elementFromPoint(e.nativeEvent.x, e.nativeEvent.y)) && Doc.UnBrushDoc(this.Document)}
                style={{
                    borderRadius: this.borderRounding,
                    pointerEvents: this.pointerEvents === 'visiblePainted' ? 'none' : this.pointerEvents, // visible painted means that the underlying doc contents are irregular and will process their own pointer events (otherwise, the contents are expected to fill the entire doc view box so we can handle pointer events here)
                }}>
                <>
                    {this._componentView instanceof KeyValueBox ? renderDoc : DocumentViewInternal.AnimationEffect(renderDoc, this.Document[Animation], this.Document)}
                    {borderPath?.jsx}
                </>
            </div>
        );
    }
}

@observer
export class DocumentView extends ObservableReactComponent<DocumentViewProps> {
    public static ROOT_DIV = 'documentView-effectsWrapper';

    constructor(props: any) {
        super(props);
        makeObservable(this);
    }

    @observable _selected = false;
    public get IsSelected() {
        return this._selected;
    }
    public set IsSelected(val) {
        runInAction(() => (this._selected = val));
    }
    @observable public static LongPress = false;
    @computed public static get exploreMode() {
        return () => (SnappingManager.ExploreMode ? ScriptField.MakeScript('CollectionBrowseClick(documentView, clientX, clientY)', { documentView: 'any', clientX: 'number', clientY: 'number' })! : undefined);
    }
    @observable public docView: DocumentViewInternal | undefined | null = undefined;
    @observable public textHtmlOverlay: Opt<string> = undefined;
    @observable public textHtmlOverlayTime: Opt<number> = undefined;
    @observable private _isHovering = false;

    public htmlOverlayEffect: Opt<Doc>;
    public get displayName() {
        return 'DocumentView(' + this._props.Document?.title + ')';
    } // this makes mobx trace() statements more descriptive
    public ContentRef = React.createRef<HTMLDivElement>();
    public ViewTimer: NodeJS.Timeout | undefined; // timer for res
    public AnimEffectTimer: NodeJS.Timeout | undefined; // timer for res
    private _disposers: { [name: string]: IReactionDisposer } = {};
    public clearViewTransition = () => {
        this.ViewTimer && clearTimeout(this.ViewTimer);
        this.layoutDoc._viewTransition = undefined;
    };
    public startDragging = (x: number, y: number, dropAction: dropActionType, hideSource = false) => this.docView?.startDragging(x, y, dropAction, hideSource);

    public showContextMenu = (pageX: number, pageY: number) => this.docView?.onContextMenu(undefined, pageX, pageY);

    public setAnimEffect = (presEffect: Doc, timeInMs: number, afterTrans?: () => void) => {
        this.AnimEffectTimer && clearTimeout(this.AnimEffectTimer);
        this.Document[Animation] = presEffect;
        this.AnimEffectTimer = setTimeout(() => (this.Document[Animation] = undefined), timeInMs);
    };
    public setViewTransition = (transProp: string, timeInMs: number, afterTrans?: () => void, dataTrans = false) => {
        this.layoutDoc._viewTransition = `${transProp} ${timeInMs}ms`;
        if (dataTrans) this.Document._dataTransition = `${transProp} ${timeInMs}ms`;
        this.ViewTimer && clearTimeout(this.ViewTimer);
        return (this.ViewTimer = setTimeout(() => {
            this.layoutDoc._viewTransition = undefined;
            this.Document._dataTransition = 'inherit';
            afterTrans?.();
        }, timeInMs + 10));
    };
    public static SetViewTransition(docs: Doc[], transProp: string, timeInMs: number, afterTrans?: () => void, dataTrans = false) {
        docs.forEach(doc => {
            doc._viewTransition = `${transProp} ${timeInMs}ms`;
            dataTrans && (doc.dataTransition = `${transProp} ${timeInMs}ms`);
        });
        return setTimeout(
            () =>
                docs.forEach(doc => {
                    doc._viewTransition = undefined;
                    dataTrans && (doc.dataTransition = 'inherit');
                    afterTrans?.();
                }),
            timeInMs + 10
        );
    }

    // shows a stacking view collection (by default, but the user can change) of all documents linked to the source
    public static showBackLinks(linkAnchor: Doc) {
        const docId = Doc.CurrentUserEmail + Doc.GetProto(linkAnchor)[Id] + '-pivotish';
        // prettier-ignore
        DocServer.GetRefField(docId).then(docx =>
            LightboxView.Instance.SetLightboxDoc(
                (docx as Doc) ?? // reuse existing pivot view of documents, or else create a new collection
                Docs.Create.StackingDocument([], { title: linkAnchor.title + '-pivot', _width: 500, _height: 500, target: linkAnchor, updateContentsScript: ScriptField.MakeScript('updateLinkCollection(this, this.target)') }, docId)
            )
        );
    }

    get Document() {
        return this._props.Document;
    }
    get topMost() {
        return this._props.renderDepth === 0;
    }
    get dataDoc() {
        return this.docView?.dataDoc ?? this.Document;
    }
    get ContentDiv() {
        return this.docView?.ContentDiv;
    }
    get ComponentView() {
        return this.docView?._componentView;
    }
    get allLinks() {
        return (this.docView?.allLinks || []).filter(link => !link.link_matchEmbeddings || link.link_anchor_1 === this.Document || link.link_anchor_2 === this.Document);
    }
    get LayoutFieldKey() {
        return this.docView?.LayoutFieldKey || 'layout';
    }
    @computed get layout_fitWidth() {
        return this._props.layout_fitWidth?.(this.layoutDoc) ?? this.layoutDoc?.layout_fitWidth;
    }
    @computed get anchorViewDoc() {
        return this._props.LayoutTemplateString?.includes('link_anchor_2') ? DocCast(this.Document['link_anchor_2']) : this._props.LayoutTemplateString?.includes('link_anchor_1') ? DocCast(this.Document['link_anchor_1']) : undefined;
    }
    @computed get hideLinkButton() {
        return this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.HideLinkBtn + (this.IsSelected ? ':selected' : ''));
    }
    hideLinkCount = () => this._props.renderDepth === -1 || (this.IsSelected && this._props.renderDepth) || !this._isHovering || this.hideLinkButton;
    @computed get linkCountView() {
        return <DocumentLinksButton hideCount={this.hideLinkCount} View={this} scaling={this.scaleToScreenSpace} OnHover={true} Bottom={this.topMost} ShowCount={true} />;
    }
    @computed get docViewPath(): DocumentView[] {
        return this._props.docViewPath ? [...this._props.docViewPath(), this] : [this];
    }
    @computed get layoutDoc() {
        return Doc.Layout(this.Document, this._props.LayoutTemplate?.());
    }
    @computed get nativeWidth() {
        return this._props.LayoutTemplateString?.includes(KeyValueBox.name) ? 0 : returnVal(this._props.NativeWidth?.(), Doc.NativeWidth(this.layoutDoc, this._props.TemplateDataDocument, !this.layout_fitWidth));
    }
    @computed get nativeHeight() {
        return this._props.LayoutTemplateString?.includes(KeyValueBox.name) ? 0 : returnVal(this._props.NativeHeight?.(), Doc.NativeHeight(this.layoutDoc, this._props.TemplateDataDocument, !this.layout_fitWidth));
    }
    @computed get shouldNotScale() {
        return (this.layout_fitWidth && !this.nativeWidth) || this._props.LayoutTemplateString?.includes(KeyValueBox.name) || [CollectionViewType.Docking].includes(this.Document._type_collection as any);
    }
    @computed get effectiveNativeWidth() {
        return this.shouldNotScale ? 0 : this.nativeWidth || NumCast(this.layoutDoc.width);
    }
    @computed get effectiveNativeHeight() {
        return this.shouldNotScale ? 0 : this.nativeHeight || NumCast(this.layoutDoc.height);
    }
    @computed get nativeScaling() {
        if (this.shouldNotScale) return 1;
        const minTextScale = this.Document.type === DocumentType.RTF ? 0.1 : 0;
        if (this.layout_fitWidth || this._props.PanelHeight() / (this.effectiveNativeHeight || 1) > this._props.PanelWidth() / (this.effectiveNativeWidth || 1)) {
            return Math.max(minTextScale, this._props.PanelWidth() / (this.effectiveNativeWidth || 1)); // width-limited or layout_fitWidth
        }
        return Math.max(minTextScale, this._props.PanelHeight() / (this.effectiveNativeHeight || 1)); // height-limited or unscaled
    }
    @computed get panelWidth() {
        return this.effectiveNativeWidth ? this.effectiveNativeWidth * this.nativeScaling : this._props.PanelWidth();
    }
    @computed get panelHeight() {
        if (this.effectiveNativeHeight && (!this.layout_fitWidth || !this.layoutDoc.layout_reflowVertical)) {
            return Math.min(this._props.PanelHeight(), this.effectiveNativeHeight * this.nativeScaling);
        }
        return this._props.PanelHeight();
    }
    @computed get Xshift() {
        return this.effectiveNativeWidth ? Math.max(0, (this._props.PanelWidth() - this.effectiveNativeWidth * this.nativeScaling) / 2) : 0;
    }
    @computed get Yshift() {
        return this.effectiveNativeWidth &&
            this.effectiveNativeHeight &&
            Math.abs(this.Xshift) < 0.001 &&
            (!this.layoutDoc.layout_reflowVertical || (!this.layout_fitWidth && this.effectiveNativeHeight * this.nativeScaling <= this._props.PanelHeight()))
            ? Math.max(0, (this._props.PanelHeight() - this.effectiveNativeHeight * this.nativeScaling) / 2)
            : 0;
    }
    @computed get centeringX() {
        return this._props.dontCenter?.includes('x') ? 0 : this.Xshift;
    }
    @computed get centeringY() {
        return this._props.dontCenter?.includes('y') ? 0 : this.Yshift;
    }

    @computed get CollectionFreeFormView() {
        return this.CollectionFreeFormDocumentView?.CollectionFreeFormView;
    }
    @computed get CollectionFreeFormDocumentView() {
        return this._props.CollectionFreeFormDocumentView?.();
    }

    public toggleNativeDimensions = () => this.docView && this.Document.type !== DocumentType.INK && Doc.toggleNativeDimensions(this.layoutDoc, this.docView.NativeDimScaling, this._props.PanelWidth(), this._props.PanelHeight());
    public getBounds = () => {
        if (!this.docView?.ContentDiv || this._props.treeViewDoc || Doc.AreProtosEqual(this._props.Document, Doc.UserDoc())) {
            return undefined;
        }
        if (this.docView._componentView?.screenBounds?.()) {
            return this.docView._componentView.screenBounds();
        }
        const xf = this.docView._props.ScreenToLocalTransform().scale(this.nativeScaling).inverse();
        const [[left, top], [right, bottom]] = [xf.transformPoint(0, 0), xf.transformPoint(this.panelWidth, this.panelHeight)];

        if (this.docView._props.LayoutTemplateString?.includes(LinkAnchorBox.name)) {
            const docuBox = this.docView.ContentDiv.getElementsByClassName('linkAnchorBox-cont');
            if (docuBox.length) return { ...docuBox[0].getBoundingClientRect(), center: undefined };
        }
        return { left, top, right, bottom };
    };

    public iconify(finished?: () => void, animateTime?: number) {
        this.ComponentView?.updateIcon?.();
        const animTime = this.docView?._animateScaleTime;
        runInAction(() => this.docView && animateTime !== undefined && (this.docView._animateScaleTime = animateTime));
        const finalFinished = action(() => {
            finished?.();
            this.docView && (this.docView._animateScaleTime = animTime);
        });
        const layout_fieldKey = Cast(this.Document.layout_fieldKey, 'string', null);
        if (layout_fieldKey !== 'layout_icon') {
            this.switchViews(true, 'icon', finalFinished);
            if (layout_fieldKey && layout_fieldKey !== 'layout' && layout_fieldKey !== 'layout_icon') this.Document.deiconifyLayout = layout_fieldKey.replace('layout_', '');
        } else {
            const deiconifyLayout = Cast(this.Document.deiconifyLayout, 'string', null);
            this.switchViews(deiconifyLayout ? true : false, deiconifyLayout, finalFinished);
            this.Document.deiconifyLayout = undefined;
            this._props.bringToFront(this.Document);
        }
    }
    @undoBatch
    setCustomView = (custom: boolean, layout: string): void => {
        Doc.setNativeView(this._props.Document);
        custom && DocUtils.makeCustomViewClicked(this._props.Document, Docs.Create.StackingDocument, layout, undefined);
    };

    switchViews = (custom: boolean, view: string, finished?: () => void, useExistingLayout = false) => {
        runInAction(() => this.docView && (this.docView._animateScalingTo = 0.1)); // shrink doc
        setTimeout(
            action(() => {
                if (useExistingLayout && custom && this.Document['layout_' + view]) {
                    this.Document.layout_fieldKey = 'layout_' + view;
                } else {
                    this.setCustomView(custom, view);
                }
                this.docView && (this.docView._animateScalingTo = 1); // expand it
                setTimeout(
                    action(() => {
                        this.docView && (this.docView._animateScalingTo = 0);
                        finished?.();
                    }),
                    this.docView ? Math.max(0, this.docView.animateScaleTime - 10) : 0
                );
            }),
            this.docView ? Math.max(0, this.docView?.animateScaleTime - 10) : 0
        );
    };

    layout_fitWidthFunc = (doc: Doc) => BoolCast(this.layout_fitWidth);
    scaleToScreenSpace = () => (1 / (this._props.NativeDimScaling?.() || 1)) * this.screenToLocalTransform().Scale;
    docViewPathFunc = () => this.docViewPath;
    isSelected = () => this.IsSelected;
    select = (extendSelection: boolean, focusSelection?: boolean) => {
        if (this.IsSelected && SelectionManager.Views.length > 1) SelectionManager.DeselectView(this);
        else {
            SelectionManager.SelectView(this, extendSelection);
            if (focusSelection) {
                DocumentManager.Instance.showDocument(this.Document, {
                    willZoomCentered: true,
                    zoomScale: 0.9,
                    zoomTime: 500,
                });
            }
        }
    };
    ShouldNotScale = () => this.shouldNotScale;
    NativeWidth = () => this.effectiveNativeWidth;
    NativeHeight = () => this.effectiveNativeHeight;
    PanelWidth = () => this.panelWidth;
    PanelHeight = () => this.panelHeight;
    NativeDimScaling = () => this.nativeScaling;
    selfView = () => this;
    screenToLocalTransform = () =>
        this._props
            .ScreenToLocalTransform()
            .translate(-this.centeringX, -this.centeringY)
            .scale(1 / this.nativeScaling);

    componentDidMount() {
        runInAction(() => this.Document[DocViews].add(this));
        this._disposers.updateContentsScript = reaction(() => ScriptCast(this.Document.updateContentsScript)?.script?.run({ this: this.Document }).result, emptyFunction);
        this._disposers.height = reaction(
            // increase max auto height if document has been resized to be greater than current max
            () => NumCast(this.layoutDoc._height),
            action(height => {
                const docMax = NumCast(this.layoutDoc.layout_maxAutoHeight);
                if (docMax && docMax < height) this.layoutDoc.layout_maxAutoHeight = height;
            })
        );
        !BoolCast(this._props.Document.dontRegisterView, this._props.dontRegisterView) && DocumentManager.Instance.AddView(this);
    }

    componentWillUnmount() {
        this.Document[DocViews].delete(this);
        Object.values(this._disposers).forEach(disposer => disposer?.());
        !BoolCast(this._props.Document.dontRegisterView, this._props.dontRegisterView) && DocumentManager.Instance.RemoveView(this);
    }
    // want the htmloverlay to be able to fade in but we also want it to be display 'none' until it is needed.
    // unfortunately, CSS can't transition animate any properties for something that is display 'none'.
    // so we need to first activate the div, then, after a render timeout, start the opacity transition.
    @observable enableHtmlOverlayTransitions: boolean = false;
    @computed get htmlOverlay() {
        const effect = StrCast(this.htmlOverlayEffect?.presentation_effect, StrCast(this.htmlOverlayEffect?.followLinkAnimEffect));
        return (
            <div
                className="documentView-htmlOverlay"
                ref={r => {
                    const val = r?.style.display !== 'none'; // if the outer overlay has been displayed, trigger the innner div to start it's opacity fade in transition
                    if (r && val !== this.enableHtmlOverlayTransitions) {
                        setTimeout(action(() => (this.enableHtmlOverlayTransitions = val)));
                    }
                }}
                style={{ display: !this.textHtmlOverlay ? 'none' : undefined }}>
                <div className="documentView-htmlOverlayInner" style={{ transition: `all 500ms`, opacity: this.enableHtmlOverlayTransitions ? 0.9 : 0 }}>
                    {DocumentViewInternal.AnimationEffect(
                        <div className="webBox-textHighlight">
                            <ObserverJsxParser autoCloseVoidElements={true} key={42} onError={(e: any) => console.log('PARSE error', e)} renderInWrapper={false} jsx={StrCast(this.textHtmlOverlay)} />
                        </div>,
                        { ...(this.htmlOverlayEffect ?? {}), presentation_effect: effect ?? PresEffect.Zoom } as any as Doc,
                        this.Document
                    )}
                </div>
            </div>
        );
    }

    @computed get infoUI() {
        return this.ComponentView?.infoUI?.();
    }

    render() {
        TraceMobx();
        const xshift = Math.abs(this.Xshift) <= 0.001 ? this._props.PanelWidth() : undefined;
        const yshift = Math.abs(this.Yshift) <= 0.001 ? this._props.PanelHeight() : undefined;

        return (
            <div className="contentFittingDocumentView" onPointerEnter={action(() => (this._isHovering = true))} onPointerLeave={action(() => (this._isHovering = false))}>
                {!this._props.Document || !this._props.PanelWidth() ? null : (
                    <div
                        className="contentFittingDocumentView-previewDoc"
                        ref={this.ContentRef}
                        style={{
                            transition: 'inherit', // this._props.dataTransition,
                            transform: `translate(${this.centeringX}px, ${this.centeringY}px)`,
                            width: xshift ?? `${this._props.PanelWidth() - this.Xshift * 2}px`,
                            height: this._props.forceAutoHeight ? undefined : yshift ?? (this.layout_fitWidth ? `${this.panelHeight}px` : `${(this.effectiveNativeHeight / this.effectiveNativeWidth) * this._props.PanelWidth()}px`),
                        }}>
                        <DocumentViewInternal
                            {...this._props}
                            DocumentView={this.selfView}
                            viewPath={this.docViewPathFunc}
                            PanelWidth={this.PanelWidth}
                            PanelHeight={this.PanelHeight}
                            NativeWidth={this.NativeWidth}
                            NativeHeight={this.NativeHeight}
                            NativeDimScaling={this.NativeDimScaling}
                            isSelected={this.isSelected}
                            select={this.select}
                            layout_fitWidth={this.layout_fitWidthFunc}
                            ScreenToLocalTransform={this.screenToLocalTransform}
                            focus={this._props.focus || emptyFunction}
                            ref={action((r: DocumentViewInternal | null) => r && (this.docView = r))}
                        />
                        {this.htmlOverlay}
                        {this.infoUI}
                    </div>
                )}

                {this.linkCountView}
            </div>
        );
    }
}

ScriptingGlobals.add(function deiconifyView(documentView: DocumentView) {
    documentView.iconify();
    documentView.select(false);
});

ScriptingGlobals.add(function deiconifyViewToLightbox(documentView: DocumentView) {
    LightboxView.Instance.AddDocTab(documentView.Document, OpenWhere.lightbox, 'layout'); //, 0);
});

ScriptingGlobals.add(function toggleDetail(dv: DocumentView, detailLayoutKeySuffix: string) {
    if (dv.Document.layout_fieldKey === 'layout_' + detailLayoutKeySuffix) dv.switchViews(false, 'layout');
    else dv.switchViews(true, detailLayoutKeySuffix, undefined, true);
});

ScriptingGlobals.add(function updateLinkCollection(linkCollection: Doc, linkSource: Doc) {
    const collectedLinks = DocListCast(Doc.GetProto(linkCollection).data);
    let wid = NumCast(linkSource._width);
    let embedding: Doc | undefined;
    const links = LinkManager.Links(linkSource);
    links.forEach(link => {
        const other = LinkManager.getOppositeAnchor(link, linkSource);
        const otherdoc = DocCast(other?.annotationOn ?? other);
        if (otherdoc && !collectedLinks?.some(d => Doc.AreProtosEqual(d, otherdoc))) {
            embedding = Doc.MakeEmbedding(otherdoc);
            embedding.x = wid;
            embedding.y = 0;
            embedding._lockedPosition = false;
            wid += NumCast(otherdoc._width);
            Doc.AddDocToList(Doc.GetProto(linkCollection), 'data', embedding);
        }
    });
    embedding && DocServer.UPDATE_SERVER_CACHE(); // if a new embedding was made, update the client's server cache so that it will not come back as a promise
    return links;
});
