import { Autocomplete, GoogleMap, GoogleMapProps, InfoWindow, Marker } from '@react-google-maps/api';
import { action, computed, IReactionDisposer, observable, ObservableMap } from 'mobx';
import { observer } from "mobx-react";
import * as React from "react";
import { DataSym, Doc, DocListCast, FieldsSym, Opt, WidthSym } from '../../../../fields/Doc';
import { documentSchema } from '../../../../fields/documentSchemas';
import { makeInterface } from '../../../../fields/Schema';
import { NumCast, StrCast } from '../../../../fields/Types';
import { emptyFunction, OmitKeys, returnEmptyDoclist, returnEmptyFilter, returnFalse, returnOne, returnZero, setupMoveUpEvents, Utils } from '../../../../Utils';
import { Docs, DocUtils } from '../../../documents/Documents';
import { DragManager } from '../../../util/DragManager';
import { ViewBoxAnnotatableComponent, ViewBoxAnnotatableProps } from '../../DocComponent';
import { AnchorMenu } from '../../pdf/AnchorMenu';
import { SidebarAnnos } from '../../SidebarAnnos';
import { StyleProp } from '../../StyleProvider';
import { FieldView, FieldViewProps } from '../FieldView';
import "./MapBox.scss";
import { MapMarker } from './MapMarker';
import { DocumentType } from '../../../documents/DocumentTypes';
import { identity } from 'lodash';
import { Id } from '../../../../fields/FieldSymbols';
import { Colors } from '../../global/globalEnums';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { TraceMobx } from '../../../../fields/util';
import { SnappingManager } from '../../../util/SnappingManager';
import { InkTool } from '../../../../fields/InkField';
import { CurrentUserUtils } from '../../../util/CurrentUserUtils';
import { CollectionFreeFormView, MarqueeOptionsMenu } from '../../collections/collectionFreeForm';
import { MarqueeAnnotator } from '../../MarqueeAnnotator';
import { Annotation } from '../../pdf/Annotation';
import { DocumentView } from '../DocumentView';
import { Transform } from '../../../util/Transform';
const _global = (window /* browser */ || global /* node */) as any;

type MapDocument = makeInterface<[typeof documentSchema]>;
const MapDocument = makeInterface(documentSchema);

export type Coordinates = {
    lat: number,
    lng: number,
}

export type LocationData = {
    id: string;
    pos: Coordinates;
};

const mapContainerStyle = {
    height: '100%',
};

const defaultCenter = {
    lat: 38.685,
    lng: -115.234,
};

const mapOptions = {
    fullscreenControl: false,
}

const drawingManager = new google.maps.drawing.DrawingManager({
    drawingControl: true,
    drawingControlOptions: {
        position: google.maps.ControlPosition.TOP_RIGHT,
        drawingModes: [
            google.maps.drawing.OverlayType.MARKER,
            // currently we are not supporting the following drawing mode on map, a thought for future development
            // google.maps.drawing.OverlayType.CIRCLE,
            // google.maps.drawing.OverlayType.POLYLINE,
        ],
    },
});


const options = {
    fields: ["formatted_address", "geometry", "name"], // note: level of details is charged by item per retrieval, not recommended to return all fields
    strictBounds: false,
    types: ["establishment"], // type pf places, subject of change according to user need
} as google.maps.places.AutocompleteOptions;

@observer
export class MapBox extends ViewBoxAnnotatableComponent<ViewBoxAnnotatableProps & FieldViewProps & Partial<GoogleMapProps>, MapDocument>(MapDocument) {
    private _dropDisposer?: DragManager.DragDropDisposer;
    private _disposers: { [name: string]: IReactionDisposer } = {};
    private _annotationLayer: React.RefObject<HTMLDivElement> = React.createRef();
    @observable private _overlayAnnoInfo: Opt<Doc>;
    showInfo = action((anno: Opt<Doc>) => this._overlayAnnoInfo = anno);
    @observable _windowWidth: number = 0;
    @observable _windowHeight: number = 0;
    public static LayoutString(fieldKey: string) { return FieldView.LayoutString(MapBox, fieldKey); }
    public get SidebarKey() { return this.fieldKey + "-sidebar"; }
    private _setPreviewCursor: undefined | ((x: number, y: number, drag: boolean, hide: boolean) => void);
    @computed get inlineTextAnnotations() { return this.allMapMarkers.filter(a => a.textInlineAnnotations); }

    @observable private _map: google.maps.Map = null as unknown as google.maps.Map;
    @observable private selectedPlace: Doc | undefined;
    @observable private markerMap: { [id: string]: google.maps.Marker } = {};
    @observable private markerIdToMapMarker: { [id: string]: Doc | MapMarker | undefined } = {};
    @observable private center = navigator.geolocation ? navigator.geolocation.getCurrentPosition : defaultCenter;
    @observable private zoom = 2.5;
    @observable private infoWindowOpen = false;
    @observable private _marqueeing: number[] | undefined;
    @observable private _isAnnotating = false;
    @observable private bounds = new window.google.maps.LatLngBounds();
    @observable private inputRef = React.createRef<HTMLInputElement>();
    @observable private searchMarkers: google.maps.Marker[] = [];
    @observable private searchBox = new window.google.maps.places.Autocomplete(this.inputRef.current!, options);
    @observable private _savedAnnotations = new ObservableMap<number, HTMLDivElement[]>();
    @computed get allSidebarDocs() { return DocListCast(this.dataDoc[this.SidebarKey]); };
    @computed get allMapMarkers() { return DocListCast(this.dataDoc[this.annotationKey]); }; // method to add MapMarker to allMapMarkers
    //TODO: change all markers to a filter function to change 
    @observable private toggleAddMarker = false;

    private _mainCont: React.RefObject<HTMLDivElement> = React.createRef();


    @observable _showSidebar = false;
    @computed get SidebarShown() { return this._showSidebar || this.layoutDoc._showSidebar ? true : false; }

    static _canAnnotate = true;
    static _hadSelection: boolean = false;
    private _sidebarRef = React.createRef<SidebarAnnos>();
    private _ref: React.RefObject<HTMLDivElement> = React.createRef();

    constructor(props: any) {
        super(props);
    }

    @action
    private setSearchBox = (searchBox: any) => {
        this.searchBox = searchBox;
    }

    // iterate allMarkers to size, center, and zoom map to contain all markers
    private fitBounds = (map: google.maps.Map) => {
        console.log('map bound is:' + this.bounds);
        this.allMapMarkers.map(place => {
            this.bounds.extend({ lat: NumCast(place.lat), lng: NumCast(place.lng) });
        });
        map.fitBounds(this.bounds)
    }

    /**
     * Custom control for add marker button
     * @param controlDiv 
     * @param map 
     */
    private CenterControl = (controlDiv: Element) => {
        // Set CSS for the control border.
        const controlUI = document.createElement("div");

        controlUI.style.backgroundColor = "#fff";
        controlUI.style.border = "2px solid #fff";
        controlUI.style.borderRadius = "3px";
        controlUI.style.cursor = "pointer";
        controlUI.style.marginTop = "8px";
        controlUI.style.marginBottom = "22px";
        controlUI.style.textAlign = "center";
        controlUI.title = "Click to add marker to the location your pointer is at";
        controlDiv.appendChild(controlUI);

        // Set CSS for the control interior.
        const controlText = document.createElement("div");

        controlText.style.color = "rgb(25,25,25)";
        controlText.style.fontFamily = "Roboto,Arial,sans-serif";
        controlText.style.fontSize = "16px";
        controlText.style.lineHeight = "38px";
        controlText.style.paddingLeft = "5px";
        controlText.style.paddingRight = "5px";
        controlText.innerHTML = "Add Marker";
        controlUI.appendChild(controlText);

        // Setup the click event listeners
        controlUI.addEventListener("click", () => {
            if (this.toggleAddMarker == true) {
                this.toggleAddMarker = false;
                console.log("add marker button status:" + this.toggleAddMarker);
                controlUI.style.backgroundColor = "#fff";
                controlText.style.color = "rgb(25,25,25)";
            } else {
                this.toggleAddMarker = true;
                console.log("add marker button status:" + this.toggleAddMarker);
                controlUI.style.backgroundColor = "#4476f7";
                controlText.style.color = "rgb(255,255,255)";
            };
        });
    }

    /**
     * Place the marker on google maps & store the empty marker as a MapMarker Document in allMarkers list
     * @param position - the LatLng position where the marker is placed
     * @param map 
     */
    @action
    private placeMarker = (position: google.maps.LatLng, map: google.maps.Map) => {
        const marker = new google.maps.Marker({
            position: position,
            map: map
        });
        map.panTo(position);
        const mapMarker = Docs.Create.MapMarkerDocument(NumCast(position.lat()), NumCast(position.lng()), [], {});
        this.addDocument(mapMarker, this.annotationKey);
    }


    /**
     * store a reference to google map instance
     * setup the drawing manager on the top right corner of map
     * fit map bounds to contain all markers 
     * @param map 
     */
    @action
    private loadHandler = (map: google.maps.Map) => {
        this._map = map;
        const centerControlDiv = document.createElement("div");
        this.CenterControl(centerControlDiv);
        map.controls[google.maps.ControlPosition.TOP_RIGHT].push(centerControlDiv);
        //drawingManager.setMap(map);
        if (navigator.geolocation) {
            navigator.geolocation.getCurrentPosition(
                (position: GeolocationPosition) => {
                    const pos = {
                        lat: position.coords.latitude,
                        lng: position.coords.longitude,
                    };
                    this._map.setCenter(pos);
                }
            );
        } else {
            alert("Your geolocation is not supported by browser.")
        };
        console.log("all sidebar docs during map loading is:")
        console.log(this.allSidebarDocs);
        this.fitBounds(map);


        // listener to addmarker event
        this._map.addListener('click', (e) => {
            console.log("add marker map status:" + this.toggleAddMarker);
            if (this.toggleAddMarker == true) {
                this.placeMarker(e.latLng, map)
                console.log(this.allMapMarkers)
            }
        })
        // this._map.addListener(drawingManager, 'markercomplete', this.addMarker)
    }

    @action
    private markerLoadHandler = (marker: google.maps.Marker, place: Doc) => {
        place[Id] ? this.markerMap[place[Id]] = marker : null;
        place[Id] ? this.markerIdToMapMarker[place[Id]] = place : null;

        console.log("the following is a markerMap from id to Marker:")
        console.log(this.markerMap);
    }

    @action
    private markerClickHandler = (e: MouseEvent, place: Doc) => {
        // set which place was clicked
        this.selectedPlace = place;

        console.log("you have selected this location:");
        console.log(this.selectedPlace);

        // used so clicking a second marker works
        if (this.infoWindowOpen) {
            this.infoWindowOpen = false;
            console.log("closeinfowindow")
        }
        this.infoWindowOpen = true;
        console.log("open infowindow")
    }

    /**
     * Called when dragging documents into map sidebar
     * @param doc 
     * @param sidebarKey 
     * @returns 
     */
    sidebarAddDocument = (doc: Doc | Doc[], sidebarKey?: string) => {
        console.log("print all sidebar Docs");
        console.log(this.allSidebarDocs);
        if (!this.layoutDoc._showSidebar) this.toggleSidebar();
        const docs = doc instanceof Doc ? [doc] : doc
        docs.forEach(doc => {
            if (doc.lat !== undefined && doc.lng !== undefined) {
                const marker = Docs.Create.MapMarkerDocument(NumCast(doc.lat), NumCast(doc.lng), [doc], {})
                this.addDocument(marker, this.annotationKey)
            }
        }) //add to annotation list
        console.log("sidebaraddDocument");
        console.log(doc);

        return this.addDocument(doc, sidebarKey); // add to sidebar list
    }

    sidebarRemoveDocument = (doc: Doc | Doc[], sidebarKey?: string) => {
        if (this.layoutDoc._showSidebar) this.toggleSidebar();
        const docs = doc instanceof Doc ? [doc] : doc;
        docs.forEach(doc => {
            console.log(this.allMapMarkers);
            console.log(this.allSidebarDocs);
        })
        return this.removeDocument(doc, sidebarKey);
    }

    /**
     * Toggle sidebar onclick the tiny comment button on the top right corner
     * @param e 
     */
    sidebarBtnDown = (e: React.PointerEvent) => {
        setupMoveUpEvents(this, e, (e, down, delta) => {
            const localDelta = this.props.ScreenToLocalTransform().scale(this.props.scaling?.() || 1).transformDirection(delta[0], delta[1]);
            const nativeWidth = NumCast(this.layoutDoc[this.fieldKey + "-nativeWidth"]);
            const curNativeWidth = NumCast(this.layoutDoc.nativeWidth, nativeWidth);
            const ratio = (curNativeWidth + localDelta[0] / (this.props.scaling?.() || 1)) / nativeWidth;
            if (ratio >= 1) {
                this.layoutDoc.nativeWidth = nativeWidth * ratio;
                this.layoutDoc._width = this.layoutDoc[WidthSym]() + localDelta[0];
                this.layoutDoc._showSidebar = nativeWidth !== this.layoutDoc._nativeWidth;
            }
            return false;
        }, emptyFunction, this.toggleSidebar);
    }

    sidebarWidth = () => Number(this.sidebarWidthPercent.substring(0, this.sidebarWidthPercent.length - 1)) / 100 * this.props.PanelWidth();
    @computed get sidebarWidthPercent() { return StrCast(this.layoutDoc._sidebarWidthPercent, "0%"); }
    @computed get sidebarColor() { return StrCast(this.layoutDoc.sidebarColor, StrCast(this.layoutDoc[this.props.fieldKey + "-backgroundColor"], "#e4e4e4")); }


    /**
     * function that reads the place inputed from searchbox, then zoom in on the location that's been autocompleted;
     * add a customized temporary marker on the map
     */
    @action
    private handlePlaceChanged = () => {
        console.log(this.searchBox);
        const place = this.searchBox.getPlace();

        if (!place.geometry || !place.geometry.location) {
            // user entered the name of a place that wasn't suggested & pressed the enter key, or place details request failed
            window.alert("No details available for input: '" + place.name + "'");
            return;
        }

        // zoom in on the location of the search result
        if (place.geometry.viewport) {
            console.log(this._map);
            this._map.fitBounds(place.geometry.viewport);
        } else {
            console.log(this._map);
            this._map.setCenter(place.geometry.location);
            this._map.setZoom(17);
        }

        // customize icon => customized icon for the nature of the location selected
        const icon = {
            url: place.icon as string,
            size: new google.maps.Size(71, 71),
            origin: new google.maps.Point(0, 0),
            anchor: new google.maps.Point(17, 34),
            scaledSize: new google.maps.Size(25, 25),
        };

        // put temporary cutomized marker on searched location
        this.searchMarkers.forEach((marker) => {
            marker.setMap(null);
        });
        this.searchMarkers = [];
        this.searchMarkers.push(
            new window.google.maps.Marker({
                map: this._map,
                icon,
                title: place.name,
                position: place.geometry.location,
            })
        )
    }


    @action
    private handleInfoWindowClose = () => {
        if (this.infoWindowOpen) {
            this.infoWindowOpen = false;
        }
        this.infoWindowOpen = false;
        this.selectedPlace = undefined;
    }

    @computed get sidebarHandle() {
        TraceMobx();
        const annotated = DocListCast(this.dataDoc[this.SidebarKey]).filter(d => d?.author).length;
        const color = !annotated ? Colors.WHITE : Colors.BLACK;
        const backgroundColor = !annotated ? this.sidebarWidth() ? Colors.MEDIUM_BLUE : Colors.BLACK : this.props.styleProvider?.(this.rootDoc, this.props as any, StyleProp.WidgetColor + (annotated ? ":annotated" : ""));
        return (!annotated) ? (null) :
            <div className="formattedTextBox-sidebar-handle" onPointerDown={this.sidebarDown}
                style={{
                    left: `max(0px, calc(100% - ${this.sidebarWidthPercent} - 17px))`,
                    backgroundColor: backgroundColor,
                    color: color,
                    opacity: annotated ? 1 : undefined
                }} >
                <FontAwesomeIcon icon={"comment-alt"} />
            </div>;
    }

    @action
    toggleSidebar = () => {
        const prevWidth = this.sidebarWidth();
        this.layoutDoc._showSidebar = ((this.layoutDoc._sidebarWidthPercent = StrCast(this.layoutDoc._sidebarWidthPercent, "0%") === "0%" ? "50%" : "0%")) !== "0%";
        this.layoutDoc._width = this.layoutDoc._showSidebar ? NumCast(this.layoutDoc._width) * 2 : Math.max(20, NumCast(this.layoutDoc._width) - prevWidth);
    }

    sidebarDown = (e: React.PointerEvent) => {
        setupMoveUpEvents(this, e, this.sidebarMove, emptyFunction, () => setTimeout(this.toggleSidebar), false);
    }
    sidebarMove = (e: PointerEvent, down: number[], delta: number[]) => {
        const bounds = this._ref.current!.getBoundingClientRect();
        this.layoutDoc._sidebarWidthPercent = "" + 100 * Math.max(0, (1 - (e.clientX - bounds.left) / bounds.width)) + "%";
        this.layoutDoc._showSidebar = this.layoutDoc._sidebarWidthPercent !== "0%";
        e.preventDefault();
        return false;
    }

    setPreviewCursor = (func?: (x: number, y: number, drag: boolean, hide: boolean) => void) => this._setPreviewCursor = func;

    @action
    onMarqueeDown = (e: React.PointerEvent) => {
        if (!e.altKey && e.button === 0 && this.props.isContentActive(true) && ![InkTool.Highlighter, InkTool.Pen].includes(CurrentUserUtils.SelectedTool)) {
            setupMoveUpEvents(this, e, action(e => {
                MarqueeAnnotator.clearAnnotations(this._savedAnnotations);
                this._marqueeing = [e.clientX, e.clientY];
                return true;
            }), returnFalse, () => MarqueeAnnotator.clearAnnotations(this._savedAnnotations), false);
        }
    }
    @action finishMarquee = (x?: number, y?: number) => {
        this._marqueeing = undefined;
        this._isAnnotating = false;
        x !== undefined && y !== undefined && this._setPreviewCursor?.(x, y, false, false);
    }

    addDocumentWrapper = (doc: Doc | Doc[], annotationKey?: string) => {
        return this.addDocument(doc, annotationKey);
    }

    pointerEvents = () => this.props.isContentActive() && this.props.pointerEvents !== "none" && !MarqueeOptionsMenu.Instance.isShown() ? "all" : SnappingManager.GetIsDragging() ? undefined : "none";

    @computed get annotationLayer() {
        TraceMobx();
        const pe = this.pointerEvents();
        return <div className="mapBox-annotationLayer" style={{ height: Doc.NativeHeight(this.Document) || undefined }} ref={this._annotationLayer}>
            {this.inlineTextAnnotations.sort((a, b) => NumCast(a.y) - NumCast(b.y)).map(anno =>
                <Annotation {...this.props} fieldKey={this.annotationKey} pointerEvents={pe} showInfo={this.showInfo} dataDoc={this.dataDoc} anno={anno} key={`${anno[Id]}-annotation`} />)}
        </div>;

    }


    getAnchor = () => {
        const anchor =
            AnchorMenu.Instance?.GetAnchor(this._savedAnnotations) ??
            this.rootDoc // if anchormenu pops up else return rootDoc (map)
        // Docs.Create.MapMarkerDocument(this.allMapMarkers, {
        //     title: StrCast(this.rootDoc.title + " " + this.layoutDoc._scrollTop),
        //     annotationOn: this.rootDoc,
        //     y: NumCast(this.layoutDoc._scrollTop),
        // });
        // this.addDocument(anchor);
        return anchor;
    }

    //documentView 
    private renderChildDocs = (selectedDoc: Doc) => {
        console.log("markerIdToMapMarker is:")
        console.log(this.markerIdToMapMarker);
        return <div>
            {DocListCast(selectedDoc.data).map(doc =>
                <DocumentView
                    key={doc[Id]}
                    Document={doc}
                    moveDocument={returnFalse}
                    rootSelected={returnFalse}
                    styleProvider={this.props.styleProvider}
                    layerProvider={this.props.layerProvider}
                    docViewPath={returnEmptyDoclist}
                    ScreenToLocalTransform={Transform.Identity}
                    isDocumentActive={returnFalse}
                    isContentActive={returnFalse}
                    addDocument={returnFalse}
                    removeDocument={returnFalse}
                    addDocTab={returnFalse}
                    pinToPres={returnFalse}
                    dontRegisterView={true}
                    docFilters={returnEmptyFilter}
                    docRangeFilters={returnEmptyFilter}
                    searchFilterDocs={returnEmptyDoclist}
                    ContainingCollectionDoc={undefined}
                    ContainingCollectionView={undefined}
                    renderDepth={-1}
                    //TODO
                    PanelWidth={() => this._windowWidth}
                    PanelHeight={() => this._windowHeight || 200}
                    focus={DocUtils.DefaultFocus}
                    whenChildContentsActiveChanged={returnFalse}
                    bringToFront={returnFalse}
                    //TODO
                    NativeWidth={Doc.NativeWidth(doc) ? () => Doc.NativeWidth(doc) : undefined}
                    NativeHeight={Doc.NativeHeight(doc) ? () => Doc.NativeHeight(doc) : undefined}
                />
            )}
        </div>


    }

    /**
     * render contents in allMapMarkers (e.g. images with exifData) into google maps as map marker
     * @returns 
     */
    private renderMarkers = () => {
        return this.allMapMarkers.map(place => (
            <Marker
                key={place[Id]}
                position={{ lat: NumCast(place.lat), lng: NumCast(place.lng) }}
                onLoad={marker => this.markerLoadHandler(marker, place)}
                onClick={e => this.markerClickHandler(e, place)}
            />
        ))
    }

    private renderInfoWindow = () => {
        return this.infoWindowOpen && this.selectedPlace && (
            <InfoWindow
                anchor={this.markerMap[this.selectedPlace[Id]]}
                onCloseClick={this.handleInfoWindowClose}
            >
                <div className="mapbox-infowindow" style={{ backgroundColor: 'white', opacity: 0.75, padding: 12, fontSize: 17 }} ref={r => {
                    r && new _global.ResizeObserver(action(() => {
                        this._windowWidth = r.getBoundingClientRect().width;
                        this._windowHeight = r.getBoundingClientRect().height;
                        console.log(r.getBoundingClientRect())
                    })).observe(r);
                }
                }>

                    {this.renderChildDocs(this.selectedPlace)}

                    <hr />
                    <form>
                        <label>Title: </label><br />
                        <input type="text" id="title" name="title"></input><br />
                        <label>Desription: </label><br />
                        <textarea style={{ height: 150 }} id="description" name="description" placeholder="Notes, a short description of this location, a brief comment, etc."></textarea>
                        <button type="submit">Save</button>
                    </form>
                    <hr />
                    <div>
                        <button>New link+</button>
                    </div>
                </div>
            </InfoWindow>
        )
    }

    panelWidth = () => this.props.PanelWidth() / (this.props.scaling?.() || 1) - this.sidebarWidth(); // (this.Document.scrollHeight || Doc.NativeHeight(this.Document) || 0);
    panelHeight = () => this.props.PanelHeight() / (this.props.scaling?.() || 1); // () => this._pageSizes.length && this._pageSizes[0] ? this._pageSizes[0].width : Doc.NativeWidth(this.Document);
    scrollXf = () => this.props.ScreenToLocalTransform().translate(0, NumCast(this.layoutDoc._scrollTop));
    transparentFilter = () => [...this.props.docFilters(), Utils.IsTransparentFilter()];
    opaqueFilter = () => [...this.props.docFilters(), Utils.IsOpaqueFilter()];

    anchorMenuClick = () => this._sidebarRef.current?.anchorMenuClick;

    render() {
        const renderAnnotations = (docFilters?: () => string[]) =>
            <CollectionFreeFormView {...OmitKeys(this.props, ["NativeWidth", "NativeHeight", "setContentView"]).omit}
                renderDepth={this.props.renderDepth + 1}
                isAnnotationOverlay={true}
                fieldKey={this.annotationKey}
                CollectionView={undefined}
                setPreviewCursor={this.setPreviewCursor}
                PanelWidth={this.panelWidth}
                PanelHeight={this.panelHeight}
                ScreenToLocalTransform={this.scrollXf}
                scaling={returnOne}
                dropAction={"alias"}
                docFilters={docFilters || this.props.docFilters}
                dontRenderDocuments={docFilters ? false : true}
                select={emptyFunction}
                ContentScaling={returnOne}
                bringToFront={emptyFunction}
                whenChildContentsActiveChanged={this.whenChildContentsActiveChanged}
                removeDocument={this.removeDocument}
                moveDocument={this.moveDocument}
                addDocument={this.sidebarAddDocument}
                childPointerEvents={true}
                pointerEvents={CurrentUserUtils.SelectedTool !== InkTool.None || this._isAnnotating || SnappingManager.GetIsDragging() ? "all" : "none"} />;
        return <div className="mapBox" ref={this._ref}
        // style={{ pointerEvents: this.isContentActive() ? undefined : "none" }} 
        >
            {/* // {/* <LoadScript
                //     googleMapsApiKey={process.env.GOOGLE_MAPS!}
                //     libraries={['places', 'drawing']}
                // >  */}
            <div className="mapBox-wrapper"
                onWheel={e => e.stopPropagation()}
                onPointerDown={e => (e.button === 0 && !e.ctrlKey) && e.stopPropagation()}
                style={{ width: `calc(100% - ${this.sidebarWidthPercent})` }}>

                <div style={{ mixBlendMode: "multiply" }}>
                    {renderAnnotations(this.transparentFilter)}
                </div>
                {renderAnnotations(this.opaqueFilter)}
                {SnappingManager.GetIsDragging() ? (null) : renderAnnotations()}
                {this.annotationLayer}
                <GoogleMap
                    mapContainerStyle={mapContainerStyle}
                    zoom={this.zoom}
                    onLoad={map => this.loadHandler(map)}
                    options={mapOptions}
                >
                    <Autocomplete
                        onLoad={this.setSearchBox}
                        onPlaceChanged={this.handlePlaceChanged}>
                        <input ref={this.inputRef} className="searchbox" type="text" placeholder="Search anywhere:" />
                    </Autocomplete>

                    {this.renderMarkers()}
                    {this.renderInfoWindow()}
                </GoogleMap>
                {!this._marqueeing || !this._mainCont.current || !this._annotationLayer.current ? (null) :
                    <MarqueeAnnotator rootDoc={this.rootDoc}
                        anchorMenuClick={this.anchorMenuClick}
                        scrollTop={0}
                        down={this._marqueeing} scaling={returnOne}
                        addDocument={this.addDocumentWrapper}
                        docView={this.props.docViewPath().lastElement()}
                        finishMarquee={this.finishMarquee}
                        savedAnnotations={this._savedAnnotations}
                        annotationLayer={this._annotationLayer.current}
                        mainCont={this._mainCont.current} />}
            </div>
            {/* {/* </LoadScript > */}
            <div className="mapBox-sidebar"
                style={{ width: `${this.sidebarWidthPercent}`, backgroundColor: `${this.sidebarColor}` }}>
                <SidebarAnnos ref={this._sidebarRef}
                    {...this.props}
                    fieldKey={this.fieldKey}
                    rootDoc={this.rootDoc}
                    layoutDoc={this.layoutDoc}
                    dataDoc={this.dataDoc}
                    showSidebar={this.SidebarShown}
                    nativeWidth={NumCast(this.layoutDoc._nativeWidth)}
                    whenChildContentsActiveChanged={this.whenChildContentsActiveChanged}
                    PanelWidth={this.sidebarWidth}
                    sidebarAddDocument={this.sidebarAddDocument}
                    moveDocument={this.moveDocument}
                    removeDocument={this.sidebarRemoveDocument}
                />
            </div>
            <div className="mapBox-overlayButton-sidebar" key="sidebar" title="Toggle Sidebar"
                style={{
                    display: !this.props.isContentActive() ? "none" : undefined,
                    top: StrCast(this.rootDoc._showTitle) === "title" ? 20 : 5,
                    backgroundColor: this.SidebarShown ? Colors.MEDIUM_BLUE : Colors.BLACK
                }}
                onPointerDown={this.sidebarBtnDown} >
                <FontAwesomeIcon style={{ color: Colors.WHITE }} icon={"comment-alt"} size="sm" />
            </div>
        </div>;
    }
}