import { action, runInAction } from 'mobx';
import { Doc, DocListCast, Opt } from '../../fields/Doc';
import { List } from '../../fields/List';
import { BoolCast, Cast, DocCast, NumCast, StrCast } from '../../fields/Types';
import { DocumentType } from '../documents/DocumentTypes';
import { CollectionFreeFormView } from '../views/collections/collectionFreeForm';
import { DocumentDecorations } from '../views/DocumentDecorations';
import { LightboxView } from '../views/LightboxView';
import { DocFocusOptions, DocumentViewSharedProps, OpenWhere, ViewAdjustment } from '../views/nodes/DocumentView';
import { PresBox } from '../views/nodes/trails';
import { DocumentManager } from './DocumentManager';
import { LinkManager } from './LinkManager';
import { SelectionManager } from './SelectionManager';
import { UndoManager } from './UndoManager';

type CreateViewFunc = (doc: Doc, followLinkLocation: string, finished?: () => void) => void;
/*
 * link doc:
 * - anchor1: doc
 * - anchor2: doc
 *
 * group doc:
 * - type: string representing the group type/name/category
 * - metadata: doc representing the metadata kvps
 *
 * metadata doc:
 * - user defined kvps
 */
export class LinkFollower {
    // follows a link - if the target is on screen, it highlights/pans to it.
    // if the target isn't onscreen, then it will open up the target in the lightbox, or in place
    // depending on the followLinkLocation property of the source (or the link itself as a fallback);
    public static FollowLink = (linkDoc: Opt<Doc>, sourceDoc: Doc, docViewProps: DocumentViewSharedProps, altKey: boolean) => {
        const batch = UndoManager.StartBatch('follow link click');
        // open up target if it's not already in view ...
        const createViewFunc = (doc: Doc, followLoc: string, finished?: Opt<() => void>) => {
            const createTabForTarget = (didFocus: boolean) =>
                new Promise<ViewAdjustment>(res => {
                    const where = LightboxView.LightboxDoc ? OpenWhere.lightbox : (StrCast(sourceDoc.followLinkLocation, followLoc) as OpenWhere);
                    const lightbox = where === OpenWhere.lightbox && DocumentManager.GetContextPath(doc).find(container => container.isLightbox && DocumentManager.Instance.getDocumentView(container));
                    const addDocTab = lightbox ? DocumentManager.Instance.getDocumentView(lightbox)?.ComponentView?.addDocTab : undefined;
                    (addDocTab ?? docViewProps.addDocTab)(doc, where);
                    setTimeout(() => {
                        const targDocView = DocumentManager.Instance.getFirstDocumentView(doc); // get first document view available within the lightbox if that's open, or anywhere otherwise.
                        if (targDocView) {
                            targDocView.props.focus(doc, {
                                willPan: true,
                                willPanZoom: BoolCast(sourceDoc.followLinkZoom, false),
                                afterFocus: (didFocus: boolean) => {
                                    finished?.();
                                    res(ViewAdjustment.resetView);
                                    return new Promise<ViewAdjustment>(res2 => res2(ViewAdjustment.doNothing));
                                },
                            });
                        } else {
                            finished?.();
                            res(BoolCast(sourceDoc.followLinkZoom) ? ViewAdjustment.resetView : ViewAdjustment.doNothing);
                        }
                    }, 100);
                });

            if (!sourceDoc.followLinkZoom) {
                createTabForTarget(false);
            } else {
                // first focus & zoom onto this (the clicked document).  Then execute the function to focus on the target
                docViewProps.focus(sourceDoc, { willPan: true, willPanZoom: BoolCast(sourceDoc.followLinkZoom, true), zoomTime: 1000, zoomScale: 1, afterFocus: createTabForTarget });
            }
        };
        runInAction(() => (DocumentDecorations.Instance.overrideBounds = true)); // turn off decoration bounds while following links since animations may occur, and DocDecorations is based on screenToLocal which is not always an observable value
        LinkFollower.traverseLink(
            linkDoc,
            sourceDoc,
            createViewFunc,
            docViewProps.ContainingCollectionDoc,
            action(() => {
                batch.end();
                Doc.AddUnHighlightWatcher(action(() => (DocumentDecorations.Instance.overrideBounds = false)));
            }),
            altKey ? true : undefined
        );
    };

    public static traverseLink(link: Opt<Doc>, sourceDoc: Doc, createViewFunc: CreateViewFunc, currentContext?: Doc, finished?: () => void, traverseBacklink?: boolean) {
        const linkDocs = link ? [link] : DocListCast(sourceDoc.links);
        const firstDocs = linkDocs.filter(linkDoc => Doc.AreProtosEqual(linkDoc.anchor1 as Doc, sourceDoc) || Doc.AreProtosEqual((linkDoc.anchor1 as Doc).annotationOn as Doc, sourceDoc)); // link docs where 'doc' is anchor1
        const secondDocs = linkDocs.filter(linkDoc => Doc.AreProtosEqual(linkDoc.anchor2 as Doc, sourceDoc) || Doc.AreProtosEqual((linkDoc.anchor2 as Doc).annotationOn as Doc, sourceDoc)); // link docs where 'doc' is anchor2
        const fwdLinkWithoutTargetView = firstDocs.find(d => DocumentManager.Instance.getDocumentViews((d.anchor2 as Doc).type === DocumentType.MARKER ? DocCast((d.anchor2 as Doc).annotationOn) : (d.anchor2 as Doc)).length === 0);
        const backLinkWithoutTargetView = secondDocs.find(d => DocumentManager.Instance.getDocumentViews((d.anchor1 as Doc).type === DocumentType.MARKER ? DocCast((d.anchor1 as Doc).annotationOn) : (d.anchor1 as Doc)).length === 0);
        const linkWithoutTargetDoc = traverseBacklink === undefined ? fwdLinkWithoutTargetView || backLinkWithoutTargetView : traverseBacklink ? backLinkWithoutTargetView : fwdLinkWithoutTargetView;
        const linkDocList = linkWithoutTargetDoc && !sourceDoc.followAllLinks ? [linkWithoutTargetDoc] : traverseBacklink === undefined ? firstDocs.concat(secondDocs) : traverseBacklink ? secondDocs : firstDocs;
        const followLinks = sourceDoc.followLinkToggle || sourceDoc.followAllLinks ? linkDocList : linkDocList.slice(0, 1);
        var count = 0;
        const allFinished = () => ++count === followLinks.length && finished?.();
        if (!followLinks.length) finished?.();
        followLinks.forEach(async linkDoc => {
            const target = (
                sourceDoc === linkDoc.anchor1
                    ? linkDoc.anchor2
                    : sourceDoc === linkDoc.anchor2
                    ? linkDoc.anchor1
                    : Doc.AreProtosEqual(sourceDoc, linkDoc.anchor1 as Doc) || Doc.AreProtosEqual((linkDoc.anchor1 as Doc).annotationOn as Doc, sourceDoc)
                    ? linkDoc.anchor2
                    : linkDoc.anchor1
            ) as Doc;
            if (target) {
                const doFollow = (canToggle?: boolean) => {
                    const options: DocFocusOptions = {
                        playAudio: BoolCast(sourceDoc.followLinkAudio),
                        toggleTarget: canToggle && BoolCast(sourceDoc.followLinkToggle),
                        willPan: true,
                        willPanZoom: BoolCast(sourceDoc.followLinkZoom, false),
                        zoomTime: NumCast(sourceDoc.followLinkTransitionTime, 500),
                        zoomScale: Cast(sourceDoc.followLinkZoomScale, 'number', null),
                        easeFunc: StrCast(sourceDoc.followLinkEase, 'ease') as any,
                        openInLightbox: sourceDoc.followLinkLocation === OpenWhere.lightbox,
                        effect: sourceDoc,
                        originatingDoc: sourceDoc,
                        zoomTextSelections: BoolCast(sourceDoc.followLinkZoomText),
                    };
                    if (target.type === DocumentType.PRES) {
                        const containerDocContext = DocumentManager.GetContextPath(sourceDoc, true); // gather all views that affect layout of sourceDoc so we can revert them after playing the rail
                        SelectionManager.DeselectAll();
                        if (!DocumentManager.Instance.AddViewRenderedCb(target, dv => containerDocContext.length && (dv.ComponentView as PresBox).PlayTrail(containerDocContext))) {
                            PresBox.OpenPresMinimized(target, [0, 0]);
                        }
                        finished?.();
                    } else {
                        const containerDocContext = DocumentManager.GetContextPath(target);
                        const targetContexts = !sourceDoc.followLinkToOuterContext && containerDocContext.length ? [containerDocContext.lastElement()] : containerDocContext;
                        DocumentManager.Instance.jumpToDocument(target, options, (doc, finished) => createViewFunc(doc, StrCast(linkDoc.followLinkLocation, OpenWhere.lightbox), finished), targetContexts, allFinished);
                    }
                };
                let movedTarget = false;
                if (sourceDoc.followLinkLocation === OpenWhere.inParent) {
                    const sourceDocParent = DocCast(sourceDoc.context);
                    if (target.context instanceof Doc && target.context !== sourceDocParent) {
                        Doc.RemoveDocFromList(target.context, Doc.LayoutFieldKey(target.context), target);
                        movedTarget = true;
                    }
                    if (!DocListCast(sourceDocParent[Doc.LayoutFieldKey(sourceDocParent)]).includes(target)) {
                        Doc.AddDocToList(sourceDocParent, Doc.LayoutFieldKey(sourceDocParent), target);
                        movedTarget = true;
                    }
                    target.context = sourceDocParent;
                    const moveTo = [NumCast(sourceDoc.x) + NumCast(sourceDoc.followLinkXoffset), NumCast(sourceDoc.y) + NumCast(sourceDoc.followLinkYoffset)];
                    if (sourceDoc.followLinkXoffset !== undefined && moveTo[0] !== target.x) {
                        target.x = moveTo[0];
                        movedTarget = true;
                    }
                    if (sourceDoc.followLinkYoffset !== undefined && moveTo[1] !== target.y) {
                        target.y = moveTo[1];
                        movedTarget = true;
                    }
                    if (movedTarget) setTimeout(doFollow);
                    else doFollow(true);
                } else doFollow(true);
            } else {
                allFinished();
            }
        });
    }
}