import { action, observable, runInAction } from 'mobx';
import { Doc, DocListCast, DocListCastAsync, Opt } from '../../fields/Doc';
import { Id } from '../../fields/FieldSymbols';
import { Cast } from '../../fields/Types';
import { returnFalse } from '../../Utils';
import { DocumentType } from '../documents/DocumentTypes';
import { CollectionDockingView } from '../views/collections/CollectionDockingView';
import { CollectionFreeFormView } from '../views/collections/collectionFreeForm';
import { CollectionView } from '../views/collections/CollectionView';
import { LightboxView } from '../views/LightboxView';
import { DocumentView, ViewAdjustment } from '../views/nodes/DocumentView';
import { LinkAnchorBox } from '../views/nodes/LinkAnchorBox';
import { ScriptingGlobals } from './ScriptingGlobals';
import { SelectionManager } from './SelectionManager';

export class DocumentManager {

    //global holds all of the nodes (regardless of which collection they're in)
    @observable public DocumentViews = new Set<DocumentView>();
    @observable public LinkAnchorBoxViews: DocumentView[] = [];
    @observable public RecordingEvent = 0;
    @observable public LinkedDocumentViews: { a: DocumentView, b: DocumentView, l: Doc }[] = [];

    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() { }

    @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("anchor2") ? "anchor2" : "anchor1";
            DocListCast(view.rootDoc.links).forEach(link => {
                this.LinkAnchorBoxViews?.filter(dv => Doc.AreProtosEqual(dv.rootDoc, link) && !dv.props.LayoutTemplateString?.includes(viewAnchorIndex)).
                    forEach(otherView => this.LinkedDocumentViews.push(
                        {
                            a: viewAnchorIndex === "anchor2" ? otherView : view,
                            b: viewAnchorIndex === "anchor2" ? 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.DocumentViews.add(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.DocumentViews.delete(view);
        }
        SelectionManager.DeselectView(view);
    });

    //gets all views
    public getDocumentViewsById(id: string) {
        const toReturn: DocumentView[] = [];
        Array.from(DocumentManager.Instance.DocumentViews).map(view => {
            if (view.rootDoc[Id] === id) {
                toReturn.push(view);
            }
        });
        if (toReturn.length === 0) {
            Array.from(DocumentManager.Instance.DocumentViews).map(view => {
                const doc = view.rootDoc.proto;
                if (doc && doc[Id] && doc[Id] === id) {
                    toReturn.push(view);
                }
            });
        }
        return toReturn;
    }

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

    public getDocumentViewById(id: string, preferredCollection?: CollectionView): DocumentView | undefined {
        if (!id) return undefined;
        let toReturn: DocumentView | undefined;
        const passes = preferredCollection ? [preferredCollection, undefined] : [undefined];

        for (const pass of passes) {
            Array.from(DocumentManager.Instance.DocumentViews).map(view => {
                if (view.rootDoc[Id] === id && (!pass || view.props.ContainingCollectionView === preferredCollection)) {
                    toReturn = view;
                    return;
                }
            });
            if (!toReturn) {
                Array.from(DocumentManager.Instance.DocumentViews).map(view => {
                    const doc = view.rootDoc.proto;
                    if (doc && doc[Id] === id && (!pass || view.props.ContainingCollectionView === preferredCollection)) {
                        toReturn = view;
                    }
                });
            } else {
                break;
            }
        }

        return toReturn;
    }

    public getDocumentView(toFind: Doc, preferredCollection?: CollectionView): DocumentView | undefined {
        return this.getDocumentViewById(toFind[Id], preferredCollection);
    }

    public getLightboxDocumentView = (toFind: Doc, originatingDoc: Opt<Doc> = undefined): DocumentView | undefined => {
        const views: DocumentView[] = [];
        Array.from(DocumentManager.Instance.DocumentViews).map(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 => {
        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(toFind: Doc): DocumentView[] {
        const toReturn: DocumentView[] = [];
        const docViews = Array.from(DocumentManager.Instance.DocumentViews).filter(view => !LightboxView.IsLightboxDocView(view.docViewPath));
        const lightViews = Array.from(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 alias 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 addView = (doc: Doc, finished?: () => void) => {
        CollectionDockingView.AddSplit(doc, "right");
        finished?.();
    }
    public jumpToDocument = async (
        targetDoc: Doc,        // document to display
        willZoom: boolean,     // whether to zoom doc to take up most of screen
        createViewFunc = DocumentManager.addView, // how to create a view of the doc if it doesn't exist
        docContext: Doc[],  // context to load that should contain the target
        linkDoc?: Doc,   // link that's being followed
        closeContextIfNotFound: boolean = false, // after opening a context where the document should be, this determines whether the context should be closed if the Doc isn't actually there
        originatingDoc: Opt<Doc> = undefined, // doc that initiated the display of the target odoc
        finished?: () => void,
        originalTarget?: Doc,
        noSelect?: boolean,
        presZoom?: number
    ): Promise<void> => {
        originalTarget = originalTarget ?? targetDoc;
        const getFirstDocView = LightboxView.LightboxDoc ? DocumentManager.Instance.getLightboxDocumentView : DocumentManager.Instance.getFirstDocumentView;
        const docView = getFirstDocView(targetDoc, originatingDoc);
        const annotatedDoc = Cast(targetDoc.annotationOn, Doc, null);
        const resolvedTarget = targetDoc.type === DocumentType.MARKER ? annotatedDoc ?? targetDoc : targetDoc; // if target is a marker, then focus toggling should apply to the document it's on since the marker itself doesn't have a hidden field
        var wasHidden = resolvedTarget.hidden;
        if (wasHidden) {
            runInAction(() => {
                resolvedTarget.hidden = false;  // if the target is hidden, un-hide it here.
                docView?.props.bringToFront(resolvedTarget);
            });
        }
        const focusAndFinish = (didFocus: boolean) => {
            const finalTargetDoc = resolvedTarget;
            if (originatingDoc?.isPushpin) {
                if (!didFocus && !wasHidden) {  // don't toggle the hidden state if the doc was already un-hidden as part of this document traversal
                    finalTargetDoc.hidden = !finalTargetDoc.hidden;
                }
            } else {
                finalTargetDoc.hidden && (finalTargetDoc.hidden = undefined);
                !noSelect && docView?.select(false);
            }
            finished?.();
        };
        const annoContainerView = (!wasHidden || resolvedTarget !== annotatedDoc) && annotatedDoc && getFirstDocView(annotatedDoc);
        const contextDocs = docContext.length ? await DocListCastAsync(docContext[0].data) : undefined;
        const contextDoc = contextDocs?.find(doc => Doc.AreProtosEqual(doc, targetDoc) || Doc.AreProtosEqual(doc, annotatedDoc)) ? docContext.lastElement() : undefined;
        const targetDocContext = contextDoc || annotatedDoc;
        const targetDocContextView = (targetDocContext && getFirstDocView(targetDocContext)) ||
            (wasHidden && annoContainerView);// if we have an annotation container and the target was hidden, then try again because we just un-hid the document above
        const focusView = !docView && targetDoc.type === DocumentType.MARKER && annoContainerView ? annoContainerView : docView;
        if (annoContainerView) {
            if (annoContainerView.props.Document.layoutKey === "layout_icon") {
                annoContainerView.iconify(() => annoContainerView.focus(targetDoc, {
                    originalTarget, willZoom, scale: presZoom, afterFocus: (didFocus: boolean) =>
                        new Promise<ViewAdjustment>(res => {
                            focusAndFinish(true);
                            res(ViewAdjustment.doNothing);
                        })
                }));
                return;
            } else if (!docView && targetDoc.type !== DocumentType.MARKER) {
                annoContainerView.focus(targetDoc);  // this allows something like a PDF view to remove its doc filters to expose the target so that it can be found in the retry code below
            }
        }
        if (focusView) {
            !noSelect && Doc.linkFollowHighlight(focusView.rootDoc); //TODO:glr make this a setting in PresBox
            const doFocus = (forceDidFocus: boolean) => focusView.focus(originalTarget ?? targetDoc, {
                originalTarget, willZoom, scale: presZoom, afterFocus: (didFocus: boolean) =>
                    new Promise<ViewAdjustment>(res => {
                        focusAndFinish(forceDidFocus || didFocus);
                        res(ViewAdjustment.doNothing);
                    })
            });
            if (focusView.props.Document.layoutKey === "layout_icon") {
                focusView.iconify(() => doFocus(true));
            } else {
                doFocus(false);
            }
        } else {
            if (!targetDocContext) { // we don't have a view and there's no context specified ... create a new view of the target using the dockFunc or default
                createViewFunc(Doc.BrushDoc(targetDoc), finished); // bcz: should we use this?: Doc.MakeAlias(targetDoc)));
            } else {  // otherwise try to get a view of the context of the target
                if (targetDocContextView) { // we found a context view and aren't forced to create a new one ... focus on the context first..
                    wasHidden = wasHidden || targetDocContextView.rootDoc.hidden;
                    targetDocContextView.rootDoc.hidden = false; // make sure context isn't hidden
                    targetDocContext._viewTransition = "transform 500ms";
                    targetDocContextView.props.focus(targetDocContextView.rootDoc, {
                        willZoom, afterFocus: async () => {
                            targetDocContext._viewTransition = undefined;
                            if (targetDocContext.layoutKey === "layout_icon") {
                                targetDocContextView.iconify(() => this.jumpToDocument(
                                    resolvedTarget ?? targetDoc, willZoom, createViewFunc, docContext, linkDoc, closeContextIfNotFound, originatingDoc,
                                    finished, originalTarget, noSelect, presZoom));
                            }
                            return ViewAdjustment.doNothing;
                        }
                    });

                    // now find the target document within the context
                    if (targetDoc._timecodeToShow) {  // if the target has a timecode, it should show up once the (presumed) video context scrubs to the display timecode;
                        targetDocContext._currentTimecode = targetDoc.anchorTimecodeToShow;
                        finished?.();
                    } else { // no timecode means we need to find the context view and focus on our target
                        const findView = (delay: number) => {
                            const retryDocView = getFirstDocView(resolvedTarget);  // test again for the target view snce we presumably created the context above by focusing on it
                            if (retryDocView) {   // we found the target in the context. 
                                Doc.linkFollowHighlight(retryDocView.rootDoc);
                                retryDocView.focus(targetDoc, {
                                    willZoom, afterFocus: (didFocus: boolean) =>
                                        new Promise<ViewAdjustment>(res => {
                                            !noSelect && focusAndFinish(didFocus);
                                            res(ViewAdjustment.doNothing);
                                        })
                                }); // focus on the target in the context
                            } else if (delay > 1000) {
                                // we didn't find the target, so it must have moved out of the context.  Go back to just creating it.
                                if (closeContextIfNotFound) targetDocContextView.props.removeDocument?.(targetDocContextView.rootDoc);
                                if (targetDoc.layout) { // there will no layout for a TEXTANCHOR type document
                                    createViewFunc(Doc.BrushDoc(targetDoc), finished); //  create a new view of the target
                                }
                            } else {
                                setTimeout(() => findView(delay + 200), 200);
                            }
                        };
                        setTimeout(() => findView(0), 0);
                    }
                } else {
                    if (docContext.length && docContext[0]?.layoutKey === "layout_icon") {
                        const docContextView = this.getFirstDocumentView(docContext[0]);
                        if (docContextView) {
                            return docContextView.iconify(() => this.jumpToDocument(
                                targetDoc, willZoom, createViewFunc, docContext.slice(1, docContext.length), linkDoc, closeContextIfNotFound, originatingDoc,
                                finished, originalTarget, noSelect, presZoom));
                        }
                    }
                    // there's no context view so we need to create one first and try again when that finishes
                    const finishFunc = () => this.jumpToDocument(targetDoc, true, createViewFunc, docContext, linkDoc, true /* if we don't find the target, we want to get rid of the context just created */, undefined, finished, originalTarget);
                    createViewFunc(targetDocContext, // after creating the context, this calls the finish function that will retry looking for the target
                        finishFunc);
                }
            }
        }
    }
}
export function DocFocusOrOpen(doc: Doc, collectionDoc?: Doc) {
    const cv = collectionDoc && DocumentManager.Instance.getDocumentView(collectionDoc);
    const dv = DocumentManager.Instance.getDocumentView(doc, (cv?.ComponentView as CollectionFreeFormView)?.props.CollectionView);
    if (dv && Doc.AreProtosEqual(dv.props.Document, doc)) {
        dv.props.focus(dv.props.Document, { willZoom: true });
        Doc.linkFollowHighlight(dv?.props.Document, false);
    }
    else {
        const context = doc.context !== Doc.UserDoc().myFilesystem && Cast(doc.context, Doc, null);
        const showDoc = context || doc;
        const bestAlias = showDoc === Doc.GetProto(showDoc) ? DocListCast(showDoc.aliases).find(doc => !doc.context && doc.author === Doc.CurrentUserEmail) : showDoc;

        CollectionDockingView.AddSplit(bestAlias ? bestAlias : Doc.MakeAlias(showDoc), "right") && context &&
            setTimeout(() => DocumentManager.Instance.getDocumentView(Doc.GetProto(doc))?.focus(doc));
    }
}
ScriptingGlobals.add(DocFocusOrOpen);