import { action, computed, observable, ObservableSet } from 'mobx';
import { Doc, Opt } from '../../fields/Doc';
import { Animation } from '../../fields/DocSymbols';
import { Id } from '../../fields/FieldSymbols';
import { listSpec } from '../../fields/Schema';
import { Cast, DocCast, StrCast } from '../../fields/Types';
import { AudioField } from '../../fields/URLField';
import { CollectionViewType } from '../documents/DocumentTypes';
import { CollectionDockingView } from '../views/collections/CollectionDockingView';
import { TabDocView } from '../views/collections/TabDocView';
import { LightboxView } from '../views/LightboxView';
import { DocFocusOptions, DocumentView, DocumentViewInternal, OpenWhere, OpenWhereMod } from '../views/nodes/DocumentView';
import { FormattedTextBox } from '../views/nodes/formattedText/FormattedTextBox';
import { KeyValueBox } from '../views/nodes/KeyValueBox';
import { LinkAnchorBox } from '../views/nodes/LinkAnchorBox';
import { PresBox } from '../views/nodes/trails';
import { ScriptingGlobals } from './ScriptingGlobals';
import { SelectionManager } from './SelectionManager';
const { Howl } = require('howler');

export class DocumentManager {
    //global holds all of the nodes (regardless of which collection they're in)
    @observable _documentViews = new Set<DocumentView>();
    @observable public LinkAnchorBoxViews: DocumentView[] = [];
    @observable public RecordingEvent = 0;
    @observable public LinkedDocumentViews: { a: DocumentView; b: DocumentView; l: Doc }[] = [];
    @computed public get DocumentViews() {
        return Array.from(this._documentViews).filter(view => !(view.ComponentView instanceof KeyValueBox) && (!LightboxView.LightboxDoc || LightboxView.IsLightboxDocView(view.docViewPath)));
    }
    public AddDocumentView(dv: DocumentView) {
        this._documentViews.add(dv);
    }
    public DeleteDocumentView(dv: DocumentView) {
        this._documentViews.delete(dv);
    }

    private static _instance: DocumentManager;
    public static get Instance(): DocumentManager {
        return this._instance || (this._instance = new this());
    }

    //private constructor so no other class can create a nodemanager
    private constructor() {}

    private _viewRenderedCbs: { doc: Doc; func: (dv: DocumentView) => any }[] = [];
    public AddViewRenderedCb = (doc: Opt<Doc>, func: (dv: DocumentView) => any) => {
        if (doc) {
            const dv = this.getDocumentView(doc);
            this._viewRenderedCbs.push({ doc, func });
            if (dv) {
                this.callAddViewFuncs(dv);
                return true;
            }
        } else {
            func(undefined as any);
        }
        return false;
    };
    callAddViewFuncs = (view: DocumentView) => {
        const callFuncs = this._viewRenderedCbs.filter(vc => vc.doc === view.rootDoc);
        if (callFuncs.length) {
            this._viewRenderedCbs = this._viewRenderedCbs.filter(vc => !callFuncs.includes(vc));
            const intTimer = setInterval(
                () => {
                    if (!view.ComponentView?.incrementalRendering?.()) {
                        callFuncs.forEach(cf => cf.func(view));
                        clearInterval(intTimer);
                    }
                },
                view.ComponentView?.incrementalRendering?.() ? 0 : 100
            );
        }
    };

    @action
    public AddView = (view: DocumentView) => {
        //console.log("MOUNT " + view.props.Document.title + "/" + view.props.LayoutTemplateString);
        if (view.props.LayoutTemplateString?.includes(LinkAnchorBox.name)) {
            const viewAnchorIndex = view.props.LayoutTemplateString.includes('link_anchor_2') ? 'link_anchor_2' : 'link_anchor_1';
            const link = view.rootDoc;
            this.LinkAnchorBoxViews?.filter(dv => Doc.AreProtosEqual(dv.rootDoc, link) && !dv.props.LayoutTemplateString?.includes(viewAnchorIndex)).forEach(otherView =>
                this.LinkedDocumentViews.push({
                    a: viewAnchorIndex === 'link_anchor_2' ? otherView : view,
                    b: viewAnchorIndex === 'link_anchor_2' ? view : otherView,
                    l: link,
                })
            );
            this.LinkAnchorBoxViews.push(view);
            // this.LinkedDocumentViews.forEach(view => console.log("  LV = " + view.a.props.Document.title + "/" + view.a.props.LayoutTemplateString + " --> " +
            //     view.b.props.Document.title + "/" + view.b.props.LayoutTemplateString));
        } else {
            this.AddDocumentView(view);
        }
        this.callAddViewFuncs(view);
    };
    public RemoveView = action((view: DocumentView) => {
        this.LinkedDocumentViews.slice().forEach(
            action(pair => {
                if (pair.a === view || pair.b === view) {
                    const li = this.LinkedDocumentViews.indexOf(pair);
                    li !== -1 && this.LinkedDocumentViews.splice(li, 1);
                }
            })
        );

        if (view.props.LayoutTemplateString?.includes(LinkAnchorBox.name)) {
            const index = this.LinkAnchorBoxViews.indexOf(view);
            this.LinkAnchorBoxViews.splice(index, 1);
        } else {
            this.DeleteDocumentView(view);
        }
        SelectionManager.DeselectView(view);
    });

    //gets all views
    public getDocumentViewsById(id: string) {
        const toReturn: DocumentView[] = [];
        DocumentManager.Instance.DocumentViews.forEach(view => {
            if (view.rootDoc[Id] === id) {
                toReturn.push(view);
            }
        });
        if (toReturn.length === 0) {
            DocumentManager.Instance.DocumentViews.forEach(view => {
                if (Doc.GetProto(view.rootDoc)?.[Id] === id) {
                    toReturn.push(view);
                }
            });
        }
        return toReturn;
    }

    public getAllDocumentViews(doc: Doc) {
        return this.getDocumentViewsById(doc[Id]);
    }

    public getDocumentView(toFind: Doc | undefined, preferredCollection?: DocumentView): DocumentView | undefined {
        const doc =
            // bcz: this was temporary code used to match documents by data url instead of by id. intended only for repairing the DB
            // Array.from(DocumentManager.Instance.DocumentViews).find(
            //     dv =>
            //         ((dv.rootDoc.data as any)?.url?.href && (dv.rootDoc.data as any)?.url?.href === (toFind.data as any)?.url?.href) ||
            //         ((DocCast(dv.rootDoc.annotationOn)?.data as any)?.url?.href && (DocCast(dv.rootDoc.annotationOn)?.data as any)?.url?.href === (DocCast(toFind.annotationOn)?.data as any)?.url?.href)
            // )?.rootDoc ??
            toFind;
        const docViewArray = DocumentManager.Instance.DocumentViews;
        const passes = !doc ? [] : preferredCollection ? [preferredCollection, undefined] : [undefined];
        return passes.reduce(
            (pass, toReturn) =>
                toReturn ??
                docViewArray.filter(view => view.rootDoc === doc).find(view => !pass || view.props.docViewPath().lastElement() === preferredCollection) ??
                docViewArray.filter(view => Doc.AreProtosEqual(view.rootDoc, doc)).find(view => !pass || view.props.docViewPath().lastElement() === preferredCollection),
            undefined as Opt<DocumentView>
        );
    }

    public getLightboxDocumentView = (toFind: Doc, originatingDoc: Opt<Doc> = undefined): DocumentView | undefined => {
        const views: DocumentView[] = [];
        DocumentManager.Instance.DocumentViews.forEach(view => LightboxView.IsLightboxDocView(view.docViewPath) && Doc.AreProtosEqual(view.rootDoc, toFind) && views.push(view));
        return views?.find(view => view.ContentDiv?.getBoundingClientRect().width /*&& view.props.focus !== returnFalse) || views?.find(view => view.props.focus !== returnFalse*/) || (views.length ? views[0] : undefined);
    };
    public getFirstDocumentView = (toFind: Doc, originatingDoc: Opt<Doc> = undefined): DocumentView | undefined => {
        if (LightboxView.LightboxDoc) return DocumentManager.Instance.getLightboxDocumentView(toFind, originatingDoc);
        const views = this.getDocumentViews(toFind); //.filter(view => view.rootDoc !== originatingDoc);
        return views?.find(view => view.ContentDiv?.getBoundingClientRect().width /*&& view.props.focus !== returnFalse) || views?.find(view => view.props.focus !== returnFalse*/) || (views.length ? views[0] : undefined);
    };
    public getDocumentViews(toFindIn: Doc): DocumentView[] {
        const toFind =
            // Array.from(DocumentManager.Instance.DocumentViews).find(
            //     dv =>
            //         ((dv.rootDoc.data as any)?.url?.href && (dv.rootDoc.data as any)?.url?.href === (toFindIn.data as any)?.url?.href) ||
            //         ((DocCast(dv.rootDoc.annotationOn)?.data as any)?.url?.href && (DocCast(dv.rootDoc.annotationOn)?.data as any)?.url?.href === (DocCast(toFindIn.annotationOn)?.data as any)?.url?.href)
            // )?.rootDoc ??
            toFindIn;

        const toReturn: DocumentView[] = [];
        const docViews = DocumentManager.Instance.DocumentViews.filter(view => !LightboxView.IsLightboxDocView(view.docViewPath));
        const lightViews = DocumentManager.Instance.DocumentViews.filter(view => LightboxView.IsLightboxDocView(view.docViewPath));

        // heuristic to return the "best" documents first:
        //   choose a document in the lightbox first
        //   choose an exact match over an embedding match
        lightViews.map(view => view.rootDoc === toFind && toReturn.push(view));
        lightViews.map(view => view.rootDoc !== toFind && Doc.AreProtosEqual(view.rootDoc, toFind) && toReturn.push(view));
        docViews.map(view => view.rootDoc === toFind && toReturn.push(view));
        docViews.map(view => view.rootDoc !== toFind && Doc.AreProtosEqual(view.rootDoc, toFind) && toReturn.push(view));

        return toReturn;
    }

    static GetContextPath(doc: Opt<Doc>, includeExistingViews?: boolean) {
        if (!doc) return [];
        const srcContext = DocCast(doc.annotationOn, DocCast(doc.embedContainer));
        var containerDocContext = srcContext ? [srcContext, doc] : [doc];
        while (
            containerDocContext.length &&
            DocCast(containerDocContext[0]?.embedContainer) &&
            DocCast(containerDocContext[0].embedContainer)?._type_collection !== CollectionViewType.Docking &&
            (includeExistingViews || !DocumentManager.Instance.getDocumentView(containerDocContext[0]))
        ) {
            containerDocContext = [Cast(containerDocContext[0].embedContainer, Doc, null), ...containerDocContext];
        }
        return containerDocContext;
    }

    static playAudioAnno(doc: Doc) {
        const anno = Cast(doc[Doc.LayoutFieldKey(doc) + '-audioAnnotations'], listSpec(AudioField), null)?.lastElement();
        if (anno) {
            if (anno instanceof AudioField) {
                new Howl({
                    src: [anno.url.href],
                    format: ['mp3'],
                    autoplay: true,
                    loop: false,
                    volume: 0.5,
                });
            }
        }
    }

    public static removeOverlayViews() {
        DocumentManager._overlayViews?.forEach(action(view => (view.textHtmlOverlay = undefined)));
        DocumentManager._overlayViews?.clear();
    }
    static _overlayViews = new ObservableSet<DocumentView>();
    static addView = (doc: Doc, finished?: () => void) => {
        CollectionDockingView.AddSplit(doc, OpenWhereMod.right);
        finished?.();
    };

    // shows a documentView by:
    // traverses down through the viewPath of contexts to the view:
    //           focusing on each context
    public showDocumentView = async (targetDocView: DocumentView, options: DocFocusOptions) => {
        const docViewPath = targetDocView.docViewPath.slice();
        let rootContextView = docViewPath.shift();
        await (rootContextView && this.focusViewsInPath(rootContextView, options, async () => ({ childDocView: docViewPath.shift(), viewSpec: undefined, focused: false })));
        if (options.toggleTarget && (!options.didMove || targetDocView.rootDoc.hidden)) targetDocView.rootDoc.hidden = !targetDocView.rootDoc.hidden;
        else if (options.openLocation?.startsWith(OpenWhere.toggle) && !options.didMove && rootContextView) DocumentViewInternal.addDocTabFunc(rootContextView.rootDoc, options.openLocation);
    };

    // shows a document by first:
    //           traversing down through the contexts that contain target until an existing view is found
    //           if no container view is found, create one by: opening an existing tab that has the top-level view, or showing the top-level context in the lightbox.
    // once a containing view is found, it then traverses back down through the contexts to the target document by:
    //           focusing on each context
    //           and finally restoring the targetDoc to the viewSpec specified by the last document which may either be the targetDoc, or a viewSpec that describes the targetDoc configuration
    public showDocument = async (
        targetDoc: Doc, // document to display
        options: DocFocusOptions, // options for how to navigate to target
        finished?: (changed: boolean) => void // func called after focusing on target with flag indicating whether anything needed to be done.
    ) => {
        const docContextPath = DocumentManager.GetContextPath(targetDoc, true);
        if (docContextPath.some(doc => doc.hidden)) options.toggleTarget = false;
        let rootContextView =
            docContextPath.length &&
            (await new Promise<DocumentView>(res => {
                const viewIndex = docContextPath.findIndex(doc => this.getDocumentView(doc));
                if (viewIndex !== -1) {
                    viewIndex && docContextPath.splice(0, viewIndex);
                    return res(this.getDocumentView(docContextPath[0])!);
                }
                options.didMove = true;
                docContextPath.some(doc => TabDocView.Activate(doc)) || DocumentViewInternal.addDocTabFunc(docContextPath[0], options.openLocation ?? OpenWhere.addRight);
                this.AddViewRenderedCb(docContextPath[0], dv => res(dv));
            }));
        if (options.openLocation === OpenWhere.lightbox) {
            // even if we found the document view, if the target is a lightbox, we try to open it in the lightbox to preserve lightbox semantics (eg, there's only one active doc in the lightbox)
            const target = DocCast(targetDoc.annotationOn, targetDoc);
            const contextView = this.getDocumentView(DocCast(target.embedContainer));
            if (contextView?.docView?._componentView?.addDocTab?.(target, OpenWhere.lightbox)) {
                await new Promise<void>(waitres => setTimeout(() => waitres()));
            }
        }
        docContextPath.shift();
        const childViewIterator = async (docView: DocumentView) => {
            const innerDoc = docContextPath.shift();
            return { focused: false, viewSpec: innerDoc, childDocView: innerDoc && !innerDoc.layout_unrendered ? (await docView.ComponentView?.getView?.(innerDoc)) ?? this.getDocumentView(innerDoc) : undefined };
        };

        if (rootContextView) {
            const target = await this.focusViewsInPath(rootContextView, options, childViewIterator);
            this.restoreDocView(target.viewSpec, target.docView, options, target.contextView ?? target.docView, targetDoc);
            finished?.(target.focused);
        } else finished?.(false);
    };

    focusViewsInPath = async (
        docView: DocumentView, //
        options: DocFocusOptions,
        iterator: (docView: DocumentView) => Promise<{ viewSpec: Opt<Doc>; childDocView: Opt<DocumentView>; focused: boolean }>
    ) => {
        let contextView: DocumentView | undefined; // view containing context that contains target
        let focused = false;
        while (true) {
            docView.rootDoc.layout_fieldKey === 'layout_icon' ? await new Promise<void>(res => docView.iconify(res)) : undefined;
            const nextFocus = docView.props.focus(docView.rootDoc, options); // focus the view within its container
            focused = focused || (nextFocus === undefined ? false : true); // keep track of whether focusing on a view needed to actually change anything
            const { childDocView, viewSpec } = await iterator(docView);
            if (!childDocView) return { viewSpec: options.anchorDoc ?? viewSpec ?? docView.rootDoc, docView, contextView, focused };
            contextView = docView;
            docView = childDocView;
        }
    };

    @action
    restoreDocView(viewSpec: Opt<Doc>, docView: DocumentView, options: DocFocusOptions, contextView: Opt<DocumentView>, targetDoc: Doc) {
        if (viewSpec && docView) {
            if (docView.ComponentView instanceof FormattedTextBox) docView.ComponentView?.focus(viewSpec, options);
            PresBox.restoreTargetDocView(docView, viewSpec, options.zoomTime ?? 500);
            Doc.linkFollowHighlight(docView.rootDoc, undefined, options.effect);
            if (options.playAudio) DocumentManager.playAudioAnno(docView.rootDoc);
            if (options.toggleTarget && (!options.didMove || docView.rootDoc.hidden)) docView.rootDoc.hidden = !docView.rootDoc.hidden;
            if (options.effect) docView.rootDoc[Animation] = options.effect;

            if (options.zoomTextSelections && Doc.UnhighlightTimer && contextView && viewSpec.textHtml) {
                // if the docView is a text anchor, the contextView is the PDF/Web/Text doc
                contextView.htmlOverlayEffect = StrCast(options?.effect?.presEffect, StrCast(options?.effect?.followLinkAnimEffect));
                contextView.textHtmlOverlay = StrCast(targetDoc.textHtml);
                DocumentManager._overlayViews.add(contextView);
            }
            Doc.AddUnHighlightWatcher(() => {
                docView.rootDoc[Animation] = undefined;
                DocumentManager.removeOverlayViews();
                contextView && (contextView.htmlOverlayEffect = '');
            });
        }
    }
}
export function DocFocusOrOpen(doc: Doc, options: DocFocusOptions = { willZoomCentered: true, zoomScale: 0, openLocation: OpenWhere.toggleRight }, containingDoc?: Doc) {
    const func = () => {
        const cv = DocumentManager.Instance.getDocumentView(containingDoc);
        const dv = DocumentManager.Instance.getDocumentView(doc, cv);
        if (dv && (!containingDoc || dv.props.docViewPath().lastElement()?.Document === containingDoc)) {
            DocumentManager.Instance.showDocumentView(dv, options).then(() => dv && Doc.linkFollowHighlight(dv.rootDoc));
        } else {
            const container = DocCast(containingDoc ?? doc.embedContainer ?? doc);
            const showDoc = !Doc.IsSystem(container) ? container : doc;
            options.toggleTarget = undefined;
            DocumentManager.Instance.showDocument(showDoc, options, () => DocumentManager.Instance.showDocument(doc, { ...options, openLocation: undefined })).then(() => {
                const cv = DocumentManager.Instance.getDocumentView(containingDoc);
                const dv = DocumentManager.Instance.getDocumentView(doc, cv);
                dv && Doc.linkFollowHighlight(dv.rootDoc);
            });
        }
    };
    if (doc.hidden) {
        doc.hidden = false;
        options.toggleTarget = false;
        setTimeout(func);
    } else func();
}
ScriptingGlobals.add(DocFocusOrOpen);