import { StrCast, Cast } from "../../fields/Types";
import { SearchUtil } from "./SearchUtil";
import { action, runInAction } from "mobx";
import { Doc, Opt } from "../../fields/Doc";
import { DocumentType } from "../documents/DocumentTypes";
import { Docs } from "../documents/Documents";
import { SelectionManager } from "./SelectionManager";
import { WebField } from "../../fields/URLField";
import { DocumentManager } from "./DocumentManager";
import { DocumentLinksButton } from "../views/nodes/DocumentLinksButton";
import { simulateMouseClick, Utils } from "../../Utils";
import { DocumentView } from "../views/nodes/DocumentView";
import { Id } from "../../fields/FieldSymbols";

export namespace Hypothesis {

    /**
     * Retrieve a WebDocument with the given url, prioritizing results that are on screen.  
     * If none exist, create and return a new WebDocument.
     */
    export const getSourceWebDoc = async (uri: string) => {
        const result = await findWebDoc(uri);
        console.log(result ? "existing doc found" : "existing doc NOT found");
        return result || Docs.Create.WebDocument(uri, { title: uri, _nativeWidth: 850, _height: 512, _width: 400, useCors: true }); // create and return a new Web doc with given uri if no matching docs are found
    };


    /**
     * Search for a WebDocument whose url field matches the given uri, return undefined if not found
     */
    export const findWebDoc = async (uri: string) => {
        const currentDoc = SelectionManager.Docs().lastElement();
        if (currentDoc && Cast(currentDoc.data, WebField)?.url.href === uri) return currentDoc; // always check first whether the currently selected doc is the annotation's source, only use Search otherwise

        const results: Doc[] = [];
        await SearchUtil.Search("web", true).then(action(async (res: SearchUtil.DocSearchResult) => {
            const docs = res.docs;
            const filteredDocs = docs.filter(doc =>
                doc.author === Doc.CurrentUserEmail && doc.type === DocumentType.WEB && doc.data
            );
            filteredDocs.forEach(doc => {
                uri === Cast(doc.data, WebField)?.url.href && results.push(doc); // TODO check visited sites history? 
            });
        }));

        const onScreenResults = results.filter(doc => DocumentManager.Instance.getFirstDocumentView(doc));
        return onScreenResults.length ? onScreenResults[0] : (results.length ? results[0] : undefined); // prioritize results that are currently on the screen
    };

    /**
     * listen for event from Hypothes.is plugin to link an annotation to Dash
     */
    export const linkListener = async (e: any) => {
        const annotationId: string = e.detail.id;
        const annotationUri: string = StrCast(e.detail.uri).split("#annotations:")[0]; // clean hypothes.is URLs that reference a specific annotation 
        const sourceDoc: Doc = await getSourceWebDoc(annotationUri);

        if (!DocumentLinksButton.StartLink || sourceDoc === DocumentLinksButton.StartLink) { // start new link if there were none already started, or if the old startLink came from the same web document (prevent links to itself)
            runInAction(() => {
                DocumentLinksButton.AnnotationId = annotationId;
                DocumentLinksButton.AnnotationUri = annotationUri;
                DocumentLinksButton.StartLink = sourceDoc;
                DocumentLinksButton.StartLinkView = undefined;
            });
        } else { // if a link has already been started, complete the link to sourceDoc
            runInAction(() => {
                DocumentLinksButton.AnnotationId = annotationId;
                DocumentLinksButton.AnnotationUri = annotationUri;
            });
            const endLinkView = DocumentManager.Instance.getFirstDocumentView(sourceDoc);
            const rect = document.body.getBoundingClientRect();
            const x = rect.x + rect.width / 2;
            const y = 250;
            DocumentLinksButton.finishLinkClick(x, y, DocumentLinksButton.StartLink, sourceDoc, false, endLinkView);
        }
    };

    /**
     *  Send message to Hypothes.is client to edit an annotation to add a Dash hyperlink
     */
    export const makeLink = async (title: string, url: string, annotationId: string, annotationSourceDoc: Doc) => {
        // if the annotation's source webpage isn't currently loaded in Dash, we're not able to access and edit the annotation from the client
        // so we're loading the webpage and its annotations invisibly in a WebBox in MainView.tsx, until the editing is done
        !DocumentManager.Instance.getFirstDocumentView(annotationSourceDoc) && runInAction(() => DocumentLinksButton.invisibleWebDoc = annotationSourceDoc);

        var success = false;
        const onSuccess = action(() => {
            console.log("Edit success!!");
            success = true;
            clearTimeout(interval);
            DocumentLinksButton.invisibleWebDoc = undefined;
            document.removeEventListener("editSuccess", onSuccess);
        });

        const newHyperlink = `[${title}\n](${url})`;
        const interval = setInterval(() => // keep trying to edit until annotations have loaded and editing is successful
            !success && document.dispatchEvent(new CustomEvent<{ newHyperlink: string, id: string }>("addLink", {
                detail: { newHyperlink: newHyperlink, id: annotationId },
                bubbles: true
            })), 300);

        setTimeout(action(() => {
            if (!success) {
                clearInterval(interval);
                DocumentLinksButton.invisibleWebDoc = undefined;
            }
        }), 10000); // give up if no success after 10s
        document.addEventListener("editSuccess", onSuccess);
    };

    /**
     * Send message Hypothes.is client request to edit an annotation to find and delete the target Dash hyperlink
     */
    export const deleteLink = async (linkDoc: Doc, sourceDoc: Doc, destinationDoc: Doc) => {
        if (Cast(destinationDoc.data, WebField)?.url.href !== StrCast(linkDoc.annotationUri)) return; // check that the destinationDoc is a WebDocument containing the target annotation

        !DocumentManager.Instance.getFirstDocumentView(destinationDoc) && runInAction(() => DocumentLinksButton.invisibleWebDoc = destinationDoc); // see note in makeLink

        var success = false;
        const onSuccess = action(() => {
            console.log("Edit success!");
            success = true;
            clearTimeout(interval);
            DocumentLinksButton.invisibleWebDoc = undefined;
            document.removeEventListener("editSuccess", onSuccess);
        });

        const annotationId = StrCast(linkDoc.annotationId);
        const linkUrl = Doc.globalServerPath(sourceDoc);
        const interval = setInterval(() => {// keep trying to edit until annotations have loaded and editing is successful
            !success && document.dispatchEvent(new CustomEvent<{ targetUrl: string, id: string }>("deleteLink", {
                detail: { targetUrl: linkUrl, id: annotationId },
                bubbles: true
            }));
        }, 300);

        setTimeout(action(() => {
            if (!success) {
                clearInterval(interval);
                DocumentLinksButton.invisibleWebDoc = undefined;
            }
        }), 10000); // give up if no success after 10s
        document.addEventListener("editSuccess", onSuccess);
    };

    /**
     *  Send message to Hypothes.is client to scroll to an annotation when it loads
     */
    export const scrollToAnnotation = (annotationId: string, target: Doc) => {
        var success = false;
        const onSuccess = () => {
            console.log("Scroll success!!");
            document.removeEventListener('scrollSuccess', onSuccess);
            clearInterval(interval);
            success = true;
        };

        const interval = setInterval(() => { // keep trying to scroll every 250ms until annotations have loaded and scrolling is successful
            document.dispatchEvent(new CustomEvent('scrollToAnnotation', {
                detail: annotationId,
                bubbles: true
            }));
            const targetView: Opt<DocumentView> = DocumentManager.Instance.getFirstDocumentView(target);
            const position = targetView?.props.ScreenToLocalTransform().inverse().transformPoint(0, 0);
            targetView && position && simulateMouseClick(targetView.ContentDiv!, position[0], position[1], position[0], position[1], false);
        }, 300);

        document.addEventListener('scrollSuccess', onSuccess); // listen for success message from client
        setTimeout(() => !success && clearInterval(interval), 10000); // give up if no success after 10s
    };
}