/// <reference path="./ContextUtil.js" />


Agility.RegisterNamespace("Subaru.MapUtils");

(function(MapUtils) {


    MapUtils.map = null;
    MapUtils._mapDivID = null;
    MapUtils.MinZoomLevelForActivities = 3;
    MapUtils.DataRecordOffset = 0;
    MapUtils.MaxRecordsPerCall = 25;
    MapUtils.MinZoomLevelForActivities = 16;
    MapUtils.ModeIsPreview = false;
    MapUtils.MapMode = "Default";


    MapUtils.TopLeft = null;
    MapUtils.TopRight = null;
    MapUtils.BottomLeft = null;
    MapUtils.BottomRight = null;
    MapUtils.NotHereLayer = null;
    MapUtils.ActivityPointLayer = null;

    MapUtils.NotHereImageUrl = null;

    MapUtils.LoadedActivities = new Array();
    MapUtils.RouteLayer = null;
    MapUtils.ClickedShape = null;
    MapUtils.SelectedActivityID = null;
    MapUtils.ClientToken = null;
    MapUtils.IsFirstLoad = true;


    MapUtils.MapEdge =
        {
            TopLeft: 0,
            TopRight: 1,
            BottomLeft: 2,
            BottomRight: 3
        };

    MapUtils.GetMap = function() {
        return MapUtils.map;
    }

    MapUtils.GetMapDiv = function() {
        if (MapUtils._mapDivID != null) {
            return $("#" + MapUtils._mapDivID);
        }
        return null;
    }

    var _mapLoaded = false;

    MapUtils.InitializeMap = function(divName, isPreview, notHereImageURL, clientToken) {

        MapUtils._mapDivID = divName;

        MapUtils.ModeIsPreview = isPreview;
        MapUtils.NotHereImageUrl = notHereImageURL;
        MapUtils.SetMapHeight(MapUtils.ModeIsPreview);
        $(window).bind("resize", MapUtils.resizeWindow);
        MapUtils.ClientToken = clientToken;

        Subaru.AgilityData.LoadContentItem("MapSettings", MapUtils.MapSettingsCallback);
    };

    MapUtils.MapSettingsCallback = function(data) {

        MapUtils.MinZoomLevelForActivities = Subaru.AgilityData.FindContentItemProperty(data, "MinimumZoomLevel");
        MapUtils.MaxRecordsPerCall = Subaru.AgilityData.FindContentItemProperty(data, "MaximumItemLoadPerZoomLevel");

        if (MapUtils.MinZoomLevelForActivities == null || MapUtils.MinZoomLevelForActivities == undefined) {
            MapUtils.MinZoomLevelForActivities = 16;
        }
        if (MapUtils.MaxRecordsPerCall == null || MapUtils.MaxRecordsPerCall == undefined) {
            MapUtils.MaxRecordsPerCall = 25;
        }

        MapUtils.LoadMap();
        setTimeout("Subaru.MapUtils.LoadMapEvents()", 1100);
    };

    MapUtils.LoadMap = function() {
        if (MapUtils.map != null) {
            MapUtils.map.Dispose();
        }

        MapUtils.map = new VEMap(MapUtils._mapDivID);
        MapUtils.map.SetDashboardSize(VEDashboardSize.Small);
        MapUtils.map.HideScalebar();

        //if (MapUtils.ClientToken.length > 0) {
        // alert(clientToken);
        //MapUtils.map.SetClientToken(MapUtils.ClientToken);
        //}

        MapUtils.map.LoadMap();

        //add the activity layer...
        if (MapUtils.ActivityPointLayer == null) {
            //add the layer for all activity points
            MapUtils.ActivityPointLayer = new VEShapeLayer();
            MapUtils.map.AddShapeLayer(MapUtils.ActivityPointLayer);
        }

        //allow the other layers to be on top of this...
        _mapLoaded = true;
    };

    MapUtils.MyHandleTokenError = function() {

    };

    MapUtils.LoadMapEvents = function() {

        MapUtils.map.AttachEvent("onendzoom", MapUtils.EndZoomHandler);

        MapUtils.map.AttachEvent("onmousedown", MapUtils.MouseHandler);
        MapUtils.map.AttachEvent("onmouseup", MapUtils.MouseHandler);
        MapUtils.map.AttachEvent("onmousemove", MapUtils.MouseHandler);

        MapUtils.map.AttachEvent("onclick", MapUtils.ClickHandler);

        //Hide the default context menu
        if ($.browser.safari) { //Webkit browser Safari or Chrome
            $("div[id$=MainContentArea]").contextMenu("MainMap_RightClick", {
                onContextMenu: function(e) {
                }
            });
        }

        MapUtils.map.AttachEvent("onendzoom", MapUtils.ZoomEnd);
    };

    MapUtils.ZoomEnd = function(e) {
        if (MapUtils.MapMode != "Route") {
            if (!MapUtils.IsFirstLoad) {
                MapUtils.map.DeleteAllShapes();

                MapUtils.LoadedActivities = new Array();
                MapUtils.LoadActivities();
            }
            MapUtils.IsFirstLoad = false;
        }
    };

    MapUtils.ClickHandler = function(e) {
        MapUtils.HideContextMenu();

        if (MapUtils.MapMode == "Route") {
            return;
        }

        if (e.rightMouseButton) {
            MapUtils.ShowContextMenu(e.clientX, e.clientY, e.latLong);
        }

        if (e.elementID != null) {

            var pushPin = MapUtils.map.GetShapeByID(e.elementID);

            if (pushPin == null) {
                return;
            }
            if (pushPin.GetType() == VEShapeType.Pushpin) {

                MapUtils.ClickedShape = null;

                if (pushPin.IsAreYouHere != null && pushPin.IsAreYouHere == true) {
                    Subaru.WelcomeScreen.ShowNotHereDialog(true);
                }
                else {
                    try {
                        //make sure welcome screen is closed
                        Subaru.WelcomeScreen.Close();
                        Subaru.MapUtils.DeleteYouAreHereLayer();
                    }
                    catch (e) {

                    }

                    var zoomLevel = MapUtils.map.GetZoomLevel();


                    if (zoomLevel == 15) {
                        //if the user is already zoomed in... load activity on click
                        Subaru.ActivityDetails.LoadActivity(pushPin.ActivityID);
                        return;
                    }
                    else {

                        MapUtils.ClickedShape = pushPin;
                        var latitude = pushPin.Latitude;
                        var longitude = pushPin.Longitude;

                        var x = 100;
                        var y = 200;

                        var point = new VELatLong(latitude, longitude + 0.015);
                        MapUtils.map.SetCenterAndZoom(point, 15);


                        setTimeout("Subaru.MapUtils.ShowActivityMiniPopup()", 500);
                    }
                }

            }
        }
    }

    MapUtils.HideContextMenu = function() {
        $("#Map_RightClickContextMenu").hide();
    }

    MapUtils.ShowContextMenu = function(clientX, clientY, latLong) {

        if (Subaru.ContextUtil.IsAuthenticated()) {

            var contextMenu = $("#Map_RightClickContextMenu");
            contextMenu.css("left", clientX);
            contextMenu.css("top", clientY);



            contextMenu.show();
        }


    }

    MapUtils.ShowActivityInfoBox = function() {



        var shape;
        for (var i = 0; i < MapUtils.ActivityPointLayer.GetShapeCount(); i++) {
            shape = MapUtils.ActivityPointLayer.GetShapeByIndex(i);
            if (shape.GetType() == VEShapeType.Pushpin) {

                if (shape.ActivityID != null && shape.ActivityID != undefined) {
                    if (shape.ActivityID == MapUtils.SelectedActivityID) {

                        MapUtils.JumpToPoint(shape.Latitude, shape.Longitude);
                        MapUtils.ClickedShape = shape;


                        setTimeout("Subaru.MapUtils.ShowActivityMiniPopup()", 500);
                    }
                }
            }
        }
    }

    MapUtils.ShowActivityMiniPopup = function() {
        if (MapUtils.ClickedShape != null) {

            MapUtils.map.ShowInfoBox(MapUtils.ClickedShape);
        }
    }


    MapUtils.resizeWindow = function(e) {
        MapUtils.SetMapHeight(MapUtils.ModeIsPreview);
    }


    MapUtils.LoadDefaultStartLocation = function(position) {

        //GeoLocation by IP
        if ((_mapLoaded == false) || (Subaru.AgilityData.Provinces == null)) {
            setTimeout(function() {
                MapUtils.LoadDefaultStartLocation();
            }, 50);
            return;
        }

        //do not do the geolocation and are you here if in Route mode on refresh with activity hash
        if (MapUtils.MapMode != "Route") {

            var shape = null;
            var lat = null;
            var lon = null;
            var zoom = null;

            var geolocationCookie = $.cookie("Subaru.Geolocation");

            if (position != undefined && position != null && position.coords != undefined && position.coords != null) {

                lat = position.coords.latitude;
                lon = position.coords.longitude;
                zoom = 8;
                MapUtils.AddYouAreHerePushPin(lat, lon);
            } /*else if (google.loader.ClientLocation) {

                lat = google.loader.ClientLocation.latitude;
                lon = google.loader.ClientLocation.longitude;
                zoom = 8;
                }*/
            else if ((geolocationCookie != null) && (geolocationCookie.indexOf("^") > -1)) {
                lat = geolocationCookie.substring(0, geolocationCookie.indexOf("^"));
                lon = geolocationCookie.substring(geolocationCookie.indexOf("^") + 1, geolocationCookie.length);
                zoom = 8;
                MapUtils.AddYouAreHerePushPin(lat, lon);
            }
            else {
                //fix the location to Toronto if none is found			
                lat = 43.675293;
                lon = -79.299902;
                zoom = 6;

                Subaru.WelcomeScreen.ShowNotHereDialog(false);
            }

            MapUtils.map.SetCenterAndZoom(new VELatLong(lat, lon), zoom);

            //load the activities
            setTimeout("Subaru.MapUtils.LoadActivities()", 1000);
        }
    }

    MapUtils.AddYouAreHerePushPin = function(lat, lon) {

        shape = new VEShape(VEShapeType.Pushpin, new VELatLong(lat, lon));

        MapUtils.NotHereLayer = new VEShapeLayer();
        MapUtils.map.AddShapeLayer(MapUtils.NotHereLayer);
        shape.SetCustomIcon(MapUtils.NotHereImageUrl);
        shape.IsAreYouHere = true;
        MapUtils.NotHereLayer.AddShape(shape);

    }

    MapUtils.SetLocation = function(city, province, postalCode) {

        var locationStr = "";
        if (postalCode != null && postalCode.length > 0) {
            locationStr = " Canada " + postalCode;
        }
        else {

            locationStr = city + " " + province + " Canada ";
        }

        MapUtils.map.Find(null, locationStr, null, null, null, null, null, null, null, null, MapUtils.SetLocationCallback);
    }

    MapUtils.SetLocationCallback = function() {
        var newLocation = MapUtils.map.GetCenter();

        if ((newLocation != null) && (newLocation != undefined)) {
            var expiryDate = new Date();
            expiryDate.setFullYear(expiryDate.getFullYear() + 100, expiryDate.getMonth(), expiryDate.getDay());
            $.cookie("Subaru.Geolocation", newLocation.Latitude + "^" + newLocation.Longitude, { expires: expiryDate });

            MapUtils.AddYouAreHerePushPin(newLocation.Latitude, newLocation.Longitude);
        }
    }

    MapUtils.DeleteYouAreHereLayer = function() {
        try {
            MapUtils.map.DeleteShapeLayer(MapUtils.NotHereLayer);
        } catch (e) { }
    }

    MapUtils.SetMapHeight = function(isPreview) {
        var mapDivObj = MapUtils.GetMapDiv();
        var windowHeight = $(window).height();

        windowHeight = windowHeight - 204;

        if (isPreview) {
            windowHeight = windowHeight - 84;
        }


        if (windowHeight < 400) {
            windowHeight = 400;
        }

        mapDivObj.height(windowHeight);

    }

    MapUtils.GetMapEdgePoint = function(edge) {
        var x = null;
        var y = null;


        var left = MapUtils.map.GetLeft();
        var top = MapUtils.map.GetTop();



        var mapDivObj = MapUtils.GetMapDiv();

        if (edge == MapUtils.MapEdge.TopLeft) {
            x = left;
            y = top;
        }
        else if (edge == MapUtils.MapEdge.TopRight) {
            x = left + mapDivObj.width();
            y = top;
        }
        else if (edge == MapUtils.MapEdge.BottomLeft) {
            x = left;
            y = top + mapDivObj.height();
        }
        else if (edge == MapUtils.MapEdge.BottomRight) {
            x = left + mapDivObj.width();
            y = top + mapDivObj.height();
        }

        if (x != null && y != null) {
            var Point = MapUtils.map.PixelToLatLong(new VEPixel(x, y));


            return Point;
        }

        return null;

    }

    MapUtils.ClearMap = function() {
        MapUtils.map.Clear();
    }

    MapUtils.LoadMapCorners = function() {
        MapUtils.TopLeft = MapUtils.GetMapEdgePoint(MapUtils.MapEdge.TopLeft);
        MapUtils.TopRight = MapUtils.GetMapEdgePoint(MapUtils.MapEdge.TopRight);
        MapUtils.BottomLeft = MapUtils.GetMapEdgePoint(MapUtils.MapEdge.BottomLeft);
        MapUtils.BottomRight = MapUtils.GetMapEdgePoint(MapUtils.MapEdge.BottomRight);
    }

    MapUtils.EndZoomHandler = function(e) {
        MapUtils.RefreshMapActivities();
    }

    MapUtils.EndMouseEventHandler = function(e) {
        MapUtils.RefreshMapActivities();
    }


    MapUtils.RefreshMapActivities = function() {

        MapUtils.LoadMapCorners();
        MapUtils.LoadActivities();
    }


    MapUtils.LoadActivities = function() {



        if (MapUtils.MapMode == "Route") {
            //do no do the data load operations when in Route Mode
            return;
        }

        if (MapUtils.ActivityPointLayer == null) {
            MapUtils.ActivityPointLayer = new VEShapeLayer();
            MapUtils.map.AddShapeLayer(MapUtils.ActivityPointLayer);
        }

        var currentZoomLevel = MapUtils.map.GetZoomLevel();


        if (currentZoomLevel < MapUtils.MinZoomLevelForActivities) {

            MapUtils.map.DeleteAllShapes();

            return;
        }

        MapUtils.LoadMapCorners();

        if (MapUtils.TopLeft == null || MapUtils.TopRight == null || MapUtils.BottomLeft == null || MapUtils.BottomRight == null) {
            return;
        }


        var precision = 4;

        var searchQuery = "";


        if (Subaru.ContextUtil.SelectedActivityType != null && Subaru.ContextUtil.SelectedActivityType > 0) {
            searchQuery += "TypeID = " + Subaru.ContextUtil.SelectedActivityType + " && ";
        }
        if (Subaru.ContextUtil.SelectedActivityType != null && Subaru.ContextUtil.SelectedProvince > 0) {
            searchQuery += "ProvinceID = " + Subaru.ContextUtil.SelectedProvince + " && ";
        }
        searchQuery += "StartLatitude < " + MapUtils.ShrinkDecimal(MapUtils.TopLeft.Latitude, precision) + " && StartLongitude > " + MapUtils.ShrinkDecimal(MapUtils.TopLeft.Longitude, precision);
        searchQuery += " && StartLatitude < " + MapUtils.ShrinkDecimal(MapUtils.TopRight.Latitude, precision) + " && StartLongitude < " + MapUtils.ShrinkDecimal(MapUtils.TopRight.Longitude, precision);
        searchQuery += " && StartLatitude > " + MapUtils.ShrinkDecimal(MapUtils.BottomLeft.Latitude, precision) + " && StartLongitude > " + MapUtils.ShrinkDecimal(MapUtils.BottomLeft.Longitude, precision);
        searchQuery += " && StartLatitude > " + MapUtils.ShrinkDecimal(MapUtils.BottomRight.Latitude, precision) + " && StartLongitude < " + MapUtils.ShrinkDecimal(MapUtils.BottomRight.Longitude, precision);



        var searchArg = {
            RecordTypeName: "Activity",
            PageSize: MapUtils.MaxRecordsPerCall,
            RecordOffset: MapUtils.DataRecordOffset,
            SortedField: "CreatedOn",
            SortDirection: Agility.UGC.API.SortDirection.DESC,
            Search: searchQuery
        }
        Agility.UGC.API.SearchRecords(searchArg, function(data) {
            if (data.ResponseType != Agility.UGC.API.ResponseType.OK) {

            } else {

                for (var i = 0; i < data.ResponseData.Records.length; i++) {

                    MapUtils.PlaceActivityPin(data.ResponseData.Records[i]);
                }


                //                var TotalCount = data.ResponseData.TotalRecords;

                //                if (TotalCount > MapUtils.DataRecordOffset) {
                //                    MapUtils.DataRecordOffset = MapUtils.DataRecordOffset + MapUtils.MaxRecordsPerCall;
                //                    if (MapUtils.DataRecordOffset < TotalCount) {


                //                        MapUtils.LoadActivities();

                //                    }
                //                    else {
                //                        MapUtils.DataRecordOffset = 0;
                //                    }

                //                }
                //                else {

                //                    MapUtils.DataRecordOffset = 0;
                //                }

            }
        });


    }

    MapUtils.AddActivityToDataSet = function(record) {
        MapUtils.LoadedActivities[MapUtils.LoadedActivities.length] = record;
    }

    MapUtils.PlaceActivityPin = function(record) {


        //if (!MapUtils.HasRecordBeenPlaced(record)) {

        MapUtils.AddActivityToDataSet(record);

        var point = new VELatLong(record.StartLatitude, record.StartLongitude);


        var activity = new VEShape(VEShapeType.Pushpin, point);

        activity.SetDescription(MapUtils.GeneratePopupContent(record));


        var iconURL = Subaru.AgilityData.GetActivityTypeIconUrl(record.TypeID);

        if (iconURL != null) {

            activity.SetCustomIcon(iconURL);
        }
        activity.ActivityID = record.ID;


        if (MapUtils.ActivityPointLayer == null) {
            MapUtils.ActivityPointLayer = new VEShapeLayer();
            MapUtils.map.AddShapeLayer(MapUtils.ActivityPointLayer);
        }
        MapUtils.ActivityPointLayer.AddShape(activity);


        //}
    }


    MapUtils.GeneratePopupContent = function(activityRecord) {
        var divContainer = $(document.createElement("div"));

        var data = new Array();
        data[0] = activityRecord;

        templateUrl = Agility.ResolveUrl("~/ClientTemplates/ActivitySimplePopup.htm");
        divContainer.setTemplateURL(templateUrl);
        //divContainer.setParam("BaseS3Url", Agility_BaseS3Url);
        divContainer.setParam("ReadMoreAndReview", Subaru.AgilityData.GetGlobalLanguageResource("ActivityPopup_ReadMoreAndReview"));
        divContainer.setParam("ImageURL", Subaru.TemplateUtils.S3ThumbURL(Agility_BaseS3Url + "/" + activityRecord.PrimaryImage, 230, 140));

        var count = 0;
        if (activityRecord.LikeCount > 0) {
            count = activityRecord.LikeCount;
        }

        divContainer.setParam("PeopleCallFav", count.toString() + " " + Subaru.AgilityData.GetGlobalLanguageResource("ActivityPopup_PeopleCallFav"));
        divContainer.setParam("SubmittedBy", Subaru.AgilityData.GetGlobalLanguageResource("ActivityPopup_SubmittedBy"));
        //divContainer.setParam("SubmittedByUser", "Subaru");

        divContainer.processTemplate(data);

        var htmlResult = divContainer.html();
        divContainer = null;


        if (htmlResult != null && htmlResult != undefined) {
            return htmlResult;
        }
        else {
            return "Error Loading Activity Data";
        }

    }

    MapUtils.HasRecordBeenPlaced = function(record) {

        if (MapUtils.LoadedActivities != null) {

            for (var i = 0; i < MapUtils.LoadedActivities.length; i++) {

                if (MapUtils.LoadedActivities[i] != null) {

                    if (MapUtils.LoadedActivities[i].ID == record.ID) {

                        return true;
                    }
                }
            }
        }
        return false;
    }

    MapUtils.ShrinkDecimal = function(value, maxDecimalCount) {

        var multiplier = 1;

        for (var i = 0; i < maxDecimalCount; i++) {
            multiplier = multiplier * 10;
        }

        var result = Math.round(value * multiplier) / multiplier;
        return result;
    }

    MapUtils.MapDrag = false;
    MapUtils.CheckForNewActivities = false;

    MapUtils.MouseHandler = function(e) {
        var msg;
        if (e.eventName == "onmousedown") {

            MapUtils.MapDrag = true

        }
        else if (e.eventName == "onmouseup") {

            if (MapUtils.MapDrag && MapUtils.CheckForNewActivities) {
                MapUtils.RefreshMapActivities();
            }
            MapUtils.MapDrag = false;
            MapUtils.CheckForNewActivities = false;
        } else if (e.eventName == "onmousemove" && MapUtils.MapDrag == true) {

            MapUtils.CheckForNewActivities = true;
        }


    }

    MapUtils.ToggleControls = function(turnControlsOn) {
        try {
            if (turnControlsOn) {
                MapUtils.map.ShowDashboard();
            }
            else {
                MapUtils.map.HideDashboard();
            }
        }
        catch (e) {

        }
    }


    MapUtils.ClearAllMapData = function() {


        MapUtils.map.DeleteAllShapes();

        MapUtils.NotHereLayer = null;
        MapUtils.ActivityPointLayer = null;

        try {
            MapUtils.map.DeleteAllShapes();
        } catch (e) { }

        //MapUtils.LoadMapEvents();
        MapUtils.LoadedActivities = new Array();



    }

    MapUtils.JumpToPoint = function(latitude, longitude, activityID) {

        MapUtils.map.SetCenterAndZoom(new VELatLong(latitude, longitude + 0.015), 15);

        setTimeout("Subaru.MapUtils.LoadActivities()", 800);

        if (activityID != null && activityID != undefined && activityID > 0) {
            MapUtils.SelectedActivityID = activityID;
            setTimeout("Subaru.MapUtils.ShowActivityInfoBox()", 1500);
        }

    }

    MapUtils.ReturnToDefaultMap = function() {
        MapUtils.MapMode = "Default";
        MapUtils.ClearAllMapData();
        MapUtils.LoadActivities();
    }


    MapUtils.CreateRoute = function(StartLat, StartLong, TypeID, MapData) {
        MapUtils.MapMode = "Route";

        MapUtils.JumpToPoint(StartLat, StartLong);

        try {
            if (MapUtils.RouteLayer != null) {
                MapUtils.map.DeleteShapeLayer(MapUtils.RouteLayer);

            }
        }
        catch (e) { }
        MapUtils.RouteLayer = null;
        MapUtils.RouteLayer = new VEShapeLayer();
        MapUtils.map.AddShapeLayer(MapUtils.RouteLayer);



        var point = new VELatLong(StartLat, StartLong);
        var activity = new VEShape(VEShapeType.Pushpin, point);


        var iconURL = Subaru.AgilityData.GetActivityTypeIconUrl(TypeID);

        if (iconURL != null) {
            activity.SetCustomIcon(iconURL);
        }


        MapUtils.RouteLayer.AddShape(activity);

        if (MapData != null && MapData != undefined && MapData != "") {

            var iconURL = "http://getoutmore.s3.amazonaws.com/RoutePoint.png";
            var mappingData = "[" + MapData + "]";

            var mappingDataJSON = eval(mappingData);


            for (var i = 0; i < mappingDataJSON.length; i++) {
                var point = new VELatLong(mappingDataJSON[i].Latitude, mappingDataJSON[i].Longitude);
                var routePoint = new VEShape(VEShapeType.Pushpin, point);
                routePoint.SetCustomIcon(iconURL);


                MapUtils.RouteLayer.AddShape(routePoint);
            }
        }

    }

    MapUtils.ProvinceZoom = function(provinceID) {

        try {
            if (Subaru.AgilityData.Provinces != null && Subaru.AgilityData.Provinces.length > 0) {
                for (var i = 0; i < Subaru.AgilityData.Provinces.length; i++) {
                    if (Subaru.AgilityData.Provinces[i].ProvinceID == provinceID) {
                        var point = new VELatLong(Subaru.AgilityData.Provinces[i].CenterLatitude, Subaru.AgilityData.Provinces[i].CenterLongitude);


                        var zoomLevel = Subaru.AgilityData.Provinces[i].ZoomLevel;
                        zoomLevel = 5;
                        MapUtils.map.SetCenterAndZoom(point, zoomLevel);

                        setTimeout("Subaru.MapUtils.LoadActivities()", 1000);
                        return;
                    }
                }
            }
        }
        catch (e) {
            return;
        }
    }


})(Subaru.MapUtils);