import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { Tooltip } from '@mui/material';
import axios from 'axios';
import { Colors } from 'browndash-components';
import { action, computed, IReactionDisposer, makeObservable, observable, ObservableMap, reaction } from 'mobx';
import { observer } from 'mobx-react';
import { extname } from 'path';
import * as React from 'react';
import ReactLoading from 'react-loading';
import { ClientUtils, DashColor, returnEmptyString, returnFalse, returnOne, returnZero, setupMoveUpEvents } from '../../../ClientUtils';
import { Doc, DocListCast, Opt } from '../../../fields/Doc';
import { DocData } from '../../../fields/DocSymbols';
import { Id } from '../../../fields/FieldSymbols';
import { InkTool } from '../../../fields/InkField';
import { ObjectField } from '../../../fields/ObjectField';
import { Cast, ImageCast, NumCast, RTFCast, StrCast } from '../../../fields/Types';
import { ImageField } from '../../../fields/URLField';
import { TraceMobx } from '../../../fields/util';
import { emptyFunction } from '../../../Utils';
import { gptAPICall, GPTCallType, gptImageLabel } from '../../apis/gpt/GPT';
import { Docs } from '../../documents/Documents';
import { DocumentType } from '../../documents/DocumentTypes';
import { DocUtils, FollowLinkScript } from '../../documents/DocUtils';
import { Networking } from '../../Network';
import { DragManager } from '../../util/DragManager';
import { dropActionType } from '../../util/DropActionTypes';
import { SnappingManager } from '../../util/SnappingManager';
import { undoBatch } from '../../util/UndoManager';
import { CollectionFreeFormView } from '../collections/collectionFreeForm/CollectionFreeFormView';
import { ContextMenu } from '../ContextMenu';
import { ContextMenuProps } from '../ContextMenuItem';
import { ViewBoxAnnotatableComponent } from '../DocComponent';
import { MarqueeAnnotator } from '../MarqueeAnnotator';
import { OverlayView } from '../OverlayView';
import { AnchorMenu } from '../pdf/AnchorMenu';
import { PinDocView, PinProps } from '../PinFuncs';
import { StyleProp } from '../StyleProp';
import { DocumentView } from './DocumentView';
import { FieldView, FieldViewProps } from './FieldView';
import { FocusViewOptions } from './FocusViewOptions';
import { ImageUtility } from './generativeFill/generativeFillUtils/ImageHandler';
import './ImageBox.scss';
import { OpenWhere } from './OpenWhere';
// import stringSimilarity from 'string-similarity';

enum quizMode {
    SMART = 'smart',
    NORMAL = 'normal',
    NONE = 'none',
}

export class ImageEditorData {
    // eslint-disable-next-line no-use-before-define
    private static _instance: ImageEditorData;
    private static get imageData() { return (ImageEditorData._instance ?? new ImageEditorData()).imageData; } // prettier-ignore
    @observable imageData: { rootDoc: Doc | undefined; open: boolean; source: string; addDoc: Opt<(doc: Doc | Doc[], annotationKey?: string) => boolean> } = observable({ rootDoc: undefined, open: false, source: '', addDoc: undefined });
    @action private static set = (open: boolean, rootDoc: Doc | undefined, source: string, addDoc: Opt<(doc: Doc | Doc[], annotationKey?: string) => boolean>) => {
        this._instance.imageData = { open, rootDoc, source, addDoc };
    };

    constructor() {
        makeObservable(this);
        ImageEditorData._instance = this;
    }

    public static get Open()                     { return ImageEditorData.imageData.open;  } // prettier-ignore
    public static set Open(open: boolean)        { ImageEditorData.set(open, this.imageData.rootDoc, this.imageData.source, this.imageData.addDoc); } // prettier-ignore
    public static get Source()                   { return ImageEditorData.imageData.source; } // prettier-ignore
    public static set Source(source: string)     { ImageEditorData.set(this.imageData.open, this.imageData.rootDoc, source, this.imageData.addDoc); } // prettier-ignore
    public static get RootDoc()                  { return ImageEditorData.imageData.rootDoc; } // prettier-ignore
    public static set RootDoc(rootDoc: Opt<Doc>) { ImageEditorData.set(this.imageData.open, rootDoc, this.imageData.source, this.imageData.addDoc); } // prettier-ignore
    public static get AddDoc()                   { return ImageEditorData.imageData.addDoc; } // prettier-ignore
    public static set AddDoc(addDoc: Opt<(doc: Doc | Doc[], annotationKey?: string) => boolean>) { ImageEditorData.set(this.imageData.open, this.imageData.rootDoc, this.imageData.source, addDoc); } // prettier-ignore
}

const API_URL = 'https://api.unsplash.com/search/photos';
@observer
export class ImageBox extends ViewBoxAnnotatableComponent<FieldViewProps>() {
    public static LayoutString(fieldKey: string) {
        return FieldView.LayoutString(ImageBox, fieldKey);
    }
    private _ignoreScroll = false;
    private _forcedScroll = false;
    private _dropDisposer?: DragManager.DragDropDisposer;
    private _disposers: { [name: string]: IReactionDisposer } = {};
    private _getAnchor: (savedAnnotations: Opt<ObservableMap<number, HTMLDivElement[]>>, addAsAnnotation: boolean) => Opt<Doc> = () => undefined;
    private _overlayIconRef = React.createRef<HTMLDivElement>();
    private _marqueeref = React.createRef<MarqueeAnnotator>();
    private _mainCont: React.RefObject<HTMLDivElement> = React.createRef();
    private _annotationLayer: React.RefObject<HTMLDivElement> = React.createRef();
    private _imageRef: HTMLImageElement | null = null; // <video> ref
    @observable private _quizBoxes: Doc[] = [];
    @observable private _searchInput = '';
    @observable private _quizMode = quizMode.NONE;
    @observable private _savedAnnotations = new ObservableMap<number, (HTMLDivElement & { marqueeing?: boolean })[]>();
    @observable private _curSuffix = '';
    @observable private _error = '';
    @observable private _loading = false;
    @observable private _isHovering = false; // flag to switch between primary and alternate images on hover
    _ffref = React.createRef<CollectionFreeFormView>();

    constructor(props: FieldViewProps) {
        super(props);
        makeObservable(this);
        this._props.setContentViewBox?.(this);
    }

    protected createDropTarget = (ele: HTMLDivElement) => {
        this._dropDisposer?.();
        ele && (this._dropDisposer = DragManager.MakeDropTarget(ele, this.drop.bind(this), this.Document));
    };

    getAnchor = (addAsAnnotation: boolean, pinProps?: PinProps) => {
        const visibleAnchor = this._getAnchor?.(this._savedAnnotations, true); // use marquee anchor, otherwise, save zoom/pan as anchor
        const anchor =
            visibleAnchor ??
            Docs.Create.ConfigDocument({
                title: 'ImgAnchor:' + this.Document.title,
                config_panX: NumCast(this.layoutDoc._freeform_panX),
                config_panY: NumCast(this.layoutDoc._freeform_panY),
                config_viewScale: Cast(this.layoutDoc._freeform_scale, 'number', null),
                annotationOn: this.Document,
            });
        if (anchor) {
            if (!addAsAnnotation) anchor.backgroundColor = 'transparent';
            addAsAnnotation && this.addDocument(anchor);
            PinDocView(anchor, { pinDocLayout: pinProps?.pinDocLayout, pinData: { ...(pinProps?.pinData ?? {}), pannable: !visibleAnchor } }, this.Document);
            return anchor;
        }
        return this.Document;
    };

    componentDidMount() {
        this._disposers.sizer = reaction(
            () => ({
                forceFull: this._props.renderDepth < 1 || this.layoutDoc._showFullRes,
                scrSize: (this.ScreenToLocalBoxXf().inverse().transformDirection(this.nativeSize.nativeWidth, this.nativeSize.nativeHeight)[0] / this.nativeSize.nativeWidth) * NumCast(this.layoutDoc._freeform_scale, 1),
                selected: this._props.isSelected(),
            }),
            ({ forceFull, scrSize, selected }) => {
                this._curSuffix = selected ? '_o' : this.fieldKey === 'icon' ? '_m' : forceFull ? '_o' : scrSize < 0.25 ? '_s' : scrSize < 0.5 ? '_m' : scrSize < 0.8 ? '_l' : '_o';
            },
            { fireImmediately: true, delay: 1000 }
        );
        const { layoutDoc } = this;
        this._disposers.path = reaction(
            () => ({ nativeSize: this.nativeSize, width: NumCast(this.layoutDoc._width) }),
            ({ nativeSize, width }) => {
                if (layoutDoc === this.layoutDoc || !this.layoutDoc._height) {
                    this.layoutDoc._height = (width * nativeSize.nativeHeight) / nativeSize.nativeWidth;
                }
            },
            { fireImmediately: true }
        );
        this._disposers.scroll = reaction(
            () => this.layoutDoc.layout_scrollTop,
            sTop => {
                this._forcedScroll = true;
                !this._ignoreScroll && this._mainCont.current && (this._mainCont.current.scrollTop = NumCast(sTop));
                this._mainCont.current?.scrollTo({ top: NumCast(sTop) });
                this._forcedScroll = false;
            },
            { fireImmediately: true }
        );
    }

    componentWillUnmount() {
        Object.values(this._disposers).forEach(disposer => disposer?.());
    }

    /**
     * Find images from the unsplash api to add to flashcards.
     */
    fetchImages = async () => {
        try {
            const { data } = await axios.get(`${API_URL}?query=${this._searchInput}&page=1&per_page=${1}&client_id=${process.env.VITE_API_KEY}`);
            const imageSnapshot = Docs.Create.ImageDocument(data.results[0].urls.small, {
                _nativeWidth: Doc.NativeWidth(this.layoutDoc),
                _nativeHeight: Doc.NativeHeight(this.layoutDoc),
                x: NumCast(this.layoutDoc.x),
                y: NumCast(this.layoutDoc.y),
                onClick: FollowLinkScript(),
                _width: 150,
                _height: 150,
                title: '--snapshot' + NumCast(this.layoutDoc._layout_currentTimecode) + ' image-',
            });
            this._props.addDocument?.(imageSnapshot);
        } catch (error) {
            console.log(error);
        }
    };

    handleSelection = async (selection: string) => {
        this._searchInput = selection;
        const images = await this.fetchImages();
    };

    @undoBatch
    drop = (e: Event, de: DragManager.DropEvent) => {
        if (de.complete.docDragData) {
            let added: boolean | undefined;
            const targetIsBullseye = (ele: HTMLElement): boolean => {
                if (!ele) return false;
                if (ele === this._overlayIconRef.current) return true;
                return targetIsBullseye(ele.parentElement as HTMLElement);
            };
            if (de.metaKey || targetIsBullseye(e.target as HTMLElement)) {
                added = de.complete.docDragData.droppedDocuments.reduce((last: boolean, drop: Doc) => {
                    this.layoutDoc[this.fieldKey + '_usePath'] = 'alternate:hover';
                    return last && Doc.AddDocToList(this.dataDoc, this.fieldKey + '_alternates', drop);
                }, true);
            } else if (de.altKey || !this.dataDoc[this.fieldKey]) {
                const layoutDoc = de.complete.docDragData?.draggedDocuments[0];
                const targetField = Doc.LayoutFieldKey(layoutDoc);
                const targetDoc = layoutDoc[DocData];
                if (targetDoc[targetField] instanceof ImageField) {
                    added = true;
                    this.dataDoc[this.fieldKey] = ObjectField.MakeCopy(targetDoc[targetField] as ImageField);
                    Doc.SetNativeWidth(this.dataDoc, Doc.NativeWidth(targetDoc), this.fieldKey);
                    Doc.SetNativeHeight(this.dataDoc, Doc.NativeHeight(targetDoc), this.fieldKey);
                }
            }
            added === false && e.preventDefault();
            added !== undefined && e.stopPropagation();
            return added;
        }
        return false;
    };

    @undoBatch
    resolution = () => {
        this.layoutDoc._showFullRes = !this.layoutDoc._showFullRes;
    };

    @undoBatch
    setNativeSize = action(() => {
        const oldnativeWidth = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth']);
        const nscale = NumCast(this._props.PanelWidth()) * NumCast(this.layoutDoc._freeform_scale, 1);
        const nw = nscale / oldnativeWidth;
        this.dataDoc[this.fieldKey + '_nativeHeight'] = NumCast(this.dataDoc[this.fieldKey + '_nativeHeight']) * nw;
        this.dataDoc[this.fieldKey + '_nativeWidth'] = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth']) * nw;
        this.dataDoc._freeform_panX = nw * NumCast(this.dataDoc._freeform_panX);
        this.dataDoc._freeform_panY = nw * NumCast(this.dataDoc._freeform_panY);
        this.dataDoc._freeform_panX_max = this.dataDoc._freeform_panX_max ? nw * NumCast(this.dataDoc._freeform_panX_max) : undefined;
        this.dataDoc._freeform_panX_min = this.dataDoc._freeform_panX_min ? nw * NumCast(this.dataDoc._freeform_panX_min) : undefined;
        this.dataDoc._freeform_panY_max = this.dataDoc._freeform_panY_max ? nw * NumCast(this.dataDoc._freeform_panY_max) : undefined;
        this.dataDoc._freeform_panY_min = this.dataDoc._freeform_panY_min ? nw * NumCast(this.dataDoc._freeform_panY_min) : undefined;
        const newnativeWidth = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth']);
        DocListCast(this.dataDoc[this.annotationKey]).forEach(doc => {
            doc.x = (NumCast(doc.x) / oldnativeWidth) * newnativeWidth;
            doc.y = (NumCast(doc.y) / oldnativeWidth) * newnativeWidth;
            if (!RTFCast(doc[Doc.LayoutFieldKey(doc)])) {
                doc.width = (NumCast(doc.width) / oldnativeWidth) * newnativeWidth;
                doc.height = (NumCast(doc.height) / oldnativeWidth) * newnativeWidth;
            }
        });
    });
    @undoBatch
    rotate = action(() => {
        const nw = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth']);
        const nh = NumCast(this.dataDoc[this.fieldKey + '_nativeHeight']);
        const w = this.layoutDoc._width;
        const h = this.layoutDoc._height;
        this.dataDoc[this.fieldKey + '_rotation'] = (NumCast(this.dataDoc[this.fieldKey + '_rotation']) + 90) % 360;
        this.dataDoc[this.fieldKey + '_nativeWidth'] = nh;
        this.dataDoc[this.fieldKey + '_nativeHeight'] = nw;
        this.layoutDoc._width = h;
        this.layoutDoc._height = w;
    });

    crop = (region: Doc | undefined, addCrop?: boolean) => {
        if (!region) return undefined;
        const cropping = Doc.MakeCopy(region, true);
        const regionData = region[DocData];
        regionData.lockedPosition = true;
        regionData.title = 'region:' + this.Document.title;
        regionData.followLinkToggle = true;
        this.addDocument(region);
        const anchx = NumCast(cropping.x);
        const anchy = NumCast(cropping.y);
        const anchw = NumCast(cropping._width);
        const anchh = NumCast(cropping._height);
        const viewScale = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth']) / anchw;
        cropping.title = 'crop: ' + this.Document.title;
        cropping.x = NumCast(this.Document.x) + NumCast(this.layoutDoc._width);
        cropping.y = NumCast(this.Document.y);
        cropping._width = anchw * (this._props.NativeDimScaling?.() || 1);
        cropping._height = anchh * (this._props.NativeDimScaling?.() || 1);
        cropping.onClick = undefined;
        const croppingProto = cropping[DocData];
        croppingProto.annotationOn = undefined;
        croppingProto.isDataDoc = true;
        croppingProto.backgroundColor = undefined;
        croppingProto.proto = Cast(this.Document.proto, Doc, null)?.proto; // set proto of cropping's data doc to be IMAGE_PROTO
        croppingProto.type = DocumentType.IMG;
        croppingProto.layout = ImageBox.LayoutString('data');
        croppingProto.data = ObjectField.MakeCopy(this.dataDoc[this.fieldKey] as ObjectField);
        croppingProto.data_nativeWidth = anchw;
        croppingProto.data_nativeHeight = anchh;
        croppingProto.freeform_scale = viewScale;
        croppingProto.freeform_scale_min = viewScale;
        croppingProto.freeform_panX = anchx / viewScale;
        croppingProto.freeform_panY = anchy / viewScale;
        croppingProto.freeform_panX_min = anchx / viewScale;
        croppingProto.freeform_panX_max = anchw / viewScale;
        croppingProto.freeform_panY_min = anchy / viewScale;
        croppingProto.freeform_panY_max = anchh / viewScale;
        if (addCrop) {
            DocUtils.MakeLink(region, cropping, { link_relationship: 'cropped image' });
            cropping.x = NumCast(this.Document.x) + NumCast(this.layoutDoc._width);
            cropping.y = NumCast(this.Document.y);
            this._props.addDocTab(cropping, OpenWhere.inParent);
        }
        DocumentView.addViewRenderedCb(cropping, dv => setTimeout(() => (dv.ComponentView as ImageBox).setNativeSize(), 200));
        this._props.bringToFront?.(cropping);
        return cropping;
    };

    createCanvas = async () => {
        const canvas = document.createElement('canvas');
        const scaling = 1 / (this._props.NativeDimScaling?.() || 1);
        const w = AnchorMenu.Instance.marqueeWidth * scaling;
        const h = AnchorMenu.Instance.marqueeHeight * scaling;
        canvas.width = w;
        canvas.height = h;
        const ctx = canvas.getContext('2d'); // draw image to canvas. scale to target dimensions
        if (ctx) {
            this._imageRef && ctx.drawImage(this._imageRef, NumCast(this._marqueeref.current?.left) * scaling, NumCast(this._marqueeref.current?.top) * scaling, w, h, 0, 0, w, h);
        }
        const blob = await ImageUtility.canvasToBlob(canvas);
        return ImageBox.selectUrlToBase64(blob);
    };

    createSnapshotLink = (imagePath: string, downX?: number, downY?: number) => {
        const url = !imagePath.startsWith('/') ? ClientUtils.CorsProxy(imagePath) : imagePath;
        const width = NumCast(this.layoutDoc._width) || 1;
        const height = NumCast(this.layoutDoc._height);
        const imageSnapshot = Docs.Create.ImageDocument(url, {
            _nativeWidth: Doc.NativeWidth(this.layoutDoc),
            _nativeHeight: Doc.NativeHeight(this.layoutDoc),
            x: NumCast(this.layoutDoc.x) + width,
            y: NumCast(this.layoutDoc.y),
            onClick: FollowLinkScript(),
            _width: 150,
            _height: (height / width) * 150,
            title: '--snapshot' + NumCast(this.layoutDoc._layout_currentTimecode) + ' image-',
        });
        Doc.SetNativeWidth(imageSnapshot[DocData], Doc.NativeWidth(this.layoutDoc));
        Doc.SetNativeHeight(imageSnapshot[DocData], Doc.NativeHeight(this.layoutDoc));
        this._props.addDocument?.(imageSnapshot);
        DocUtils.MakeLink(imageSnapshot, this.getAnchor(true), { link_relationship: 'video snapshot' });
        setTimeout(() => downX !== undefined && downY !== undefined && DocumentView.getFirstDocumentView(imageSnapshot)?.startDragging(downX, downY, dropActionType.move, true));
    };

    static selectUrlToBase64 = async (blob: Blob): Promise<string> => {
        try {
            return new Promise((resolve, reject) => {
                const reader = new FileReader();
                reader.readAsDataURL(blob);
                reader.onloadend = () => resolve(reader.result as string);
                reader.onerror = error => reject(error);
            });
        } catch (error) {
            console.error('Error:', error);
            throw error;
        }
    };

    pushInfo = async (quiz: quizMode, i?: string) => {
        this._quizMode = quiz;
        this._loading = true;

        const img = {
            file: i ? i : this.paths[0],
            drag: i ? 'drag' : 'full',
            smart: quiz,
        };
        const response = await axios.post('http://localhost:105/labels/', img, {
            headers: {
                'Content-Type': 'application/json',
            },
        });
        if (response.data['boxes'].length != 0) {
            this.createBoxes(response.data['boxes'], response.data['text']);
        } else {
            this._loading = false;
        }
    };

    /**
     * Creates label boxes over text on the image to be filled in.
     * @param boxes
     * @param texts
     */
    createBoxes = (boxes: [[[number, number]]], texts: [string]) => {
        for (let i = 0; i < boxes.length; i++) {
            const coords = boxes[i] ? boxes[i] : [];
            const width = coords[1][0] - coords[0][0];
            const height = coords[2][1] - coords[0][1];
            const text = texts[i];

            const newCol = Docs.Create.LabelDocument({
                _width: width,
                _height: height,
                _layout_fitWidth: true,
                title: '',
            });
            const scaling = 1 / (this._props.NativeDimScaling?.() || 1);
            newCol.x = coords[0][0] + NumCast(this._marqueeref.current?.left) * scaling;
            newCol.y = coords[0][1] + NumCast(this._marqueeref.current?.top) * scaling;

            newCol.zIndex = 1000;
            newCol.forceActive = true;
            newCol.quiz = text;
            newCol.showQuiz = false;
            newCol[DocData].textTransform = 'none';
            this._quizBoxes.push(newCol);
            this.addDocument(newCol);
            this._loading = false;
        }
    };

    /**
     * Create flashcards from an image.
     */
    getImageDesc = async () => {
        this._loading = true;
        try {
            const hrefBase64 = await this.createCanvas();
            const response = await gptImageLabel(hrefBase64, 'Make flashcards out of this image with each question and answer labeled as "question" and "answer". Do not label each flashcard and do not include asterisks: ');
            AnchorMenu.Instance.transferToFlashcard(response, NumCast(this.layoutDoc['x']), NumCast(this.layoutDoc['y']));
        } catch (error) {
            console.log('Error', error);
        }
        this._loading = false;
    };

    makeLabels = async () => {
        try {
            const hrefBase64 = await this.createCanvas();
            this.pushInfo(quizMode.NORMAL, hrefBase64);
        } catch (error) {
            console.log('Error', error);
        }
    };

    levenshteinDistance = (str1: string, str2: string) => {
        const len1 = str1.length;
        const len2 = str2.length;
        const dp = Array.from(Array(len1 + 1), () => Array(len2 + 1).fill(0));

        if (len1 === 0) return len2;
        if (len2 === 0) return len1;

        for (let i = 0; i <= len1; i++) dp[i][0] = i;
        for (let j = 0; j <= len2; j++) dp[0][j] = j;

        for (let i = 1; i <= len1; i++) {
            for (let j = 1; j <= len2; j++) {
                const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
                dp[i][j] = Math.min(
                    dp[i - 1][j] + 1, // deletion
                    dp[i][j - 1] + 1, // insertion
                    dp[i - 1][j - 1] + cost // substitution
                );
            }
        }

        return dp[len1][len2];
    };

    jaccardSimilarity = (str1: string, str2: string) => {
        const set1 = new Set(str1.split(' '));
        const set2 = new Set(str2.split(' '));

        const intersection = new Set([...set1].filter(x => set2.has(x)));
        const union = new Set([...set1, ...set2]);

        return intersection.size / union.size;
    };

    stringSimilarity(str1: string, str2: string) {
        const levenshteinDist = this.levenshteinDistance(str1, str2);
        const levenshteinScore = 1 - levenshteinDist / Math.max(str1.length, str2.length);

        const jaccardScore = this.jaccardSimilarity(str1, str2);

        // Combine the scores with a higher weight on Jaccard similarity
        return 0.5 * levenshteinScore + 0.5 * jaccardScore;
    }

    @computed get checkIcon() {
        return (
            <Tooltip title={<div className="dash-tooltip">Check</div>}>
                <div className="check-icon" onPointerDown={this.check}>
                    <FontAwesomeIcon icon="circle-check" size="lg" />
                </div>
            </Tooltip>
        );
    }

    @computed get redoIcon() {
        return (
            <Tooltip title={<div className="dash-tooltip">Redo</div>}>
                <div className="redo-icon" onPointerDown={this.redo}>
                    <FontAwesomeIcon icon="redo-alt" size="lg" />
                </div>
            </Tooltip>
        );
    }

    compareWords = (input: string, target: string) => {
        const distance = this.stringSimilarity(input.toLowerCase(), target.toLowerCase());
        // const threshold = Math.max(input.length, target.length) * 0.2; // Allow up to 20% of the length as difference
        return distance >= 0.7;
    };

    extractHexAndSentences = (inputString: string) => {
        // Regular expression to match a hexadecimal number at the beginning followed by a period and sentences
        const regex = /^#([0-9A-Fa-f]+)\.\s*(.+)$/s;
        const match = inputString.match(regex);

        if (match) {
            const hexNumber = match[1];
            const sentences = match[2].trim();
            return { hexNumber, sentences };
        } else {
            return { error: 'The input string does not match the expected format.' };
        }
    };

    /**
     * Check whether the contents of the label boxes on an image are correct.
     */
    check = () => {
        this._loading = true;
        this._quizBoxes.forEach(async doc => {
            const input = StrCast(doc[DocData].title);
            if (this._quizMode == quizMode.SMART && input) {
                const questionText = 'Question: What was labeled in this image?';
                const rubricText = ' Rubric: ' + StrCast(doc.quiz);
                const queryText =
                    questionText +
                    ' UserAnswer: ' +
                    input +
                    '. ' +
                    rubricText +
                    '. One sentence and evaluate based on meaning, not wording. Provide a hex color at the beginning with a period after it on a scale of green (minor details missed) to red (big error) for how correct the answer is. Example: "#FFFFFF. Pasta is delicious."';
                const response = await gptAPICall(queryText, GPTCallType.QUIZ);
                const hexSent = this.extractHexAndSentences(response);
                doc.quiz = hexSent.sentences?.replace(/UserAnswer/g, "user's answer").replace(/Rubric/g, 'rubric');
                doc.backgroundColor = '#' + hexSent.hexNumber;
            } else {
                const match = this.compareWords(input, StrCast(doc.quiz));
                doc.backgroundColor = match ? '#11c249' : '#eb2d2d';
            }
            doc.showQuiz = true;
        });
        this._loading = false;
    };

    redo = () => {
        this._quizBoxes.forEach(doc => {
            doc[DocData].title = '';
            doc.backgroundColor = '#e4e4e4';
            doc.showQuiz = false;
        });
    };

    exitQuizMode = () => {
        this._quizMode = quizMode.NONE;
        this._quizBoxes.forEach(doc => {
            this.removeDocument?.(doc);
        });
        this._quizBoxes = [];
        console.log('remove');
    };

    @action
    setRef = (iref: HTMLImageElement | null) => {
        this._imageRef = iref;
    };

    specificContextMenu = (): void => {
        const field = Cast(this.dataDoc[this.fieldKey], ImageField);
        if (field) {
            const funcs: ContextMenuProps[] = [];
            const quizes: ContextMenuProps[] = [];
            quizes.push({
                description: 'Smart Check',
                event: this._quizMode == quizMode.NONE ? () => this.pushInfo(quizMode.SMART) : this.exitQuizMode,
                icon: 'pen-to-square',
            });
            quizes.push({
                description: 'Normal',
                event: this._quizMode == quizMode.NONE ? () => this.pushInfo(quizMode.NORMAL) : this.exitQuizMode,
                icon: 'pencil',
            });
            funcs.push({ description: 'Rotate Clockwise 90', event: this.rotate, icon: 'redo-alt' });
            funcs.push({ description: `Show ${this.layoutDoc._showFullRes ? 'Dynamic Res' : 'Full Res'}`, event: this.resolution, icon: 'expand' });
            funcs.push({ description: 'Set Native Pixel Size', event: this.setNativeSize, icon: 'expand-arrows-alt' });
            funcs.push({ description: 'Copy path', event: () => ClientUtils.CopyText(this.choosePath(field.url)), icon: 'copy' });
            funcs.push({
                description: 'Open Image Editor',
                event: action(() => {
                    ImageEditorData.Open = true;
                    ImageEditorData.Source = this.choosePath(field.url);
                    ImageEditorData.AddDoc = this._props.addDocument;
                    ImageEditorData.RootDoc = this.Document;
                }),
                icon: 'pencil-alt',
            });
            ContextMenu.Instance?.addItem({ description: 'Quiz Mode', subitems: quizes, icon: 'file-pen' });
            ContextMenu.Instance?.addItem({ description: 'Options...', subitems: funcs, icon: 'asterisk' });
        }
    };

    choosePath = (url: URL) => {
        if (!url?.href) return '';
        const lower = url.href.toLowerCase();
        if (url.protocol === 'data') return url.href;
        if (url.href.indexOf(window.location.origin) === -1 && url.href.indexOf('dashblobstore') === -1) return ClientUtils.CorsProxy(url.href);
        if (!/\.(png|jpg|jpeg|gif|webp)$/.test(lower) || lower.endsWith('/assets/unknown-file-icon-hi.png')) return `/assets/unknown-file-icon-hi.png`;

        const ext = extname(url.href);
        return url.href.replace(ext, (this._error ? '_o' : this._curSuffix) + ext);
    };
    getScrollHeight = () => (this._props.fitWidth?.(this.Document) !== false && NumCast(this.layoutDoc._freeform_scale, 1) === NumCast(this.dataDoc._freeform_scaleMin, 1) ? this.nativeSize.nativeHeight : undefined);

    @computed get nativeSize() {
        TraceMobx();
        const nativeWidth = NumCast(this.dataDoc[this.fieldKey + '_nativeWidth'], NumCast(this.layoutDoc[this.fieldKey + '_nativeWidth'], 500));
        const nativeHeight = NumCast(this.dataDoc[this.fieldKey + '_nativeHeight'], NumCast(this.layoutDoc[this.fieldKey + '_nativeHeight'], 500));
        const nativeOrientation = NumCast(this.dataDoc[this.fieldKey + '_nativeOrientation'], 1);
        return { nativeWidth, nativeHeight, nativeOrientation };
    }
    @computed get overlayImageIcon() {
        const usePath = this.layoutDoc[`_${this.fieldKey}_usePath`];
        return (
            <Tooltip
                title={
                    <div className="dash-tooltip">
                        toggle between
                        <span style={{ color: usePath === undefined ? 'black' : undefined }}>
                            <em> primary, </em>
                        </span>
                        <span style={{ color: usePath === 'alternate' ? 'black' : undefined }}>
                            <em>alternate, </em>
                        </span>
                        and show
                        <span style={{ color: usePath === 'alternate:hover' ? 'black' : undefined }}>
                            <em> alternate on hover</em>
                        </span>
                    </div>
                }>
                <div
                    className="imageBox-alternateDropTarget"
                    ref={this._overlayIconRef}
                    onPointerDown={e =>
                        setupMoveUpEvents(e.target, e, returnFalse, emptyFunction, () => {
                            this.layoutDoc[`_${this.fieldKey}_usePath`] = usePath === undefined ? 'alternate' : usePath === 'alternate' ? 'alternate:hover' : undefined;
                        })
                    }
                    style={{
                        display: (this._props.isContentActive() !== false && SnappingManager.CanEmbed) || this.dataDoc[this.fieldKey + '_alternates'] ? 'block' : 'none',
                        width: 'min(10%, 25px)',
                        height: 'min(10%, 25px)',
                        background: usePath === undefined ? 'white' : usePath === 'alternate' ? 'black' : 'gray',
                        color: usePath === undefined ? 'black' : 'white',
                    }}>
                    <FontAwesomeIcon icon="circle-half-stroke" size="lg" />
                </div>
            </Tooltip>
        );
    }

    @computed get paths() {
        const field = Cast(this.dataDoc[this.fieldKey], ImageField, null); // retrieve the primary image URL that is being rendered from the data doc
        const alts = DocListCast(this.dataDoc[this.fieldKey + '_alternates']); // retrieve alternate documents that may be rendered as alternate images
        const defaultUrl = new URL(ClientUtils.prepend('/assets/unknown-file-icon-hi.png'));
        const altpaths =
            alts
                ?.map(doc => (doc instanceof Doc ? (ImageCast(doc[Doc.LayoutFieldKey(doc)])?.url ?? defaultUrl) : defaultUrl))
                .filter(url => url)
                .map(url => this.choosePath(url)) ?? []; // acc  ess the primary layout data of the alternate documents
        const paths = field ? [this.choosePath(field.url), ...altpaths] : altpaths;
        return paths.length ? paths : [defaultUrl.href];
    }

    @computed get content() {
        TraceMobx();

        const backColor = DashColor((this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.BackgroundColor) as string) ?? Colors.WHITE);
        // allow use case where the image is transparent when the alpha value is to smallest possible value from UI (alpha = 1 out of 255)
        const backAlpha = backColor.alpha() < 0.015 && backColor.alpha() > 0 ? backColor.alpha() : 1;
        const srcpath = this.layoutDoc.hideImage ? '' : this.paths[0];
        const fadepath = this.layoutDoc.hideImage ? '' : this.paths.lastElement();
        const { nativeWidth, nativeHeight /* , nativeOrientation */ } = this.nativeSize;
        const rotation = NumCast(this.dataDoc[this.fieldKey + '_rotation']);
        const aspect = rotation % 180 ? nativeHeight / nativeWidth : 1;
        let transformOrigin = 'center center';
        let transform = `translate(0%, 0%) rotate(${rotation}deg) scale(${aspect})`;
        if (rotation === 90 || rotation === -270) {
            transformOrigin = 'top left';
            transform = `translate(100%, 0%) rotate(${rotation}deg) scale(${aspect})`;
        } else if (rotation === 180) {
            transform = `rotate(${rotation}deg) scale(${aspect})`;
        } else if (rotation === 270 || rotation === -90) {
            transformOrigin = 'right top';
            transform = `translate(-100%, 0%) rotate(${rotation}deg) scale(${aspect})`;
        }
        const usePath = this.layoutDoc[`_${this.fieldKey}_usePath`];

        return (
            <div
                className="imageBox-cont"
                onPointerEnter={action(() => {
                    this._isHovering = true;
                })}
                onPointerLeave={action(() => {
                    this._isHovering = false;
                })}
                key={this.layoutDoc[Id]}
                ref={this.createDropTarget}
                onPointerDown={this.marqueeDown}>
                <div className="imageBox-fader" style={{ opacity: backAlpha }}>
                    <img
                        alt=""
                        ref={this.setRef}
                        key="paths"
                        src={srcpath}
                        style={{ transform, transformOrigin }}
                        onError={action(e => {
                            this._error = e.toString();
                        })}
                        draggable={false}
                        width={nativeWidth}
                    />
                    {fadepath === srcpath ? null : (
                        <div className={`imageBox-fadeBlocker${(this._isHovering && usePath === 'alternate:hover') || usePath === 'alternate' ? '-hover' : ''}`} style={{ transition: StrCast(this.layoutDoc.viewTransition, 'opacity 1000ms') }}>
                            <img alt="" className="imageBox-fadeaway" key="fadeaway" src={fadepath} style={{ transform, transformOrigin }} draggable={false} width={nativeWidth} />
                        </div>
                    )}
                </div>
                {this.overlayImageIcon}
            </div>
        );
    }

    @computed get annotationLayer() {
        TraceMobx();
        return <div className="imageBox-annotationLayer" style={{ height: this._props.PanelHeight() }} ref={this._annotationLayer} />;
    }
    screenToLocalTransform = () => this.ScreenToLocalBoxXf().translate(0, NumCast(this.layoutDoc._layout_scrollTop) * this.ScreenToLocalBoxXf().Scale);
    marqueeDown = (e: React.PointerEvent) => {
        if (!this.dataDoc[this.fieldKey]) {
            this.chooseImage();
        } else if (
            !e.altKey &&
            e.button === 0 &&
            NumCast(this.layoutDoc._freeform_scale, 1) <= NumCast(this.dataDoc.freeform_scaleMin, 1) &&
            this._props.isContentActive() &&
            ![InkTool.Highlighter, InkTool.Pen, InkTool.Write].includes(Doc.ActiveTool)
        ) {
            setupMoveUpEvents(
                this,
                e,
                action(moveEv => {
                    MarqueeAnnotator.clearAnnotations(this._savedAnnotations);
                    this._marqueeref.current?.onInitiateSelection([moveEv.clientX, moveEv.clientY]);
                    return true;
                }),
                returnFalse,
                () => MarqueeAnnotator.clearAnnotations(this._savedAnnotations),
                false
            );
        }
    };
    @action
    finishMarquee = () => {
        this._getAnchor = AnchorMenu.Instance?.GetAnchor;
        AnchorMenu.Instance.gptFlashcards = this.getImageDesc;
        AnchorMenu.Instance.addToCollection = this._props.DocumentView?.()._props.addDocument;
        AnchorMenu.Instance.makeLabels = this.makeLabels;
        AnchorMenu.Instance.marqueeWidth = this._marqueeref.current?.Width ?? 0;
        AnchorMenu.Instance.marqueeHeight = this._marqueeref.current?.Height ?? 0;
        this._marqueeref.current?.onTerminateSelection();
        this._props.select(false);
    };
    focus = (anchor: Doc, options: FocusViewOptions) => (anchor.type === DocumentType.CONFIG ? undefined : this._ffref.current?.focus(anchor, options));

    renderedPixelDimensions = async () => {
        const { nativeWidth: width, nativeHeight: height } = await Networking.PostToServer('/inspectImage', { source: this.paths[0] });
        return { width, height };
    };

    savedAnnotations = () => this._savedAnnotations;
    render() {
        TraceMobx();
        const borderRad = this._props.styleProvider?.(this.layoutDoc, this._props, StyleProp.BorderRounding) as string;
        const borderRadius = borderRad?.includes('px') ? `${Number(borderRad.split('px')[0]) / (this._props.NativeDimScaling?.() || 1)}px` : borderRad;
        return (
            <div
                className="imageBox"
                onContextMenu={this.specificContextMenu}
                ref={this._mainCont}
                onScroll={action(() => {
                    if (!this._forcedScroll) {
                        if (this.layoutDoc._layout_scrollTop || this._mainCont.current?.scrollTop) {
                            this._ignoreScroll = true;
                            this.layoutDoc._layout_scrollTop = this._mainCont.current?.scrollTop;
                            this._ignoreScroll = false;
                        }
                    }
                })}
                style={{
                    width: this._props.PanelWidth() ? undefined : `100%`,
                    height: this._props.PanelWidth() ? undefined : `100%`,
                    pointerEvents: this.layoutDoc._lockedPosition ? 'none' : undefined,
                    borderRadius,
                    overflow: this.layoutDoc.layout_fitWidth || this._props.fitWidth?.(this.Document) ? 'auto' : 'hidden',
                }}>
                <CollectionFreeFormView
                    ref={this._ffref}
                    {...this._props}
                    setContentViewBox={emptyFunction}
                    NativeWidth={returnZero}
                    NativeHeight={returnZero}
                    renderDepth={this._props.renderDepth + 1}
                    fieldKey={this.annotationKey}
                    styleProvider={this._props.styleProvider}
                    isAnnotationOverlay
                    annotationLayerHostsContent
                    PanelWidth={this._props.PanelWidth}
                    PanelHeight={this._props.PanelHeight}
                    ScreenToLocalTransform={this.screenToLocalTransform}
                    select={emptyFunction}
                    focus={this.focus}
                    getScrollHeight={this.getScrollHeight}
                    NativeDimScaling={returnOne}
                    isAnyChildContentActive={returnFalse}
                    whenChildContentsActiveChanged={this.whenChildContentsActiveChanged}
                    removeDocument={this.removeDocument}
                    moveDocument={this.moveDocument}
                    addDocument={this.addDocument}>
                    {this.content}
                </CollectionFreeFormView>
                {this._loading ? (
                    <div className="loading-spinner" style={{ position: 'absolute' }}>
                        <ReactLoading type="spin" height={50} width={50} color={'blue'} />
                    </div>
                ) : null}
                {this.annotationLayer}
                {!this._mainCont.current || !this.DocumentView || !this._annotationLayer.current ? null : (
                    <MarqueeAnnotator
                        Document={this.Document}
                        ref={this._marqueeref}
                        scrollTop={0}
                        annotationLayerScrollTop={0}
                        scaling={returnOne}
                        annotationLayerScaling={this._props.NativeDimScaling}
                        docView={this.DocumentView}
                        addDocument={this.addDocument}
                        finishMarquee={this.finishMarquee}
                        savedAnnotations={this.savedAnnotations}
                        selectionText={returnEmptyString}
                        annotationLayer={this._annotationLayer.current}
                        marqueeContainer={this._mainCont.current}
                        highlightDragSrcColor=""
                        anchorMenuCrop={this.crop}
                        // anchorMenuFlashcard={() => this.getImageDesc()}
                    />
                )}
                {this._quizMode != quizMode.NONE ? this.checkIcon : null}
                {this._quizMode != quizMode.NONE ? this.redoIcon : null}
            </div>
        );
    }

    public chooseImage = () => {
        const input = document.createElement('input');
        input.type = 'file';
        input.multiple = true;
        input.accept = 'image/*';
        input.onchange = async () => {
            const file = input.files?.[0];
            if (file) {
                const disposer = OverlayView.ShowSpinner();
                const [{ result }] = await Networking.UploadFilesToServer({ file });
                if (result instanceof Error) {
                    alert('Error uploading files - possibly due to unsupported file types');
                } else {
                    this.dataDoc[this.fieldKey] = new ImageField(result.accessPaths.agnostic.client);
                    !(result instanceof Error) && DocUtils.assignImageInfo(result, this.dataDoc);
                }
                disposer();
            } else {
                console.log('No file selected');
            }
        };
        input.click();
    };
}

Docs.Prototypes.TemplateMap.set(DocumentType.IMG, {
    layout: { view: ImageBox, dataField: 'data' },
    options: { acl: '', freeform: '', systemIcon: 'BsFileEarmarkImageFill' },
});
