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 { Cast, StrCast } from '../../fields/Types';
/*
 * 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[] = [];
    @observable public static currentLink: Opt<Doc>;
    @observable public static currentLinkAnchor: 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);
                        }
                    })
                );
            });
        };
        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
            if (userLinkDBDoc.data) {
                observe(
                    userLinkDBDoc.data,
                    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[] {
        return Array.from(Doc.GetProto(anchor)[DirectLinksSym] ?? []);
    } // 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;
    }
}