/* eslint-disable @typescript-eslint/no-unused-vars */
import { Colors } from '@dash/components';
import { runInAction } from 'mobx';
import { Doc, Opt, StrListCast } from '../../../fields/Doc';
import { InkEraserTool, InkInkTool, InkProperty, InkTool } from '../../../fields/InkField';
import { BoolCast, Cast, NumCast, StrCast } from '../../../fields/Types';
import { WebField } from '../../../fields/URLField';
import { Gestures } from '../../../pen-gestures/GestureTypes';
import { DocumentType } from '../../documents/DocumentTypes';
import { LinkManager } from '../../util/LinkManager';
import { ScriptingGlobals } from '../../util/ScriptingGlobals';
import { SnappingManager } from '../../util/SnappingManager';
import { UndoManager, undoable } from '../../util/UndoManager';
import { GestureOverlay } from '../GestureOverlay';
import { InkTranscription } from '../InkTranscription';
import { PropertiesView } from '../PropertiesView';
import { docSortings } from '../collections/CollectionSubView';
import { CollectionFreeFormView } from '../collections/collectionFreeForm';
import { CollectionFreeFormDocumentView } from '../nodes/CollectionFreeFormDocumentView';
import {
    ActiveEraserWidth,
    ActiveHideTextLabels,
    ActiveInkColor,
    ActiveInkFillColor,
    ActiveInkWidth,
    ActiveIsInkMask,
    DocumentView,
    SetActiveInkColor,
    SetActiveInkFillColor,
    SetActiveInkWidth,
    SetActiveIsInkMask,
    SetEraserWidth,
    SetactiveHideTextLabels,
} from '../nodes/DocumentView';
import { ImageBox } from '../nodes/ImageBox';
import { OpenWhere } from '../nodes/OpenWhere';
import { VideoBox } from '../nodes/VideoBox';
import { WebBox } from '../nodes/WebBox';
import { RichTextMenu } from '../nodes/formattedText/RichTextMenu';
import { GPTPopup, GPTPopupMode } from '../pdf/GPTPopup/GPTPopup';
import { DocData } from '../../../fields/DocSymbols';

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function IsNoneSelected() {
    return DocumentView.Selected().length <= 0;
}, 'are no document selected');

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setView(view: string, shiftKey: boolean, checkResult?: boolean) {
    if (checkResult) return DocumentView.SelectedDocs();
    const selected = DocumentView.Selected().lastElement();
    if (selected) {
        if (shiftKey) {
            const newCol = Doc.MakeEmbedding(selected.Document);
            newCol._type_collection = view;
            selected._props.addDocTab?.(newCol, OpenWhere.addRight);
        } else {
            selected.Document._type_collection = view;
        }
    } else {
        console.log('[FontIconBox.tsx] changeView failed');
    }
    return undefined;
});

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setBorderColor(color?: string, checkResult?: boolean) {
    const selectedViews = DocumentView.Selected();
    const defaultBorder = () => StrCast(Doc.UserDoc().borderColor, 'transparent');
    const setDefaultBorder = (c: string) => { Doc.UserDoc().borderColor = c; }; // prettier-ignore
    const fieldKey = 'borderColor';
    if (selectedViews.length) {
        if (checkResult) {
            const selView = selectedViews.lastElement();
            const layoutFrameNumber = Cast(selView.containerViewPath?.().lastElement()?.Document?._currentFrame, 'number'); // frame number that container is at which determines layout frame values
            const contentFrameNumber = Cast(selView.Document?._currentFrame, 'number', layoutFrameNumber ?? null); // frame number that content is at which determines what content is displayed
            return (contentFrameNumber !== undefined && CollectionFreeFormDocumentView.getStringValues(selView?.Document, contentFrameNumber)[fieldKey]) || defaultBorder();
        }
        setDefaultBorder(color ?? 'transparent');
        selectedViews.forEach(dv => {
            const layoutFrameNumber = Cast(dv.containerViewPath?.().lastElement()?.Document?._currentFrame, 'number'); // frame number that container is at which determines layout frame values
            const contentFrameNumber = Cast(dv.Document?._currentFrame, 'number', layoutFrameNumber ?? null); // frame number that content is at which determines what content is displayed
            if (contentFrameNumber !== undefined) {
                const obj: { [key: string]: Opt<string> } = {};
                obj[fieldKey] = color;
                CollectionFreeFormDocumentView.setStringValues(contentFrameNumber, dv.Document, obj);
            } else {
                const dataKey = Doc.LayoutDataKey(dv.Document);
                const alternate = (dv.layoutDoc[dataKey + '_usePath'] ? '_' + dv.layoutDoc[dataKey + '_usePath'] : '').replace(':hover', '');
                dv.layoutDoc[fieldKey + alternate] = undefined;
                dv.dataDoc[fieldKey + alternate] = color;
            }
        });
    } else {
        const selected = DocumentView.SelectedDocs().length ? DocumentView.SelectedDocs() : LinkManager.Instance.currentLink ? [LinkManager.Instance.currentLink] : [];
        if (checkResult) {
            return (selected.lastElement() ?? Doc.UserDoc()).borderColor ?? defaultBorder();
        }
        if (!selected.length) setDefaultBorder(color ?? 'transparent');
        else selected.forEach(doc => (doc.$borderColor = color));
    }
    return '';
});

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setBackgroundColor(color?: string, checkResult?: boolean) {
    const selectedViews = DocumentView.Selected();
    const selectedDoc = selectedViews.lastElement()?.Document;
    const defaultFill = selectedDoc?._layout_isSvg ? () => StrCast(selectedDoc.$fillColor) : !Doc.ActiveTool || Doc.ActiveTool === InkTool.None ? () => StrCast(Doc.UserDoc().textBackgroundColor, 'transparent') : () => ActiveInkFillColor();
    const setDefaultFill = !Doc.ActiveTool || Doc.ActiveTool === InkTool.None  ? (c: string) => { Doc.UserDoc().textBackgroundColor = c; }: SetActiveInkFillColor; // prettier-ignore
    if (Doc.ActiveTool !== InkTool.None && !selectedViews.lastElement()?.Document._layout_isSvg) {
        if (checkResult) return defaultFill();
        setDefaultFill(color ?? 'transparent');
    } else if (selectedViews.length) {
        if (checkResult) {
            const selView = selectedViews.lastElement();
            const fieldKey = selView.Document._layout_isSvg ? 'fillColor' : 'backgroundColor';
            const layoutFrameNumber = Cast(selView.containerViewPath?.().lastElement()?.Document?._currentFrame, 'number'); // frame number that container is at which determines layout frame values
            const contentFrameNumber = Cast(selView.Document?._currentFrame, 'number', layoutFrameNumber ?? null); // frame number that content is at which determines what content is displayed
            return (contentFrameNumber !== undefined ? CollectionFreeFormDocumentView.getStringValues(selView?.Document, contentFrameNumber)[fieldKey] : selView.backgroundColor()) || defaultFill();
        }
        !selectedViews.length && setDefaultFill(color ?? 'transparent');
        selectedViews.forEach(dv => {
            const fieldKey = dv.Document._layout_isSvg ? 'fillColor' : 'backgroundColor';
            const layoutFrameNumber = Cast(dv.containerViewPath?.().lastElement()?.Document?._currentFrame, 'number'); // frame number that container is at which determines layout frame values
            const contentFrameNumber = Cast(dv.Document?._currentFrame, 'number', layoutFrameNumber ?? null); // frame number that content is at which determines what content is displayed
            if (contentFrameNumber !== undefined) {
                const obj: { [key: string]: Opt<string> } = {};
                obj[fieldKey] = color;
                CollectionFreeFormDocumentView.setStringValues(contentFrameNumber, dv.Document, obj);
            } else {
                const colorDoc = dv.isTemplateForField ? dv.layoutDoc : dv.dataDoc; // assigning to a template's compoment field should not assign to the data doc
                const dataKey = Doc.LayoutDataKey(colorDoc);
                const alternate = (dv.layoutDoc[dataKey + '_usePath'] ? '_' + dv.layoutDoc[dataKey + '_usePath'] : '').replace(':hover', '');
                colorDoc[fieldKey + alternate] = color;
            }
        });
    } else {
        const selected = DocumentView.SelectedDocs().length ? DocumentView.SelectedDocs() : LinkManager.Instance.currentLink ? [LinkManager.Instance.currentLink] : [];
        if (checkResult) {
            return selected.lastElement()?._backgroundColor ?? defaultFill();
        }
        if (!selected.length) setDefaultFill(color ?? 'transparent');
        else selected.forEach(doc => (doc[doc._layout_isSvg ? '$fillColor' : '$backgroundColor'] = color));
    }
    return '';
});

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setDefaultTemplate(checkResult?: boolean) {
    return DocumentView.setDefaultTemplate(checkResult);
});
// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setDefaultImageTemplate(checkResult?: boolean) {
    return DocumentView.setDefaultImageTemplate(checkResult);
});
// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setHeaderColor(color?: string, checkResult?: boolean) {
    if (checkResult) {
        return DocumentView.Selected().length ? StrCast(DocumentView.SelectedDocs().lastElement().layout_headingColor) : Doc.SharingDoc()?.headingColor;
    }
    if (DocumentView.Selected().length) {
        DocumentView.SelectedDocs().forEach(doc => {
            doc.$layout_headingColor = color === 'transparent' ? undefined : color;
            doc.layout_showTitle = color === 'transparent' ? undefined : StrCast(doc.layout_showTitle, 'title');
        });
    } else {
        const sharing = Doc.SharingDoc();
        if (sharing) {
            sharing.headingColor = undefined;
            Doc.GetProto(sharing).headingColor = color === 'transparent' ? undefined : color;
        }
        Doc.UserDoc().layout_showTitle = color === 'transparent' ? undefined : StrCast(Doc.UserDoc().layout_showTitle, 'title');
    }
    return undefined;
});

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function toggleOverlay(checkResult?: boolean) {
    const selected = DocumentView.Selected().length ? DocumentView.Selected()[0] : undefined;
    if (checkResult) {
        if (NumCast(selected?.Document.z) >= 1) return true;
        return false;
    }
    selected ? CollectionFreeFormDocumentView.from(selected)?.float() : console.log('[FontIconBox.tsx] toggleOverlay failed');
    return undefined;
});

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function showFreeform(
    attr: 'flashcards' | 'hcenter' | 'vcenter' | 'grid' | 'snaplines' | 'clusters' | 'viewAll' | 'fitOnce' | 'time' | 'docType' | 'color' | 'chat' | 'reverse' | 'toggle-chat' | 'toggle-tags' | 'tag',
    checkResult?: boolean,
    persist?: boolean
) {
    const selected = DocumentView.SelectedDocs().lastElement();

    function isAttrFiltered(attribute: string) {
        return StrListCast(selected._childFilters).some(filter => filter.includes(attribute));
    }

    // prettier-ignore
    const map: Map<'flashcards' | 'hcenter' | 'vcenter' | 'grid' | 'snaplines' | 'clusters' | 'viewAll' | 'fitOnce' | 'time' | 'docType' | 'color' | 'chat' | 'reverse'| 'toggle-chat' | 'toggle-tags' | 'tag', 
    { 
        waitForRender?: boolean; 
        checkResult: (doc: Doc) => boolean; 
        setDoc: (doc: Doc, dv: DocumentView) => void; 
    }> = new Map([
        ['grid', {
            checkResult: (doc: Doc) => BoolCast(doc?._freeform_backgroundGrid, false),
            setDoc: (doc: Doc) => { doc._freeform_backgroundGrid = !doc._freeform_backgroundGrid; },
        }],
        ['snaplines', {
            checkResult: (doc: Doc) => BoolCast(doc?._freeform_snapLines, false),
            setDoc: (doc: Doc) => { doc._freeform_snapLines = !doc._freeform_snapLines; },
        }],
        ['viewAll', {
            checkResult: (doc: Doc) => BoolCast(doc?._freeform_fitContentsToBox, false),
            setDoc: (doc: Doc, dv: DocumentView) => {
                if (persist) doc._freeform_fitContentsToBox = !doc._freeform_fitContentsToBox;
                else if (doc._freeform_fitContentsToBox) doc._freeform_fitContentsToBox = undefined;
                else (dv.ComponentView as CollectionFreeFormView)?.fitContentOnce();
            },
        }],
        ['vcenter', {
            checkResult: (doc:Doc) => !StrCast(doc?._layout_dontCenter).includes('y'),
            setDoc: (doc:Doc) => { doc._layout_dontCenter = StrCast(doc.layout_dontCenter).includes('y') ? StrCast(doc.layout_dontCenter).replace(/y/,"") : StrCast(doc.layout_dontCenter) + 'y'; },
        }],
        ['hcenter', {
            checkResult: (doc:Doc) => !StrCast(doc?._layout_dontCenter).includes('x'),
            setDoc: (doc:Doc) => { doc._layout_dontCenter = StrCast(doc.layout_dontCenter).includes('x') ? StrCast(doc.layout_dontCenter).replace(/x/,"") : 'x'+ StrCast(doc.layout_dontCenter); },
        }],
        ['clusters', {
            waitForRender: true, // flags that undo batch should terminate after a re-render giving the script the chance to fire
            checkResult: (doc: Doc) => BoolCast(doc?._freeform_useClusters, false),
            setDoc: (doc: Doc) => { doc._freeform_useClusters = !doc._freeform_useClusters; },
        }],
        ['time', {
            checkResult: (doc: Doc) => StrCast(doc?.[Doc.LayoutDataKey(doc)+"_sort"]) === "time",
            setDoc: (doc: Doc, dv: DocumentView) => { doc[Doc.LayoutDataKey(doc)+"_sort"] === "time" ? doc[Doc.LayoutDataKey(doc)+"_sort"] = '' : doc[Doc.LayoutDataKey(doc)+"_sort"] = docSortings.Time}, // prettier-ignore
        }],
        ['docType', {
            checkResult: (doc: Doc) => StrCast(doc?.[Doc.LayoutDataKey(doc)+"_sort"]) === "type",
            setDoc: (doc: Doc, dv: DocumentView) => { doc[Doc.LayoutDataKey(doc)+"_sort"] === "type" ? doc[Doc.LayoutDataKey(doc)+"_sort"] = '' : doc[Doc.LayoutDataKey(doc)+"_sort"] = docSortings.Type}, // prettier-ignore
        }],
        ['color', {
            checkResult: (doc: Doc) => StrCast(doc?.[Doc.LayoutDataKey(doc)+"_sort"]) === "color",
            setDoc: (doc: Doc, dv: DocumentView) => { doc?.[Doc.LayoutDataKey(doc)+"_sort"] === "color" ? doc[Doc.LayoutDataKey(doc)+"_sort"] = '' : doc[Doc.LayoutDataKey(doc)+"_sort"] = docSortings.Color}, // prettier-ignore
        }],
        ['tag', {
            checkResult: (doc: Doc) => StrCast(doc?.[Doc.LayoutDataKey(doc)+"_sort"]) === "tag",
            setDoc: (doc: Doc, dv: DocumentView) => { doc[Doc.LayoutDataKey(doc)+"_sort"] === "tag" ? doc[Doc.LayoutDataKey(doc)+"_sort"] = '' : doc[Doc.LayoutDataKey(doc)+"_sort"] = docSortings.Tag}, // prettier-ignore
        }],
        ['reverse', {
            checkResult: (doc: Doc) => BoolCast(doc?.[Doc.LayoutDataKey(doc)+"_sort_reverse"]),
            setDoc: (doc: Doc, dv: DocumentView) => { doc[Doc.LayoutDataKey(doc)+"_sort_reverse"] = !doc[Doc.LayoutDataKey(doc)+"_sort_reverse"]; },
        }],
        ['toggle-chat', {
            checkResult: (doc: Doc) => SnappingManager.ChatVisible,
            setDoc: (doc: Doc, dv: DocumentView) => {
                if (SnappingManager.ChatVisible){
                    doc[Doc.LayoutDataKey(doc)+"_sort"] = '';
                    SnappingManager.SetChatVisible(false);
                } else {
                    SnappingManager.SetChatVisible(true);
                    GPTPopup.Instance.setMode(GPTPopupMode.GPT_MENU);
                }
            },
        }],
        ['toggle-tags', {
            checkResult: (doc: Doc) => BoolCast(doc?.showChildTags),
            setDoc: (doc: Doc, dv: DocumentView) => {
                doc.showChildTags = !doc.showChildTags;
            },
        }],
    ]);

    if (checkResult) {
        return map.get(attr)?.checkResult(selected);
    }

    const batch = map.get(attr)?.waitForRender ? UndoManager.StartBatch('set freeform attribute') : { end: () => {} };
    DocumentView.Selected().map(dv => map.get(attr)?.setDoc(dv.layoutDoc, dv));
    setTimeout(() => batch.end(), 100);
    return undefined;
});

/**
 * Applies (or removes) a filter to the selected document for the specified tag
 * NOTE: this also opens the filter panel if the settings button is clicked (probably should be a different function)
 */
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setTagFilter(tag: string, added: boolean, checkResult?: boolean) {
    const selected = DocumentView.SelectedDocs().lastElement();
    const isOptions = tag === '-opts-';

    if (checkResult) {
        return isOptions
            ? false
            : StrListCast(selected._childFilters) // check all filters for one that filters tags:value where value is the tag's name
                  .map(filter => filter.split(Doc.FilterSep))
                  .some(([key, val]) => key === 'tags' && val === tag);
    }

    if (!isOptions) {
        added ? Doc.setDocFilter(selected, 'tags', tag, 'check') : Doc.setDocFilter(selected, 'tags', tag, 'remove');
    } else {
        SnappingManager.PropertiesWidth < 5 && SnappingManager.SetPropertiesWidth(0);
        SnappingManager.SetPropertiesWidth(SnappingManager.PropertiesWidth < 15 ? 250 : 0);
        PropertiesView.Instance?.CloseAll();
        runInAction(() => (PropertiesView.Instance.openFilters = SnappingManager.PropertiesWidth > 5));
    }

    return undefined;
}, '');

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setFontAttr(attr: 'font' | 'fontColor' | 'highlight' | 'fontSize', value: string | number, checkResult?: boolean) {
    const editorView = RichTextMenu.Instance?.TextView?.EditorView;
    // prettier-ignore
    const map: Map<'font'|'fontColor'|'highlight'|'fontSize', { checkResult: () => string | undefined; setDoc: () => void;}> = new Map([
        ['font', {
            checkResult: () => RichTextMenu.Instance?.fontFamily,
            setDoc: () => value && RichTextMenu.Instance?.setFontField(value.toString(), 'fontFamily'),
        }],
        ['highlight', {
            checkResult: () => RichTextMenu.Instance?.fontHighlight,
            setDoc: () => value  && RichTextMenu.Instance?.setFontField(value.toString(), 'fontHighlight'),
        }],
        ['fontColor', {
            checkResult: () => RichTextMenu.Instance?.fontColor,
            setDoc: () => value && RichTextMenu.Instance?.setFontField(value.toString(), 'fontColor'),
        }],
        ['fontSize', {
            checkResult: () => RichTextMenu.Instance?.fontSize.replace('px', ''),
            setDoc: () => {
                let fsize = value;
                if (typeof fsize === 'number') fsize = fsize.toString();
                if (fsize && Number(fsize).toString() === fsize) fsize += 'px';
                RichTextMenu.Instance?.setFontField(fsize, 'fontSize');
            },
        }],
    ]);

    if (checkResult) {
        // console.log(map.get(attr)?.checkResult() + "font check result")
        return map.get(attr)?.checkResult();
    }
    map.get(attr)?.setDoc?.();
    return undefined;
});

type attrname = 'noAutoLink' | 'dictation' | 'fitBox' | 'bold' | 'italic' | 'elide' | 'underline' | 'left' | 'center' | 'right' | 'vcent' | 'bullet' | 'decimal';
type attrfuncs = [attrname, { checkResult: () => boolean; toggle?: () => unknown }];

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function toggleCharStyle(charStyle: attrname, checkResult?: boolean) {
    const textView = RichTextMenu.Instance?.TextView;
    const editorView = textView?.EditorView;
    // prettier-ignore
    const alignments:attrfuncs[] = (['left','right','center','vcent'] as ("left"|"center"|"right"|"vcent")[]).map((where) =>
        [ where, {      checkResult: () => (where === 'vcent' ?  RichTextMenu.Instance?.textVcenter ?? false:
                                                             (RichTextMenu.Instance?.textAlign === where)),
                        toggle: () => { (where === 'vcent' ? RichTextMenu.Instance?.vcenterToggle():
                                                            RichTextMenu.Instance?.align(editorView, editorView?.dispatch, where)); }
        }]); // prettier-ignore
    // prettier-ignore
    const listings:attrfuncs[] = (['bullet','decimal'] as attrname[]).map(list =>
        [ list, {       checkResult: () => (editorView ? RichTextMenu.Instance?.listStyle === list:false),
                        toggle: () => editorView?.state && RichTextMenu.Instance?.changeListType(list) }]);
    // prettier-ignore
    const attrs:attrfuncs[] = [
        ['dictation', { checkResult: () => !!textView?.recordingDictation,
                        toggle: () => textView && runInAction(() => { textView.recordingDictation = !textView.recordingDictation;} ) }],
        ['fitBox',    { checkResult: () => RichTextMenu.Instance?.fitBox ?? false,
                        toggle: () => RichTextMenu.Instance?.toggleFitBox()}],
        ['elide',      { checkResult: () => false,
                        toggle: () => editorView ? RichTextMenu.Instance?.elideSelection(): 0}],
        ['noAutoLink',{ checkResult: () => ((editorView && RichTextMenu.Instance?.noAutoLink) ?? false),
                        toggle: () => editorView && RichTextMenu.Instance?.toggleNoAutoLinkAnchor()}],
        ['bold',      { checkResult: () => (editorView ? RichTextMenu.Instance?.bold??false : (Doc.UserDoc().fontWeight === 'bold')),
                        toggle: editorView ? RichTextMenu.Instance?.toggleBold : () => { Doc.UserDoc().fontWeight = Doc.UserDoc().fontWeight === 'bold' ? undefined : 'bold'; }}],
        ['italic',    { checkResult: () => (editorView ? RichTextMenu.Instance?.italic ?? false : (Doc.UserDoc().fontStyle === 'italic')),
                        toggle: editorView ? RichTextMenu.Instance?.toggleItalic : () => { Doc.UserDoc().fontStyle = Doc.UserDoc().fontStyle === 'italic' ? undefined : 'italic'; }}],
        ['underline', { checkResult: () => (editorView ? RichTextMenu.Instance?.underline ?? false: (Doc.UserDoc().fontDecoration === 'underline')),
                        toggle: editorView ? RichTextMenu.Instance?.toggleUnderline : () => { Doc.UserDoc().fontDecoration = Doc.UserDoc().fontDecoration === 'underline' ? undefined : 'underline'; } }]]

    const map = new Map(attrs.concat(alignments).concat(listings));
    if (checkResult) {
        return map.get(charStyle)?.checkResult();
    }
    undoable(() => map.get(charStyle)?.toggle?.(), 'toggle ' + charStyle)();
    return undefined;
});

function setActiveTool(tool: InkTool | InkEraserTool | InkInkTool | Gestures, keepPrim: boolean, checkResult?: boolean) {
    InkTranscription.Instance?.createInkGroup();
    if (checkResult) {
        return Doc.ActiveTool === tool || Doc.ActiveEraser === tool || Doc.ActiveInk === tool || SnappingManager.InkShape === tool
            ? true //SnappingManager.KeepGestureMode || ![Gestures.Circle, Gestures.Line, Gestures.Rectangle].includes(tool as Gestures)
            : false;
    }
    runInAction(() => {
        const eraserTool = tool === InkTool.Eraser ? Doc.ActiveEraser : [InkEraserTool.Stroke, InkEraserTool.Radius, InkEraserTool.Segment].includes(tool as InkEraserTool) ? (tool as InkEraserTool) : undefined;
        const inkTool = tool === InkTool.Ink ? Doc.ActiveInk : [InkInkTool.Pen, InkInkTool.Write, InkInkTool.Math, InkInkTool.Highlight].includes(tool as InkInkTool) ? (tool as InkInkTool) : undefined;
        if (GestureOverlay.Instance) {
            SnappingManager.SetKeepGestureMode(keepPrim);
        }
        if (Object.values(Gestures).includes(tool as Gestures)) {
            if (SnappingManager.InkShape === tool && !keepPrim) {
                Doc.ActiveTool = InkTool.None;
                SnappingManager.SetInkShape(undefined);
            } else {
                Doc.ActiveTool = InkTool.Ink;
                SnappingManager.SetInkShape(tool as Gestures);
            }
        } else if (eraserTool) {
            if (Doc.ActiveTool === InkTool.Eraser && Doc.ActiveTool === tool) {
                Doc.ActiveTool = InkTool.None;
            } else {
                Doc.ActiveEraser = eraserTool;
                Doc.ActiveTool = InkTool.Eraser;
                SnappingManager.SetInkShape(undefined);
            }
        } else if (inkTool) {
            if (Doc.ActiveTool === InkTool.Ink && Doc.ActiveTool === tool) {
                Doc.ActiveTool = InkTool.None;
            } else {
                Doc.ActiveInk = inkTool;
                Doc.ActiveTool = InkTool.Ink;
                SnappingManager.SetInkShape(undefined);
            }
        } else {
            if ((Doc.ActiveTool === tool || !tool) && !keepPrim) Doc.ActiveTool = InkTool.None;
            else Doc.ActiveTool = tool as InkTool;
        }
    });
    return undefined;
}

ScriptingGlobals.add(setActiveTool, 'sets the active ink tool mode');

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function activeEraserTool() {
    return StrCast(Doc.UserDoc().activeEraserTool, InkEraserTool.Stroke);
}, 'returns the current eraser tool');

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setBorderWidth(value: number, checkResult?: boolean) {
    const selected = DocumentView.SelectedDocs().lastElement();
    if (checkResult) return NumCast((selected ?? Doc.UserDoc()).borderWidth);
    if (!selected) Doc.UserDoc().borderWidth = value;
    else
        DocumentView.SelectedDocs().map(doc => {
            doc.borderWidth = value;
        });
    return undefined;
}, 'sets the border width of the selected document');

// toggle: Set overlay status of selected document
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setInkProperty(option: InkProperty, value: string | number, checkResult?: boolean) {
    const selected = DocumentView.SelectedDocs().lastElement();
    // prettier-ignore
    const map: Map<InkProperty, { checkResult: () => number|boolean|string|undefined; setInk: (doc: Doc) => void; setMode: () => void }> = new Map([
        [InkProperty.Mask, {
            checkResult: () => ((selected?._layout_isSvg ? BoolCast(selected.$stroke_isInkMask) : ActiveIsInkMask())),
            setInk: (doc: Doc) => { doc.$stroke_isInkMask = !doc.stroke_isInkMask; },
            setMode: () => SetActiveIsInkMask(value ? true : false)
        }],
        [InkProperty.Labels, {
            checkResult: () => ((selected?._layout_isSvg ? BoolCast(selected.$stroke_showLabel) : !ActiveHideTextLabels())),
            setInk: (doc: Doc) => { doc.$stroke_showLabel = value; },
            setMode: () => SetactiveHideTextLabels(value? false : true),
        }],
        [ InkProperty.StrokeWidth, {
            checkResult: () => (selected?._layout_isSvg ? NumCast(selected.$stroke_width, 1) : ActiveInkWidth()),
            setInk: (doc: Doc) => { doc.$stroke_width = NumCast(value); },
            setMode: () => SetActiveInkWidth(value.toString()),
        }],
        [InkProperty.StrokeColor, {
            checkResult: () => (selected?._layout_isSvg? StrCast(selected.$color) : ActiveInkColor()),
            setInk: (doc: Doc) => { doc.$color = String(value); },
            setMode: () => SetActiveInkColor(StrCast(value))
        }],
        [ InkProperty.EraserWidth, {
            checkResult: () => ActiveEraserWidth() === 0 ? 1 : ActiveEraserWidth(),
            setInk: (doc: Doc) => { },
            setMode: () => SetEraserWidth(+value),
        }]
    ]);

    if (checkResult) {
        return map.get(option)?.checkResult();
    }
    map.get(option)?.setMode();
    DocumentView.SelectedDocs()
        .filter(doc => doc._layout_isSvg)
        .map(doc => map.get(option)?.setInk(doc));
    return undefined;
});

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function toggleRaiseOnDrag(readOnly?: boolean) {
    if (readOnly) {
        return DocumentView.Selected().some(dv => dv.Document.keepZWhenDragged);
    }
    DocumentView.Selected().forEach(dv => {
        dv.Document.keepZWhenDragged = !dv.Document.keepZWhenDragged;
    });
    return undefined;
});

/** WEB
 *      webSetURL
 * */
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function webSetURL(url: string, checkResult?: boolean) {
    const selected = DocumentView.Selected().lastElement();
    if (selected?.Document.type === DocumentType.WEB) {
        if (checkResult) {
            return StrCast(selected.Document.data, Cast(selected.Document.data, WebField, null)?.url?.href);
        }
        selected.ComponentView?.setData?.(url);
    }
    return '';
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function webForward(checkResult?: boolean) {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as WebBox;
    if (checkResult) {
        return selected?.forward(checkResult) ? undefined : 'lightGray';
    }
    selected?.forward();
    return undefined;
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function webBack() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as WebBox;
    selected?.back();
});

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function videoSnapshot() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as VideoBox;
    selected?.Snapshot();
});

// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function imageMaskForeground() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as ImageBox;
    selected?.maskForeground();
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function imageRemoveBackground() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as ImageBox;
    selected?.removeBackground();
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function imageSetPixelSize() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as ImageBox;
    selected?.setNativeSize();
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function imageRotate90() {
    const selected = DocumentView.Selected().lastElement()?.ComponentView as ImageBox;
    selected?.rotate();
});

/** Schema
 *      toggleSchemaPreview
 * */
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function toggleSchemaPreview(checkResult?: boolean) {
    const selected = DocumentView.SelectedDocs().lastElement();
    if (checkResult && selected) {
        const result: boolean = NumCast(selected.schema_previewWidth) > 0;
        if (result) return Colors.MEDIUM_BLUE;
        return 'transparent';
    }
    if (selected) {
        if (NumCast(selected.schema_previewWidth) > 0) {
            selected.schema_previewWidth = 0;
        } else {
            selected.schema_previewWidth = 200;
        }
    }
    return '';
});
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function toggleSingleLineSchema(checkResult?: boolean) {
    const selected = DocumentView.SelectedDocs().lastElement();
    if (checkResult && selected) {
        return NumCast(selected._schema_singleLine) > 0 ? Colors.MEDIUM_BLUE : 'transparent';
    }
    if (selected) {
        selected._schema_singleLine = !selected._schema_singleLine;
    }
    return undefined;
});

/** STACK
 *      groupBy
 */
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function setGroupBy(key: string, checkResult?: boolean) {
    DocumentView.SelectedDocs().forEach(doc => { doc._text_fontFamily = key; }); // prettier-ignore
    const editorView = RichTextMenu.Instance?.TextView?.EditorView;
    if (checkResult) {
        return StrCast((editorView ? RichTextMenu.Instance : Doc.UserDoc())?.fontFamily);
    }
    if (editorView) RichTextMenu.Instance?.setFontField(key, 'fontFamily');
    else Doc.UserDoc().fontFamily = key;
    return undefined;
});