var ids=[];
var DemoTileProvider = function DemoTileProvider() {
    this._quadtree = undefined;
    this._tilingScheme = new Cesium.GeographicTilingScheme();
    this._errorEvent = new Cesium.Event();
    this._levelZeroMaximumError = Cesium.QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(
        this._tilingScheme);
    this.cartographicLimitRectangle = Cesium.Rectangle.clone(Cesium.Rectangle.MAX_VALUE);
};
Cesium.defineProperties(DemoTileProvider.prototype, {
    quadtree: {
        get: function() {
            return this._quadtree;
        },
        set: function(value) {
            this._quadtree = value;
        }
    },
    ready: {
        get: function() {
            return true;
        }
    },
    tilingScheme: {
        get: function() {
            return this._tilingScheme;
        }
    },
    errorEvent: {
        get: function() {
            return this._errorEvent;
        }
    }
});
var rectangleIntersectionScratch = new Cesium.Rectangle();
var cornerPositionsScratch = [new Cesium.Cartesian3(), new Cesium.Cartesian3(), new Cesium.Cartesian3(),
    new Cesium.Cartesian3()
];
DemoTileProvider.prototype.update = function(frameState) {
    this._quadtree.beginFrame(frameState);
};
DemoTileProvider.prototype.initialize = function(frameState) {
    this._quadtree.render(frameState);
};
DemoTileProvider.prototype.beginUpdate = function(frameState) {

};
DemoTileProvider.prototype.endUpdate = function(frameState) {
    this._quadtree.endFrame(frameState);
    for (var i=0;i<this._quadtree._tilesToRender.length;i++){
        if(this._quadtree._tilesToRender[i].data.geometryPrimitive)
            this._quadtree._tilesToRender[i].data.geometryPrimitive.update(frameState);
            
    }
     
};

DemoTileProvider.prototype.getLevelMaximumGeometricError = function(level) {
    return this._levelZeroMaximumError / (1 << level);
};

DemoTileProvider.prototype.loadTile = function(frameState, tile) {
    var m_tile = function m_tile(json) {
        this._tile = tile;
        this._json = json;
        m_tile.prototype.draw = function draw() {
            var tile = this._tile;
            var json = this._json;
            var geometries = [];
            var billboards = new Cesium.BillboardCollection();//new Cesium.LabelCollection(); //new Cesium.PointPrimitiveCollection();//new Cesium.LabelCollection();
            //var positions = [];
            //var colorsTemp = [];
            //viewer.entities.removeAll();
            var entities=[];
            var count=0;
            for (var feature of json.features) {
                count++;
                if(count>20)
                    break;
                var coords = feature.geometry.coordinates;
                billboards.add({
                    position: Cesium.Cartesian3.fromDegrees(coords[0], coords[1], 200-tile._level*10),
                    //text: feature.properties.name,
                    //font: '10px sans-serif',
                    color: Cesium.Color.WHITE,
                    image: './js/plugin_video/video1.png'
                    //outlineColor: Cesium.Color.BLACK,
                    //outlineWidth: 1.0,
                    //style : Cesium.LabelStyle.FILL_AND_OUTLINE
                    
                });
                var entity = {
                    id:feature.id,
                    name: "点",
                    position: Cesium.Cartesian3.fromDegrees(coords[0], coords[1], 200-tile._level*10),
                    billboard: {
                        image: './js/plugin_video/video1.png',
                        
                    },
                    
                    click: function (entity) {//单击
                        //haoutil.alert('你单击了billboard：' + entity._name);
                        viewer.camera.flyTo({
                            destination : new Cesium.Cartesian3(entity._position._value.x, entity._position._value.y, entity._position._value.z+50)
                        });
                        if($("#video_toolbar").css('display')=='none'){
                            $("#video_toolbar").css('display','block');
                            
                        }
                    },
                    mouseover: function (entity1) {//移入
                    
                        mouseOverEntity(entity1)
                    },
                    mouseout: function (entity1) {//移出
                        
    
                        mouseOutEntity(entity1)
                    }
                }
                entities.push(entity);
                viewer.entities.add(entity);
               
            }
            //tile.data.geometryPrimitive = billboards;
            tile.data.entities = entities;
            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            tile.renderable = true;
            
        };
    }

    if (tile.state === Cesium.QuadtreeTileLoadState.START) {
        tile.state = Cesium.QuadtreeTileLoadState.LOADING;
        tile.data = {
            geometryPrimitive: undefined,
            entities:[],
            freeResources:function(){
                if(this.geometryPrimitive&&this.geometryPrimitive.destory)
                {
                    this.geometryPrimitive.destory();
                    this.geometryPrimitive=undefined;
                }
                if(this.entities){
                    for(var entity of this.entities){
                        viewer.entities.remove(entity);
                    }
                    this.entities=[];
                }
                
            }
        };
        //viewer.entities.removeAll();

        if (tile._level < 14) {
            tile.state = Cesium.QuadtreeTileLoadState.DONE;
            tile.renderable = true;
            return;
        }

        var resource = new Cesium.Resource({
            url: 'http://localhost:8580/geoserver/gwc/service/wmts',
            queryParameters: {
                FORMAT: 'application/json;type=geojson',
                STYLE: '',
                REQUEST: 'GetTile',
                SERVICE: 'WMTS',
                VERSION: '1.0.0',
                LAYER: 'DOM:hzvideoPts',
                TILEMATRIX: 'EPSG:4326:' + tile._level,
                TILEMATRIXSET: 'EPSG:4326',
                TILECOL: tile._x,
                TILEROW: tile._y
            }
        });
        
        resource.fetchJson().then(function(results) {
            var tile = new m_tile(results);
            
            if(tile._json.features.length>0){
                tile.draw();   
               
                // var count=0;
                // for (var feature of tile._json.features) {
                //     for(var id of ids){
                //         if(feature.id != id){
                //             count++;
                //         }
                //     }
                    
                //     if(count==ids.length){
                //         count=0;
                //         ids.push(feature.id);
                //         var coords = feature.geometry.coordinates;
                    
                //         viewer.entities.add({
                //             name: "点",
                //             position: Cesium.Cartesian3.fromDegrees(coords[0], coords[1], 20),
                //             billboard: {
                //                 image: './js/plugin_video/video3.png'
                //             },
                //             click: function (entity) {//单击
                //                 //haoutil.alert('你单击了billboard：' + entity._name);
                //                 viewer.camera.flyTo({
                //                     destination : new Cesium.Cartesian3(entity._position._value.x, entity._position._value.y, entity._position._value.z)
                //                 });
                //                 if($("#video_toolbar").css('display')=='none'){
                //                     $("#video_toolbar").css('display','block');
                                    
                //                 }
                //             },
                //             mouseover: function (entity) {//移入
                            
                //                 mouseOverEntity(entity)
                //             },
                //             mouseout: function (entity) {//移出
                                
            
                //                 mouseOutEntity(entity)
                //             },
                //         });
                //     }
                        
                    
                // }
                
            }
            
                
        });
        var levelError = this.getLevelMaximumGeometricError(tile.level);
    }
};

DemoTileProvider.prototype.computeTileVisibility = function(tile, frameState, occluders) {
    var distance = this.computeDistanceToTile(tile, frameState);
    tile._distance = distance;

    if (frameState.fog.enabled) {
        if (Cesium.Math.fog(distance, frameState.fog.density) >= 1.0) {
            // Tile is completely in fog so return that it is not visible.
            return Cesium.Visibility.NONE;
        }
    }

    var surfaceTile = tile.data;
    var tileBoundingRegion = surfaceTile.tileBoundingRegion;

    if (surfaceTile.boundingVolumeSourceTile === undefined) {
        // We have no idea where this tile is, so let's just call it partially visible.
        return Cesium.Visibility.PARTIAL;
    }

    var cullingVolume = frameState.cullingVolume;
    var boundingVolume = surfaceTile.orientedBoundingBox;

    if (!boundingVolume && surfaceTile.renderedMesh) {
        boundingVolume = surfaceTile.renderedMesh.boundingSphere3D;
    }

    // Check if the tile is outside the limit area in cartographic space
    surfaceTile.clippedByBoundaries = false;
    var clippedCartographicLimitRectangle = clipRectangleAntimeridian(tile.rectangle, this
        .cartographicLimitRectangle);
    var areaLimitIntersection = Cesium.Rectangle.simpleIntersection(clippedCartographicLimitRectangle, tile
        .rectangle, rectangleIntersectionScratch);
    if (!areaLimitIntersection) {
        return Visibility.NONE;
    }
    if (!Cesium.Rectangle.equals(areaLimitIntersection, tile.rectangle)) {
        surfaceTile.clippedByBoundaries = true;
    }

    if (frameState.mode !== Cesium.SceneMode.SCENE3D) {
        boundingVolume = boundingSphereScratch;
        BoundingSphere.fromRectangleWithHeights2D(tile.rectangle, frameState.mapProjection,
            tileBoundingRegion.minimumHeight, tileBoundingRegion.maximumHeight, boundingVolume);
        Cartesian3.fromElements(boundingVolume.center.z, boundingVolume.center.x, boundingVolume.center.y,
            boundingVolume.center);

        if (frameState.mode === SceneMode.MORPHING && surfaceTile.renderedMesh) {
            boundingVolume = BoundingSphere.union(surfaceTile.renderedMesh.boundingSphere3D, boundingVolume,
                boundingVolume);
        }
    }

    if (!boundingVolume) {
        return Cesium.Intersect.INTERSECTING;
    }

    var clippingPlanes = this._clippingPlanes;
    if (clippingPlanes && clippingPlanes.enabled) {
        var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
        tile.isClipped = (planeIntersection !== Intersect.INSIDE);
        if (planeIntersection === Cesium.Intersect.OUTSIDE) {
            return Cesium.Visibility.NONE;
        }
    }

    var intersection = cullingVolume.computeVisibility(boundingVolume);
    if (intersection === Cesium.Intersect.OUTSIDE) {
        return Cesium.Visibility.NONE;
    }

    var ortho3D = frameState.mode === Cesium.SceneMode.SCENE3D && frameState.camera
        .frustum instanceof Cesium.OrthographicFrustum;
    if (frameState.mode === Cesium.SceneMode.SCENE3D && !ortho3D && occluders) {
        var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
        if (!occludeePointInScaledSpace) {
            return intersection;
        }

        if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
            return intersection;
        }

        return Cesium.Visibility.NONE;
    }

    return intersection;
};
DemoTileProvider.prototype.canRefine = function(tile, frameState, occluders) {
    if (tile.level < 19)
        return true;
    return false;
};
DemoTileProvider.prototype.showTileThisFrame = function(tile, context, frameState, commandList) {

    if (tile.data.geometryPrimitive) {
        //tile.data.geometryPrimitive.update(context, frameState, commandList);
    }
};
DemoTileProvider.prototype.computeDistanceToTile = function(tile, frameState) {
    // The distance should be:
    // 1. the actual distance to the tight-fitting bounding volume, or
    // 2. a distance that is equal to or greater than the actual distance to the tight-fitting bounding volume.
    //
    // When we don't know the min/max heights for a tile, but we do know the min/max of an ancestor tile, we can
    // build a tight-fitting bounding volume horizontally, but not vertically. The min/max heights from the
    // ancestor will likely form a volume that is much bigger than it needs to be. This means that the volume may
    // be deemed to be much closer to the camera than it really is, causing us to select tiles that are too detailed.
    // Loading too-detailed tiles is super expensive, so we don't want to do that. We don't know where the child
    // tile really lies within the parent range of heights, but we _do_ know the child tile can't be any closer than
    // the ancestor height surface (min or max) that is _farthest away_ from the camera. So if we compute distance
    // based that conservative metric, we may end up loading tiles that are not detailed enough, but that's much
    // better (faster) than loading tiles that are too detailed.

    var heightSource = updateTileBoundingRegion(tile, this.terrainProvider, frameState);
    var surfaceTile = tile.data;
    var tileBoundingRegion = surfaceTile.tileBoundingRegion;

    if (heightSource === undefined) {
        // Can't find any min/max heights anywhere? Ok, let's just say the
        // tile is really far away so we'll load and render it rather than
        // refining.
        return 9999999999.0;
    } else if (surfaceTile.boundingVolumeSourceTile !== heightSource) {
        // Heights are from a new source tile, so update the bounding volume.
        surfaceTile.boundingVolumeSourceTile = heightSource;

        var rectangle = tile.rectangle;
        if (rectangle && rectangle.width < Cesium.Math.PI_OVER_TWO + Cesium.Math.EPSILON5) {
            surfaceTile.orientedBoundingBox = Cesium.OrientedBoundingBox.fromRectangle(
                tile.rectangle,
                tileBoundingRegion.minimumHeight,
                tileBoundingRegion.maximumHeight,
                tile.tilingScheme.ellipsoid,
                surfaceTile.orientedBoundingBox);

            surfaceTile.occludeePointInScaledSpace = computeOccludeePoint(this, surfaceTile
                .orientedBoundingBox.center, tile.rectangle, tileBoundingRegion.maximumHeight,
                surfaceTile.occludeePointInScaledSpace);
        }
    }

    var min = tileBoundingRegion.minimumHeight;
    var max = tileBoundingRegion.maximumHeight;

    if (surfaceTile.boundingVolumeSourceTile !== tile) {
        var cameraHeight = frameState.camera.positionCartographic.height;
        var distanceToMin = Math.abs(cameraHeight - min);
        var distanceToMax = Math.abs(cameraHeight - max);
        if (distanceToMin > distanceToMax) {
            tileBoundingRegion.minimumHeight = min;
            tileBoundingRegion.maximumHeight = min;
        } else {
            tileBoundingRegion.minimumHeight = max;
            tileBoundingRegion.maximumHeight = max;
        }
    }

    var result = tileBoundingRegion.distanceToCamera(frameState);

    tileBoundingRegion.minimumHeight = min;
    tileBoundingRegion.maximumHeight = max;

    return result;
};



function updateTileBoundingRegion(tile, terrainProvider, frameState) {
    var surfaceTile = tile.data;
    if (surfaceTile === undefined) {
        surfaceTile = tile.data = new Cesium.GlobeSurfaceTile();
    }

    if (surfaceTile.tileBoundingRegion === undefined) {
        surfaceTile.tileBoundingRegion = new Cesium.TileBoundingRegion({
            computeBoundingVolumes: false,
            rectangle: tile.rectangle,
            ellipsoid: tile.tilingScheme.ellipsoid,
            minimumHeight: 0,
            maximumHeight: 0
        });
    }
    return tile;
}

function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
    if (cartographicLimitRectangle.west < cartographicLimitRectangle.east) {
        return cartographicLimitRectangle;
    }
    var splitRectangle = Rectangle.clone(cartographicLimitRectangle, splitCartographicLimitRectangleScratch);
    var tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
    if (tileCenter.longitude > 0.0) {
        splitRectangle.east = CesiumMath.PI;
    } else {
        splitRectangle.west = -CesiumMath.PI;
    }
    return splitRectangle;
}

function computeOccludeePoint(tileProvider, center, rectangle, height, result) {
    var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
    var ellipsoid = ellipsoidalOccluder.ellipsoid;

    var cornerPositions = cornerPositionsScratch;
    Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.south, height, ellipsoid, cornerPositions[0]);
    Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.south, height, ellipsoid, cornerPositions[1]);
    Cesium.Cartesian3.fromRadians(rectangle.west, rectangle.north, height, ellipsoid, cornerPositions[2]);
    Cesium.Cartesian3.fromRadians(rectangle.east, rectangle.north, height, ellipsoid, cornerPositions[3]);

    return ellipsoidalOccluder.computeHorizonCullingPoint(center, cornerPositions, result);
}
DemoTileProvider.prototype.isDestroyed = function() {

    return false;
}
DemoTileProvider.prototype.destroy = function() {

    return Cesium.destroyObject(this);
};
DemoTileProvider.prototype.updateForPick = function(frameState) {
    // Add the tile pick commands from the tiles drawn last frame.
    var drawCommands = this._drawCommands;
    for (var i = 0, length = this._usedDrawCommands; i < length; ++i) {
        frameState.commandList.push(drawCommands[i]);
    }
};

function mouseOverEntity(entity) {
    entity._billboard._image._value='./js/plugin_video/video2.png';
    //var newclr = color.getValue().withAlpha(alpha);
    //color.setValue(newclr);
}

function mouseOutEntity(entity) {
    entity._billboard._image._value='./js/plugin_video/video1.png';
    //var newclr = color.getValue().withAlpha(alpha);
    //color.setValue(newclr);
}