/**
 * Freebase Layer class extends OpenLayers.Layer.WMS
 * For better(?) descriptions of the first four parameters, see docs for
 * OpenLayers.Layer.WMS
 * Provides query() functionality
 * @param {String} Layer Name
 * @param {String} WMS URL
 * @param {Object} GetMap query string parameters/values
 * @param {Object} Extra layer options
 */
FreebaseLayer = function(name, url, params, options) {
    FreebaseLayer.superclass.constructor.call(this, name, url, params, options);
};
 //   layer = new OpenLayers.Layer.WMS(name, url, params, options);
Ext.extend(FreebaseLayer, OpenLayers.Layer.WMS, {
    isQueryable: function() {
        if (this.view_name != undefined) {
            return true;
        } else {
            return false;
        }
    },
    getDisplayName: function() {
        return this.display_name;
    },
    getViewName: function() {
        return this.view_name;
    },
    query: function(tab, geom) {

        // Add a GridPanel to the passed-in tab
        if (tab.gridLoaded == false) {
            grid1 = new Ext.ux.AutoGridPanel({
                renderTo: tab.contentEl,
                height: 400,
                loadMask: true,
                autoSave: false,
                store : new Ext.data.Store({
                    proxy: new Ext.data.HttpProxy({
                        url: 'assets/php/AjaxRouter.php'
                    }),
                    reader: new Ext.data.JsonReader()
                })

            });
            grid1.store.addListener(
                "loadexception", 
                function (thisObj, options, response, error) {
                    alert("Load Exception Event\n" +
                          "Error:" + JSON.stringify(error) +
                          "\n");
                });
            grid1.store.load({params: {
                func: 'boxQuery', 
                geom: geom, 
                view: this.view_name, 
                meta: true
            }, callback: function(record, options, success) {
                if (record.length == 0) {
                    tab.contentEl.innerHTML = "No Results Found";
                }
            }
            });
            tab.gridLoaded = true;
        }
    },
    pointQuery: function(geom) {
        qResultWin.title = 'Identify Results';//this.display_name;
        qResultWin.show();
        qResultWin.items.items[0].store.load({ params: {
            func: 'pointQuery',
            geom: geom.getGeometryText(map),
            view: this.view_name,
            meta: false
        }, callback: function(record, options, success) {
            if (record.length == 0) {
                Ext.Msg.show({
                    title: "No Results Found",
                    msg: "<b>No data was found near that location.</b><br>",
                    buttons: Ext.Msg.OK
                });
            }
        }});
    },
    getLegend: function() {
        alert("I need to get data from the Style DB and build an HTML/CSS legend");
    },
    zoomToLayer: function(){
         //this.extent;
         if (this.maxExtent){
             map.zoomToExtent(this.maxExtent);
         } else {
             map.setCenter(new OpenLayers.LonLat(lon,lat),zoom); // zoom to initla extent (home)
         }
    },
    // Get a menu item for this layer
    getMenuItem: function(handler) {
        var buttonPanel = new Ext.menu.Item({
            text: this.getDisplayName(),
            layerObj: this,
            handler: handler
        });
        return buttonPanel;
    }    
});

/**
 * Define a few layer-related functions. These should probably by static methods of the
 * FreebaseLayer class.
 */

/**
 * Retrieve an array of FreebaseLayer objects for visible, queryable layers
 * @return {Array} Array of visible, queryable layers
 */
function getVisibleQueryableLayers() {
    var layers = new Array();
    for (layername in layerArray) {
        var layer = layerArray[layername];
        if (!layerArray.hasOwnProperty(layername)) continue;
        if (layer.view_name != null && layer.getVisibility()) {
            layers.push(layer);
        }
    }
    return layers;
}

/**
 * Get a textual list of queryable for the "No queryable layers" dialog
 * @return {String} list of queryable layers
 */
function getQueryableLayers() {
    var text = "";
    for (layername in layerArray) {
        var layer = layerArray[layername];
        if (!layerArray.hasOwnProperty(layername)) continue;
        if (layer.view_name != null) {
            text += layer.getDisplayName() + "<br>";
        }
    }
    return text;
}

/**
 * Given an array of FreebaseLayer objects, return an array of the view names for
 * those objects
 * @param {Array} Array of FreebaseLayer objects
 * @return {Array} Array of view names
 */
function getViewNames(layers) {
    var result = new Array();
    for (var i in layers) {
        if (!layers.hasOwnProperty(i)) continue;
        if (layers[i].view_name != null){
            result.push(layers[i].view_name);
        }
    }
    return result;
}

/**
 * Given an array of layer view names, return an array of freebaseLayer objects
 * @param {Array} Array of layer view names
 * @return {Array} Array of FreebaseLayer objects
 */
function getLayersByViewName(views) {
    var result = new Array();
    for (layername in layerArray) {
        var layer = layerArray[layername];
        if (!layerArray.hasOwnProperty(layername)) continue;
        var viewName = layer.view_name;
        for (var i in views) {
            if (!views.hasOwnProperty(i)) continue;
            if (views[i] == viewName) {
                result.push(layer);
                break;
            }
        } // End for each view name provided by the caller
    } // End for each layer in the application
    return result;
}