/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 * 
 * http://extjs.com/license
 */

/**
 * @author Shea Frederick
 */

Ext.namespace('Ext.ux');
 
/**
 *
 * @class GMapPanel
 * @extends Ext.Panel
 */
Ext.ux.GMapPanel = Ext.extend(Ext.Panel, {

    initComponent : function(){
        
        var defConfig = {
            plain: true,
            zoomLevel: 3,
            yaw: 180,
            pitch: 0,
            zoom: 0,
            gmapType: 'map',
            border: false,
            geoAccuracyWarning: false
        };
        
        Ext.applyIf(this,defConfig);
        
        Ext.ux.GMapPanel.superclass.initComponent.call(this);        
    },

    afterRender : function(){
        var wh = this.ownerCt.getSize();
        Ext.applyIf(this, wh);
        
        Ext.ux.GMapPanel.superclass.afterRender.call(this);    
        
        if (this.gmapType === 'map')
            this.gmap = new GMap2(this.body.dom);
        
        if (this.gmapType === 'panorama')
            this.gmap = new GStreetviewPanorama(this.body.dom);
        
        GEvent.bind(this.gmap, 'load', this, this.onMapReady);
        
        if (typeof this.addControl == 'object' && this.gmapType === 'map')
            this.gmap.addControl(this.addControl);
        
        if (typeof this.setCenter === 'object') {
            if (typeof this.setCenter.geoCodeAddr === 'string'){
                this.setMapCenter(this.setCenter.geoCodeAddr,this.setCenter.marker);
            } else {
                if (this.gmapType === 'map'){
                    var point = new GLatLng(this.setCenter.lat,this.setCenter.lng);
                    this.gmap.setCenter(point, this.zoomLevel);
                }
/*
                if (this.setCenter.marker && typeof this.setCenter.marker === 'object'
                    && typeof point === 'object') {
                    this.addMarker(point,this.setCenter.marker,this.setCenter.marker.clear);
                }
*/
            }
            if (this.gmapType === 'panorama') {
                this.gmap.setLocationAndPOV(new GLatLng(this.setCenter.lat,this.setCenter.lng),
                    {yaw: this.yaw, pitch: this.pitch, zoom: this.zoom});
            }
        }

    },

    onMapReady : function(){
        this.addMarkers(this.markers);
        this.addMapControls();
        this.addMapTypes();
        this.addOptions();  
        if ( !this.largeSizer )
            this.largeSizer = new GLargeMapControl();
        if ( !this.smallSizer )
            this.smallSizer = new GSmallMapControl();
        this.currentSizer = this.largeSizer;
    },

    onResize : function(w, h){
        if (typeof this.getMap() == 'object') {
            this.gmap.checkResize.defer(10,this.gmap);
            if ( h < 265 ) {
                if ( this.currentSizer === this.largeSizer ) {
                    this.removeMapControl(this.largeSizer);
                    this.addMapControl(this.currentSizer = this.smallSizer);
                }
            } else {
                if ( this.currentSizer === this.smallSizer ) {
                    this.removeMapControl(this.smallSizer);
                    this.addMapControl(this.currentSizer = this.largeSizer);
                }
            }
        }
        Ext.ux.GMapPanel.superclass.onResize.apply(this,arguments);
    },
    
    setSize : function(w, h, animate){
        if (typeof this.getMap() == 'object')
            this.gmap.checkResize();
        Ext.ux.GMapPanel.superclass.setSize.apply(this, arguments);
    },

    getMap : function(){
        return this.gmap;
    },

    getCenter : function(){
        return this.getMap().getCenter();
    },

    getCenterLatLng : function(){
        var ll = this.getCenter();
        return { lat: ll.lat(), lng: ll.lng() };
    },

    addMarkers : function(markers) {
        if (Ext.isArray(markers)) {
            for (var i = 0; i < markers.length; i++) {
                var mkr_point = new GLatLng(markers[i].lat,markers[i].lng);
                this.addMarker(mkr_point,markers[i].marker,false,markers[i].setCenter, markers[i].listeners);
            }
        }
    },

    addMarker : function(point, marker, clear, center, listeners){
        Ext.applyIf(marker,G_DEFAULT_ICON);

        if (clear === true)
            this.getMap().clearOverlays();
        if (center === true)
            this.getMap().setCenter(point, this.zoomLevel);

        var mark = new GMarker(point,marker);
        if (typeof listeners === 'object')
            for (evt in listeners)
                GEvent.bind(mark, evt, this, listeners[evt]);
        this.getMap().addOverlay(mark);
    },

    addMapControls : function(){
        if (this.gmapType === 'map') {
            if (Ext.isArray(this.mapControls)) {
                for(i=0;i<this.mapControls.length;i++){
                    this.addMapControl(this.mapControls[i]);
                }
            } else if(typeof this.mapControls === 'string') {
                this.addMapControl(this.mapControls);
            } else if(typeof this.mapControls === 'object') {
                this.getMap().addControl(this.mapControls);
            }
        }
    },

    addMapControl : function(mc){
        if ( typeof mc == 'string' ) { 
            var mcf = window[mc];
            if (typeof mcf === 'function') {
                var obj = new mcf();
               if ( mc == 'GLargeMapControl' )
                   this.largeSizer = obj;
               if ( mc == 'GSmallMapControl' )
                   this.smallSizer = obj;
            }
        } else
            obj = mc;
        if ( obj )
           this.getMap().addControl(obj);
    },

    removeMapControl : function(mc){
        this.getMap().removeControl(mc);
    },

    addMapTypes : function() {
        if (Ext.isArray(this.mapTypes)) {
            for(i=0;i<this.mapTypes.length;i++){
                this.addMapType(this.mapTypes[i]);
            }
        } else
            this.addMapType(this.mapTypes);
    },
    
    addMapType : function(mt){
        this.getMap().addMapType(mt);
    },

    addOptions : function(){
        if (Ext.isArray(this.mapConfOpts)) {
            var mc;
            for( i=0; i < this.mapConfOpts.length; i++ )
                this.addOption(this.mapConfOpts[i]);
        } else if(typeof this.mapConfOpts === 'string')
            this.addOption(this.mapConfOpts);
    },

    addOption : function(mc){
        var mcf = this.getMap()[mc];
        if (typeof mcf === 'function')
            this.getMap()[mc]();
    },

    geoCodeLookup : function(addr) {
        this.geocoder = new GClientGeocoder();
        this.geocoder.getLocations(addr, this.addAddressToMap.createDelegate(this));
    },

    setMapCenter : function(res,marker) {
        if ( res && typeof res == 'string' ) {
            this.geocoder = new GClientGeocoder();
            this.geocoder.getLocations(res, this.setMapCenter.createDelegate(this,[marker],true));
        } else {
            if (!res || res.Status.code != 200) {
                if ( res )
                    Ext.MessageBox.alert('Error', 'Geocode: Code '+res.Status.code+' Error Returned');
                else
                    Ext.MessageBox.alert('Error', 'Geocode: Error Returned');
            } else {
                place = res.Placemark[0];
                addressinfo = place.AddressDetails;
                accuracy = addressinfo.Accuracy;
                if (accuracy === 0) {
                    Ext.MessageBox.alert('Geocode Error', 'Unable to Locate the Address you provided');
                } else {
                    if (this.geoAccuracyWarning && accuracy < 7) {
                        Ext.MessageBox.alert('Geocode Warning', 'The address provided has a low accuracy.<br><br>Level '+accuracy+' Accuracy (8 = Exact Match, 1 = Vague Match)');
                    } else {
                        var pt = new GLatLng(place.Point.coordinates[1],place.Point.coordinates[0]);
                        if ( marker )
                            this.addMarker(pt,marker,false,true);
                        this.gmap.setCenter(pt, this.zoomLevel);
                    }
                }
            }
        }
    },

    addAddressToMap : function(response) {
        if (!response || response.Status.code != 200) {
            Ext.MessageBox.alert('Error', 'Code '+response.Status.code+' Error Returned');
        } else {
            place = response.Placemark[0];
            addressinfo = place.AddressDetails;
            accuracy = addressinfo.Accuracy;
            if (accuracy === 0) {
                Ext.MessageBox.alert('Geocode Error', 'Unable to Locate the Address you provided');
            } else {
                if (this.geoAccuracyWarning && accuracy < 7) {
                    Ext.MessageBox.alert('Geocode Warning', 'The address provided has a low accuracy.<br><br>Level '+accuracy+' Accuracy (8 = Exact Match, 1 = Vague Match)');
                } else {
                    point = new GLatLng(place.Point.coordinates[1], place.Point.coordinates[0]);
                    if (this.setCenter.marker && typeof this.setCenter.marker === 'object'
                        && typeof point === 'object') {
                        this.addMarker(point,this.setCenter.marker,this.setCenter.marker.clear,true, this.setCenter.listeners);
                    }
                }
            }
        }
    }
 
});

Ext.reg('gmappanel',Ext.ux.GMapPanel);