import { action, observable, observe } from "mobx";
import { computedFn } from "mobx-utils";
import { DirectLinksSym, Doc, DocListCast, DocListCastAsync, Field, Opt } from "../../fields/Doc";
import { List } from "../../fields/List";
import { ProxyField } from "../../fields/Proxy";
import { BoolCast, Cast, StrCast } from "../../fields/Types";
import { LightboxView } from "../views/LightboxView";
import { DocumentViewSharedProps, ViewAdjustment } from "../views/nodes/DocumentView";
import { DocumentManager } from "./DocumentManager";
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 LinkManager {

    @observable static _instance: LinkManager;
    @observable static userLinkDBs: Doc[] = [];
    public static currentLink: Opt<Doc>;
    public static get Instance() { return LinkManager._instance; }
    public static addLinkDB = (linkDb: any) => LinkManager.userLinkDBs.push(linkDb);
    public static AutoKeywords = "keywords:Usages";
    static links: Doc[] = [];
    constructor() {
        LinkManager._instance = this;
        this.createLinkrelationshipLists();
        LinkManager.userLinkDBs = [];
        const addLinkToDoc = (link: Doc) => {
            const a1Prom = link?.anchor1;
            const a2Prom = link?.anchor2;
            Promise.all([a1Prom, a2Prom]).then((all) => {
                const a1 = all[0];
                const a2 = all[1];
                const a1ProtoProm = (link?.anchor1 as Doc)?.proto;
                const a2ProtoProm = (link?.anchor2 as Doc)?.proto;
                Promise.all([a1ProtoProm, a2ProtoProm]).then(action((all) => {
                    if (a1 instanceof Doc && a2 instanceof Doc && ((a1.author !== undefined && a2.author !== undefined) || link.author === Doc.CurrentUserEmail)) {
                        Doc.GetProto(a1)[DirectLinksSym].add(link);
                        Doc.GetProto(a2)[DirectLinksSym].add(link);
                        Doc.GetProto(link)[DirectLinksSym].add(link);
                    }
                }));
            });
        };
        const remLinkFromDoc = (link: Doc) => {
            const a1 = link?.anchor1;
            const a2 = link?.anchor2;
            Promise.all([a1, a2]).then(action(() => {
                if (a1 instanceof Doc && a2 instanceof Doc && ((a1.author !== undefined && a2.author !== undefined) || link.author === Doc.CurrentUserEmail)) {
                    Doc.GetProto(a1)[DirectLinksSym].delete(link);
                    Doc.GetProto(a2)[DirectLinksSym].delete(link);
                    Doc.GetProto(link)[DirectLinksSym].delete(link);
                }
            }));
        };
        const watchUserLinkDB = (userLinkDBDoc: Doc) => {
            LinkManager.links.push(...DocListCast(userLinkDBDoc.data));
            const toRealField = (field: Field) => field instanceof ProxyField ? field.value() : field;  // see List.ts.  data structure is not a simple list of Docs, but a list of ProxyField/Fields
            observe(userLinkDBDoc.data as Doc, change => {  // observe pushes/splices on a user link DB 'data' field (should only happen for local changes)
                switch (change.type as any) {
                    case "splice":
                        (change as any).added.forEach((link: any) => addLinkToDoc(toRealField(link)));
                        (change as any).removed.forEach((link: any) => remLinkFromDoc(toRealField(link)));
                        break;
                    case "update": //let oldValue = change.oldValue;
                }
            }, true);
            observe(userLinkDBDoc, "data",  // obsever when a new array of links is assigned as the link DB 'data' field (should happen whenever a remote user adds/removes a link)
                change => {
                    switch (change.type as any) {
                        case "update":
                            Promise.all([...(change.oldValue as any as Doc[] || []), ...(change.newValue as any as Doc[] || [])]).then(doclist => {
                                const oldDocs = doclist.slice(0, (change.oldValue as any as Doc[] || []).length);
                                const newDocs = doclist.slice((change.oldValue as any as Doc[] || []).length, doclist.length);

                                const added = newDocs?.filter(link => !(oldDocs || []).includes(link));
                                const removed = oldDocs?.filter(link => !(newDocs || []).includes(link));
                                added?.forEach((link: any) => addLinkToDoc(toRealField(link)));
                                removed?.forEach((link: any) => remLinkFromDoc(toRealField(link)));
                            });
                    }
                }, true);
        };
        observe(LinkManager.userLinkDBs, change => {
            switch (change.type as any) {
                case "splice": (change as any).added.forEach(watchUserLinkDB); break;
                case "update": //let oldValue = change.oldValue;
            }
        }, true);
        LinkManager.addLinkDB(Doc.LinkDBDoc());
        DocListCastAsync(Doc.LinkDBDoc()?.data).then(dblist => dblist?.forEach(async link => { // make sure anchors are loaded to avoid incremental updates to computedFn's in LinkManager
            const a1 = await Cast(link?.anchor1, Doc, null);
            const a2 = await Cast(link?.anchor2, Doc, null);
        }));
    }


    public createLinkrelationshipLists = () => {
        //create new lists for link relations and their associated colors if the lists don't already exist
        !Doc.UserDoc().linkRelationshipList && (Doc.UserDoc().linkRelationshipList = new List<string>());
        !Doc.UserDoc().linkColorList && (Doc.UserDoc().linkColorList = new List<string>());
        !Doc.UserDoc().linkRelationshipSizes && (Doc.UserDoc().linkRelationshipSizes = new List<number>());
    }

    public addLink(linkDoc: Doc, checkExists = false) {
        if (!checkExists || !DocListCast(Doc.LinkDBDoc().data).includes(linkDoc)) {
            Doc.AddDocToList(Doc.LinkDBDoc(), "data", linkDoc);
        }
    }
    public deleteLink(linkDoc: Doc) { return Doc.RemoveDocFromList(Doc.LinkDBDoc(), "data", linkDoc); }
    public deleteAllLinksOnAnchor(anchor: Doc) { LinkManager.Instance.relatedLinker(anchor).forEach(linkDoc => LinkManager.Instance.deleteLink(linkDoc)); }

    public getAllRelatedLinks(anchor: Doc) { return this.relatedLinker(anchor); } // finds all links that contain the given anchor
    public getAllDirectLinks(anchor: Doc): Doc[] {
        // FIXME:glr Why is Doc undefined?
        if (Doc.GetProto(anchor)[DirectLinksSym]) {
            return Array.from(Doc.GetProto(anchor)[DirectLinksSym]);
        } else {
            return [];
        }
    } // finds all links that contain the given anchor

    relatedLinker = computedFn(function relatedLinker(this: any, anchor: Doc): Doc[] {
        const lfield = Doc.LayoutFieldKey(anchor);
        if (!anchor || anchor instanceof Promise || Doc.GetProto(anchor) instanceof Promise) {
            console.log("WAITING FOR DOC/PROTO IN LINKMANAGER");
            return [];
        }
        const dirLinks = Doc.GetProto(anchor)[DirectLinksSym];
        const annos = DocListCast(anchor[lfield + "-annotations"]);
        const timelineAnnos = DocListCast(anchor[lfield + "-annotations-timeline"]);
        if (!annos || !timelineAnnos) {
            debugger;
        }
        const related = [...annos, ...timelineAnnos].reduce((list, anno) =>
            [...list, ...LinkManager.Instance.relatedLinker(anno)],
            Array.from(dirLinks).slice());
        return related;
    }, true);

    // returns map of group type to anchor's links in that group type
    public getRelatedGroupedLinks(anchor: Doc): Map<string, Array<Doc>> {
        const anchorGroups = new Map<string, Array<Doc>>();
        this.relatedLinker(anchor).forEach(link => {
            if (link.linkRelationship && link.linkRelationship !== "-ungrouped-") {
                const relation = StrCast(link.linkRelationship);
                const anchorRelation = relation.indexOf(":") !== -1 ? relation.split(":")[Doc.AreProtosEqual(Cast(link.anchor1, Doc, null), anchor) ? 0 : 1] : relation;
                const group = anchorGroups.get(anchorRelation);
                anchorGroups.set(anchorRelation, group ? [...group, link] : [link]);
            } else {
                // if link is in no groups then put it in default group
                const group = anchorGroups.get("*");
                anchorGroups.set("*", group ? [...group, link] : [link]);
            }
        });
        return anchorGroups;
    }

    // finds the opposite anchor of a given anchor in a link
    //TODO This should probably return undefined if there isn't an opposite anchor
    //TODO This should also await the return value of the anchor so we don't filter out promises
    public static getOppositeAnchor(linkDoc: Doc, anchor: Doc): Doc | undefined {
        const a1 = Cast(linkDoc.anchor1, Doc, null);
        const a2 = Cast(linkDoc.anchor2, Doc, null);
        if (Doc.AreProtosEqual(anchor, a1)) return a2;
        if (Doc.AreProtosEqual(anchor, a2)) return a1;
        if (Doc.AreProtosEqual(anchor, a1.annotationOn as Doc)) return a2;
        if (Doc.AreProtosEqual(anchor, a2.annotationOn as Doc)) return a1;
        if (Doc.AreProtosEqual(anchor, linkDoc)) return linkDoc;
    }


    // 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, zoom: boolean = false) => {
        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 ? "lightbox" : StrCast(sourceDoc.followLinkLocation, followLoc);
                docViewProps.addDocTab(doc, where);
                setTimeout(() => {
                    const getFirstDocView = LightboxView.LightboxDoc ? DocumentManager.Instance.getLightboxDocumentView : DocumentManager.Instance.getFirstDocumentView;
                    const targDocView = getFirstDocView(doc); // get first document view available within the lightbox if that's open, or anywhere otherwise.
                    if (targDocView) {
                        targDocView.props.focus(doc, {
                            willZoom: BoolCast(sourceDoc.followLinkZoom, false),
                            afterFocus: (didFocus: boolean) => {
                                finished?.();
                                res(ViewAdjustment.resetView);
                                return new Promise<ViewAdjustment>(res2 => res2(ViewAdjustment.doNothing));
                            }
                        });
                    } else {
                        res(where !== "inPlace" ? ViewAdjustment.resetView : ViewAdjustment.doNothing); // for 'inPlace'  resetting the initial focus&zoom would negate the zoom into the target 
                    }
                });
            });

            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, { willZoom: BoolCast(sourceDoc.followLinkZoom, true), scale: 1, afterFocus: createTabForTarget });
            }
        };
        LinkManager.traverseLink(linkDoc, sourceDoc, createViewFunc, BoolCast(sourceDoc.followLinkZoom, zoom), docViewProps.ContainingCollectionDoc, batch.end, altKey ? true : undefined);
    }

    public static traverseLink(link: Opt<Doc>, sourceDoc: Doc, createViewFunc: CreateViewFunc, zoom = false, 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).length === 0);
        const backLinkWithoutTargetView = secondDocs.find(d => DocumentManager.Instance.getDocumentViews(d.anchor1 as Doc).length === 0);
        const linkWithoutTargetDoc = traverseBacklink === undefined ? fwdLinkWithoutTargetView || backLinkWithoutTargetView : traverseBacklink ? backLinkWithoutTargetView : fwdLinkWithoutTargetView;
        const linkDocList = linkWithoutTargetDoc ? [linkWithoutTargetDoc] : (traverseBacklink === undefined ? firstDocs.concat(secondDocs) : traverseBacklink ? secondDocs : firstDocs);
        const followLinks = sourceDoc.isPushpin ? linkDocList : linkDocList.slice(0, 1);
        var count = 0;
        const allFinished = () => ++count === followLinks.length && finished?.();
        followLinks.forEach(async linkDoc => {
            if (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) {
                    if (target.TourMap) {
                        const fieldKey = Doc.LayoutFieldKey(target);
                        const tour = DocListCast(target[fieldKey]).reverse();
                        LightboxView.SetLightboxDoc(currentContext, undefined, tour);
                        setTimeout(LightboxView.Next);
                        allFinished();
                    } else {
                        const containerAnnoDoc = Cast(target.annotationOn, Doc, null);
                        const containerDoc = containerAnnoDoc || target;
                        var containerDocContext = containerDoc?.context ? [Cast(containerDoc?.context, Doc, null)] : [] as Doc[];
                        while (containerDocContext.length && !DocumentManager.Instance.getDocumentView(containerDocContext[0]) && containerDocContext[0].context) {
                            containerDocContext = [Cast(containerDocContext[0].context, Doc, null), ...containerDocContext];
                        }
                        const targetContexts = LightboxView.LightboxDoc ? [containerAnnoDoc || containerDocContext[0]].filter(a => a) : containerDocContext;
                        DocumentManager.Instance.jumpToDocument(target, zoom, (doc, finished) => createViewFunc(doc, StrCast(linkDoc.followLinkLocation, "lightbox"), finished), targetContexts, linkDoc, undefined, sourceDoc, allFinished);
                    }
                } else {
                    allFinished();
                }
            } else {
                allFinished();
            }
        });
    }

}