import { action, computed, makeObservable, observable, ObservableSet, observe } from 'mobx';
import { Doc, DocListCast, Opt } from '../../fields/Doc';
import { AclAdmin, AclEdit, Animation } from '../../fields/DocSymbols';
import { Id } from '../../fields/FieldSymbols';
import { listSpec } from '../../fields/Schema';
import { Cast, DocCast, NumCast, StrCast } from '../../fields/Types';
import { AudioField } from '../../fields/URLField';
import { GetEffectiveAcl } from '../../fields/util';
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 { KeyValueBox } from '../views/nodes/KeyValueBox';
import { LinkAnchorBox } from '../views/nodes/LinkAnchorBox';
import { LoadingBox } from '../views/nodes/LoadingBox';
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.shallow public LinkAnchorBoxViews: DocumentView[] = [];
    @observable.shallow 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());
    }
    @observable.shallow public CurrentlyLoading: Doc[] = []; // this assignment doesn't work. the actual assignment happens in DocumentManager's constructor

    //private constructor so no other class can create a nodemanager
    private constructor() {
        makeObservable(this);
        observe(this.CurrentlyLoading, change => {
            // watch CurrentlyLoading-- when something is loaded, it's removed from the list and we have to update its icon if it were iconified since LoadingBox icons are different than the media they become
            switch (change.type as any) {
                case 'update':
                    break;
                case 'remove':
                    // DocumentManager.Instance.getAllDocumentViews(change as any).forEach(dv => StrCast(dv.Document.layout_fieldKey) === 'layout_icon' && dv.iconify(() => dv.iconify()));
                    break;
                case 'splice':
                    (change as any).removed.forEach((doc: Doc) => DocumentManager.Instance.getAllDocumentViews(doc).forEach(dv => StrCast(dv.Document.layout_fieldKey) === 'layout_icon' && dv.iconify(() => dv.iconify())));
                    break;
            }
        });
    }

    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.Document);
        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) => {
        if (view._props.LayoutTemplateString?.includes(KeyValueBox.name)) return;
        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.Document;
            this.LinkAnchorBoxViews?.filter(dv => Doc.AreProtosEqual(dv.Document, 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);
        } 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.Document[Id] === id) {
                toReturn.push(view);
            }
        });
        if (toReturn.length === 0) {
            DocumentManager.Instance.DocumentViews.forEach(view => {
                if (Doc.GetProto(view.Document)?.[Id] === id) {
                    toReturn.push(view);
                }
            });
        }
        return toReturn;
    }

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

    public getDocumentView(target: Doc | undefined, preferredCollection?: DocumentView): DocumentView | undefined {
        const docViewArray = DocumentManager.Instance.DocumentViews;
        const passes = !target ? [] : preferredCollection ? [preferredCollection, undefined] : [undefined];
        return passes.reduce(
            (toReturn, pass) =>
                toReturn ??
                docViewArray.filter(view => view.Document === target).find(view => !pass || view._props.docViewPath().lastElement() === preferredCollection) ??
                docViewArray.filter(view => Doc.AreProtosEqual(view.Document, target)).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.Document, 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.Document !== 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.Document.data as any)?.url?.href && (dv.Document.data as any)?.url?.href === (toFindIn.data as any)?.url?.href) ||
            //         ((DocCast(dv.Document.annotationOn)?.data as any)?.url?.href && (DocCast(dv.Document.annotationOn)?.data as any)?.url?.href === (DocCast(toFindIn.annotationOn)?.data as any)?.url?.href)
            // )?.Document ??
            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.Document === toFind && toReturn.push(view));
        lightViews.map(view => view.Document !== toFind && Doc.AreProtosEqual(view.Document, toFind) && toReturn.push(view));
        docViews.map(view => view.Document === toFind && toReturn.push(view));
        docViews.map(view => view.Document !== toFind && Doc.AreProtosEqual(view.Document, 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.Document.hidden)) targetDocView.Document.hidden = !targetDocView.Document.hidden;
        else if (options.openLocation?.startsWith(OpenWhere.toggle) && !options.didMove && rootContextView) DocumentViewInternal.addDocTabFunc(rootContextView.Document, 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.
    ) => {
        Doc.RemoveDocFromList(Doc.MyRecentlyClosed, undefined, targetDoc);
        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) {
            if (docView.Document.layout_fieldKey === 'layout_icon') {
                await new Promise<void>(res => docView.iconify(res));
                options.didMove = true;
            }
            const nextFocus = docView._props.focus(docView.Document, 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.Document, docView, contextView, focused };
            contextView = options.anchorDoc?.layout_unrendered ? childDocView : 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)
            //viewSpec !== docView.Document &&
            docView.ComponentView?.focus?.(viewSpec, options);
            PresBox.restoreTargetDocView(docView, viewSpec, options.zoomTime ?? 500);
            Doc.linkFollowHighlight(viewSpec ? [docView.Document, viewSpec] : docView.Document, undefined, options.effect);
            if (options.playMedia) docView.ComponentView?.playFrom?.(NumCast(docView.Document._layout_currentTimecode));
            if (options.playAudio) DocumentManager.playAudioAnno(docView.Document);
            if (options.toggleTarget && (!options.didMove || docView.Document.hidden)) docView.Document.hidden = !docView.Document.hidden;
            if (options.effect) docView.Document[Animation] = options.effect;

            if (options.zoomTextSelections && Doc.UnhighlightTimer && contextView && viewSpec.text_html) {
                // if the docView is a text anchor, the contextView is the PDF/Web/Text doc
                contextView.htmlOverlayEffect = options.effect;
                contextView.textHtmlOverlayTime = options.zoomTime;
                contextView.textHtmlOverlay = StrCast(targetDoc.text_html);
                DocumentManager._overlayViews.add(contextView);
            }
            Doc.AddUnHighlightWatcher(() => {
                docView.Document[Animation] = undefined;
                DocumentManager.removeOverlayViews();
                contextView && (contextView.htmlOverlayEffect = undefined);
            });
        }
    }
}
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.Document));
        } else {
            const container = DocCast(containingDoc ?? doc.embedContainer ?? Doc.BestEmbedding(doc));
            const showDoc = !Doc.IsSystem(container) && !cv ? 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.Document);
            });
        }
    };
    if (Doc.IsDataProto(doc) && DocListCast(doc.proto_embeddings).some(embed => embed.hidden && [AclAdmin, AclEdit].includes(GetEffectiveAcl(embed)))) {
        doc = DocListCast(doc.proto_embeddings).find(embed => embed.hidden && [AclAdmin, AclEdit].includes(GetEffectiveAcl(embed)))!;
    }
    if (doc.hidden) {
        doc.hidden = false;
        options.toggleTarget = false;
        setTimeout(func);
    } else func();
}
ScriptingGlobals.add(DocFocusOrOpen);