/// <reference path="../GbgMap.Base.js" />
/// <reference path="OpenLayers/OpenLayers.js" />

GbgMap.API.Search = {

    map: GbgMap.API.getMapInstance(),

    searchByIDs: function (layerName, IDList, searchCompleteCallback) {

        var layer = GbgMap.API.getActiveLayer(layerName);

        var andFilter = new OpenLayers.Filter.Logical({
            type: OpenLayers.Filter.Logical.AND
        });

        if (layer.filter != "") {

            var parsedFilter = GbgMap.API.Search.parseFilter(layer.filter);

            if (parsedFilter != null) {
                andFilter.filters.push(parsedFilter);
            }
        }

        var orFilter = new OpenLayers.Filter.Logical({
            type: OpenLayers.Filter.Logical.OR
        });

        if (IDList) {

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

                var idFilter = new OpenLayers.Filter.Comparison({
                    type: OpenLayers.Filter.Comparison.EQUAL_TO,
                    property: layer.idField,
                    value: IDList[i]
                });

                orFilter.filters.push(idFilter);
            }

            andFilter.filters.push(orFilter);

            var featuresToReturn = new Array();

            var protocol = new OpenLayers.Protocol.WFS({
                url: layer.url,
                featureNS: layer.featureNS,
                featureType: layer.id,
                filter: andFilter,
                callback: function (response) {

                    if (response.features != null) {

                        for (var i = 0; i < response.features.length; i++) {
                            var feature = new GbgMap.API.Feature();
                            var responseFeature = response.features[i];

                            feature.featureId = responseFeature.attributes[layer.fields.featureId];
                            feature.datasetId = responseFeature.attributes[layer.fields.datasetId];
                            feature.name = responseFeature.attributes[layer.fields.name];
                            feature.adress = responseFeature.attributes[layer.fields.adress];
                            feature.x = responseFeature.geometry.x;
                            feature.y = responseFeature.geometry.y;
                            feature.WKT = responseFeature.attributes[layer.fields.WKT];
                            feature.objectType = responseFeature.attributes[layer.fields.objectType];
                            feature.ingress = responseFeature.attributes[layer.fields.ingress];
                            feature.header = responseFeature.attributes[layer.fields.header];
                            feature.body = responseFeature.attributes[layer.fields.body];
                            feature.link = responseFeature.attributes[layer.fields.link];

                            featuresToReturn.push(feature);
                        }
                    }

                    var sortedFeatures = GbgMap.API.Search.sortFeatures(featuresToReturn);

                    if (searchCompleteCallback) {
                        searchCompleteCallback(sortedFeatures);
                    }
                }
            });

            protocol.read();
        }
        else {
            if (searchCompleteCallback) {
                searchCompleteCallback(null);
            }
        }

    },

    sortFeatures: function (featuresToSort) {
        
        featuresToSort.sort(function (a, b) {
            return a.header > b.header;
        });
        
        return featuresToSort;
    },

    //Parses OGC filter from XML format to OpenLayers OpenLayers.Format.Filter object
    parseFilter: function (filterString) {

        var filter = new OpenLayers.Format.Filter({ version: "1.1.0" });
        var xml = new OpenLayers.Format.XML();

        var parsedFilter = filter.read(xml.read(filterString).documentElement);

        return parsedFilter;
    }
};