/*
 * options:
 * - mapOptions: options to pass to google Map constructor
 * - enableClustering: boolean whether to cluster markers or not, defaults to true
 * - clusterOptions: options to pass to MarkerClusterer constructor
*/
function MapWrapper(divID, options) {
    'use strict';
    options = options || {};

    var _map = createMap(divID, options.mapOptions),
        _initialized = false,
        _clusterer = createClusterer(_map, options.clusterOptions),
        _trafficLayer = new google.maps.TrafficLayer(),
        _clusteringEnabled = options.enableClustering !== false,
        _defaultLayer = new Layer('Default'),
        _pushpinLayer = new Layer('pushpinLayer'),
        _layers = [],
        _layersArray = [],
        _entities = {},
        _entitiesArray = [],
        _infoboxes = {},
        _places = {},
        _highestMarkerZIndex = google.maps.Marker.MAX_ZINDEX;

    return {
        addEntity: addEntity,
        addLayer: addLayer,
        addInfobox: addInfobox,
        addEventListener: addEventListener,
        addPlace: addPlace,
        clearLayer: clearLayer,
        cluster: cluster,
        draw: draw,
        getEntity: getEntity,
        getLayer: getLayer,
        getMap: getMap,
        showDefaultLayer: showDefaultLayer,
        hideDefaultLayer: hideDefaultLayer,
        showTrafficLayer: showTrafficLayer,
        hideTrafficLayer: hideTrafficLayer,
        showEntities: showEntities,
        hideEntities: hideEntities,
        removeEntity: removeEntity,
        removePlace: removePlace,
        clearPlaces: clearPlaces,
        uncluster: uncluster,
        zoom: zoom,
        zoomToLayer: zoomToLayer,
        zoomToPlaces: zoomToPlaces,
        zoomToPlace: zoomToPlace,
        moveEntityToFront: moveEntityToFront,
        moveLayerToFront: moveLayerToFront
    };

    //Add entity to a specific layer, or the default layer if 'layerId' is undefined or the layer doesn't exist
    function addEntity(entity, layerId) {

        var layer = _layers[layerId];

        if (layer)
            layer.add(entity);
        else {
            _defaultLayer.add(entity);
            layer = _defaultLayer;
        }
        entity.layer = layer;
        _entities[entity.id] = entity;
        _entitiesArray.push(entity);

    }
    function addLayer(layer) {
        _layers[layer.id] = layer;
        _layersArray.push(layer);
    }
    function addInfobox(id, infobox) {
        _infoboxes[id] = infobox;
        infobox.map = _map;
    }
    function addEventListener(eventName, callback) {
        _map.addEventListener(eventName, callback);
    }
    function createMap(divID, options) {

        options = options || {
            backgroundColor: '#f9f9f9',
            center: { lat: 50, lng: 3 },
            disableDefaultUI: true,
            minZoom: 2,
            mapTypeControl: true,
            mapTypeControlOptions: {
                position: google.maps.ControlPosition.TOP_RIGHT
            },
            noClear: true,
            streetViewControl: true,
            streetViewControlOptions: {
                position: google.maps.ControlPosition.RIGHT_BOTTOM
            },
            zoom: 5,
        };

        return new google.maps.Map(document.getElementById(divID), options);
    }
    function createClusterer(map, options) {

        options = options || {
            averageCenter: true,
            imagePath: '/Content/Images/Mobile/Map/m',
            minimumClusterSize: 10,
            zoomOnClick: true,
        };

        return new MarkerClusterer(map, [], options);
    }
    function draw() {

        if (_clusteringEnabled) {

            var googleEntities = _entitiesArray.filter(function (entity) {
                if (entity.visible)
                    return entity;
            }).map(function (entity) {
                entity.clusterer = _clusterer;
                return entity.googleEntity;
            });

            _clusterer.addMarkers(googleEntities, !_initialized);

            _layersArray.forEach(function (layer) {
                layer.clusterer = _clusterer;
            });
        }
        else {
            _entitiesArray.forEach(function (entity) {
                entity.googleEntity.setMap(_map);
            });
        }

        _map.addListener('idle', function () {
            _initialized = true;
        });

        //Defaultlayer isn't part of any cluster
        _defaultLayer.draw(_map);
        zoom();
    }
    function clearLayer(layer) {
        layer.entities.forEach(function (entity) {
            //removes the entity from the map, not from _entities or _entitiesArray
            entity.remove();
            if (entity.radiusCircle) {
                entity.radiusCircle.setMap(null);
            }
            var index = _entitiesArray.indexOf(entity);
            _entitiesArray.splice(index, 1);
            delete _entities[entity.id];
        });
        layer.entities = [];
    }
    function cluster() {
        if (_clusteringEnabled)
            return;
        _clusteringEnabled = true;
        _entitiesArray.forEach(function (entity) {
            entity.clusterer = _clusterer;
            entity.remove();
        });
        _layersArray.forEach(function (layer) {
            layer.clusterer = _clusterer;
        });
        this.draw();
    }
    function getEntity(id) {
        return _entities[id] || null;
    }
    function getLayer(id) {
        return _layers[id] || null;
    }
    function getMap() {
        return _map;
    }
    function showDefaultLayer() {
        _defaultLayer.show();
    }
    function hideDefaultLayer() {
        _defaultLayer.hide();
    }
    function showTrafficLayer() {
        _trafficLayer.setMap(_map);
    }
    function hideTrafficLayer() {
        _trafficLayer.setMap(null);
    }
    //This won't make entities show up inside an invisible layer
    function showEntities() {

        if (_clusteringEnabled) {

            _entitiesArray.forEach(function (entity) {
                entity.show(false);
            });
            var visibleEntities = _entitiesArray.filter(function (entity) {
                return entity.visible;
            }).map(function (entity) {
                return entity.googleEntity;
            });

            _clusterer.addMarkers(visibleEntities, !_initialized);
        }
        else {
            _entitiesArray.forEach(function (entity) {
                entity.show();
            });
        }
    }
    function hideEntities() {

        if (_clusteringEnabled) {
            _clusterer.clearMarkers();
            _entitiesArray.forEach(function (entity) {
                entity.hide(false);
            });
        }
        else {
            _entitiesArray.forEach(function (entity) {
                entity.hide();
            });
        }
    }
    function removeEntity(id) {
        var entity = getEntity(id);
        if (entity === null) {
            return;
        }
        //removes the entity from the map, not from _entities or _entitiesArray
        entity.remove();
        if (entity.radiusCircle) {
            entity.radiusCircle.setMap(null);
        }
        //remove from the layer
        entity.layer.remove(entity);
        var index = _entitiesArray.indexOf(entity);
        _entitiesArray.splice(index, 1);
        delete _entities[id];
    }
    function uncluster() {
        if (!_clusteringEnabled)
            return;
        _clusteringEnabled = false;
        _clusterer.clearMarkers();
        this.draw();
        _entitiesArray.forEach(function (entity) {
            entity.clusterer = null;
        });
        _layersArray.forEach(function (layer) {
            layer.clusterer = null;
        });
    }
    function zoom(id) {

        if (id) {
            var entity = _entities[id];
            zoom(entity.latitude, entity.longitude, 16);
            return;
        }

        var visibleEntities = _entitiesArray.filter(function (entity) {
            return entity.googleEntity && entity.visible;
        });

        if (visibleEntities.length > 1) {

            var latLngBounds = new google.maps.LatLngBounds();
            visibleEntities.forEach(function (entity) {
                latLngBounds.extend(entity.location);
            });
            _map.fitBounds(latLngBounds);
        }
        else if (visibleEntities.length == 1) {
            zoom(visibleEntities[0].latitude, visibleEntities[0].longitude, 16);
        }
        else
            zoom();

        function zoom(latitude, longitude, zoomLevel) {

            if (!(latitude || longitude)) {
                latitude = 50;
                longitude = 3;
                zoomLevel = 4;
            }
            _map.setCenter({ lat: latitude, lng: longitude });
            _map.setZoom(zoomLevel);
        }
    }
    function zoomToLayer(layer) {

        if (layer.entities.length === 0) {
            _map.setCenter({ lat: 50, lng: 3 });
            _map.setZoom(5);
            return;
        }

        if (layer.entities.length === 1) {
            var entity = layer.entities[0];
            _map.setCenter(entity.location);
            _map.setZoom(16);
            return;
        }

        var locationArray = layer.entities.reduce(function (locationRect, entity) {
            if (entity.googleEntity && entity.googleEntity.getVisible()) {
                locationRect.extend(entity.location);
            }
            return locationRect;
        }, new google.maps.LatLngBounds());

        _map.fitBounds(locationArray);

        if (_map.getZoom() > 16) {
            _map.setZoom(16);
        }
    }
    function addPlace(place) {
        _places[place.id] = place;
        place.googleEntity.setMap(_map);
    }
    function removePlace(id) {
        //calling remove() removes the entity from the map but does not delete it from _places
        _places[id].remove();
        delete _places[id];
    }
    function clearPlaces() {
        for (var key in _places) {
            if (_places.hasOwnProperty(key) && _places[key].googleEntity) {
                _places[key].remove();
            }
        }

        _places = {};
    }
    function zoomToPlaces() {
        var anyVisible = false;

        var locationRectangle = new google.maps.LatLngBounds();
        for (var key in _places) {
            if (_places.hasOwnProperty(key) && _places[key].googleEntity && _places[key].googleEntity.getVisible()) {
                anyVisible = true;
                var googleEntity = _places[key].googleEntity;
                var bounds = googleEntity.getBounds();
                locationRectangle.extend(bounds.getNorthEast());
                locationRectangle.extend(bounds.getSouthWest());
            }
        }

        if (anyVisible) {
            _map.fitBounds(locationRectangle);
        }
        else {
            _map.setCenter({ lat: 50, lng: 3 });
            _map.setZoom(4);
        }
    }
    function zoomToPlace(id) {
        var place = _places[id];
        _map.fitBounds(place.googleEntity.getBounds());
    }
    function moveEntityToFront(id) {
        var entity = getEntity(id);
        if (entity == null) {
            return;
        }
        _highestMarkerZIndex++;
        entity.googleEntity.setZIndex(_highestMarkerZIndex);
    }
    function moveLayerToFront(layerId) {
        var layer = getLayer(layerId);
        _highestMarkerZIndex++;
        layer.entities.forEach(function (entity) {
            entity.googleEntity.setZIndex(_highestMarkerZIndex);
        });
    }
}