//COPY of dws_web_shop/../js/logging.js
//TODO: remove duplication by using sigle copy of logging.js
/*Logging subsystem, used for logging to Firefox Console-like object
 *    Enable/Disable logging controlled by logging members:
 *          debug,
 *          arguments,
 *          whitelist,
 *          backlist
 */
logging = {
    // logging configuration
    // do _never_ check the section below in!!!
    // do not use trailing comas in object definitions ever, that's a syntax error on IE and opera!!!!

    debug: false, 		/*Enabled function calls logging flag*/
    arguments: false,	/*Enable function arguments logging flag*/
    whitelist: {        /*Dictionary of names to be logged*/
    },
    blacklist: {        /*Dictionary of names to be ignored*/
        translator:true
    },

    _keys:function(data){
		/* Fetch data object properties as keys 
         * Copied from util.js due to dependencies conflict
         */
        var result = new Array();
        for(key in data){
            result.push(key);
        }
        return result;
    },

    // logging implementation
    match: function(parts, config, otherwise){
		/* Checks if parst connected by '.' are present in config as keys.
		 * Checked combinations of parts p0, p0.p1, p0.p1.p2, ...
		 * Return true in case of found correspondence.
		 * parts - list of names
		 * config - object whos properties used as dictionary
		 * otherwise - value returned in case of mismatch
		 */
        var keys = logging._keys(config);
        if(keys.length){
            for(var i=0; i<parts.length; i++){
                if(config[parts.slice(0, i+1).join('.')]){
                    return true;
                }
            }
            return false;
        }
        return otherwise;
    },
    decide:function(name){
		/* Checks is name is valid logging.
		 * It must match against not match against blacklist 
		 * and possibly be in whitelist.
		 * Checking performed only when debug flag is True.
		 * name - string with possible indication of parts by '.' separator
		 */
        if(logging.debug){
            if(name.length){ 
                var parts = name.split('.');
                var whitelisted = logging.match(parts, logging.whitelist, true);
                var blacklisted = logging.match(parts, logging.blacklist, false);
                return whitelisted && !blacklisted;
            }
            else{
                return true;
            }
        }
        else{
            return false;
        }
    },
    fun:function(name, fun){
		/* Decorates function if logging of it enabled.
		 * Performs function call with tracing colls and arguments to
		 * console object.
		 * Logs call fail information.
		 */
        if(logging.decide(name)){
            _fun_logger_impl = function(){
                console.group(name);
                try{
                    if(logging.arguments && arguments.length){
                        console.log('arguments:' + $.serializeJSON(arguments));
                    }
                }
                catch(e){}
                try{
                    var result = fun.apply(this, arguments);
                }
                catch(e){
                    console.error(e.name + ': ' + e.message);
                    console.groupEnd();
                    throw e;
                }
                console.groupEnd();
                return result;
            }
            return _fun_logger_impl;
        }
        else{
            return fun;
        }
    },
    ns:function(name){
		/* Creates logging namespace object with pointed name
		 * if logging enabled. Otherwise returns dummy namespace wrapper.
		 * Methods of namespace:
		 * 		fun() - logging function call
		 * 		ns() - creation of child logging namespace
		 * 		leave() - logging namespace finish
		 */
        if(logging.decide(name)){
            console.group(name);
            return {
                fun:function(fun_name, fun){
                    return logging.fun([name, fun_name].join('.'), fun);
                },
                ns:function(sub_name){
                    return logging.ns([name, sub_name].join('.'));
                },
                leave:function(){
                    console.groupEnd();
                }
            }
        }
        else{
            return {
                fun:function(fun_name, fun){
                    return fun;
                },
                ns:function(sub_name){
                    return logging.ns([name, sub_name].join('.'));
                },
                leave:function(){
                }
            }
        }
    }
}
TelusURL = util.inherits('TelusURL', URL, function(self, application, language){
    
    // basic stuff //
    self.images = function(){
        return base_path + '/images/';
    };
    self.login = function(fn){
        return $.sprintf(application.config('auth_url'), language) + '&fn=' + fn;
    };
    self.logout = function(){
        if(application.config('use_old_logout') == 'True'){
            return $.sprintf(application.config('logout_url'), language, language);
        }
        else{
            return application.config('logout_url');
        }
    };
    self.my_vault = function(params){
        return self.complete(base_path + '/lang/' + language + '/my_vault', params);
    };
    self.user_data = function(){
        return base_path + '/user/data';
    };

    self.save_settings = function(){
        return base_path + '/settings/save';
    };

    // bundle //
    self.bundle = function(bundle_id, params){
        return self.complete(base_path + '/lang/' + language + '/bundle/' + bundle_id, params);
    };
        self.bundle.in_library = function(bundle_id){
            return base_path + '/bundle/' + bundle_id + '/in_library';
        }
        self.bundle.purchase_pc = function(bundle_id){
            return base_path + '/bundle/' + bundle_id + '/purchase_pc';
        }
        self.bundle.purchase_pc_and_mobile = function(bundle_id){
            return base_path + '/bundle/' + bundle_id + '/purchase_pc_and_mobile';
        }
        self.bundle.license = function(bundle_id){
            // the fully qualified URL is used because the player doesn't support https
            return 'http://' + document.domain + base_path + '/bundle/' + bundle_id + '/license.sdcxml'
        }
        self.bundle.rent = function(bundle_id){
            return base_path + '/bundle/' + bundle_id + '/rent';
        }

    // track //
    self.track = function(track_id, params){
        return self.complete(base_path + '/lang/' + language + '/track/' + track_id, params);
    };
        self.track.in_library = function(track_id){
            return base_path + '/track/' + track_id + '/in_library';
        }
        self.track.purchase_pc = function(track_id){
            return base_path + '/track/' + track_id + '/purchase_pc';
        }
        self.track.purchase_pc_and_mobile = function(track_id){
            return base_path + '/track/' + track_id + '/purchase_pc_and_mobile';
        }
        self.track.rent = function(track_id){
            return base_path + '/track/' + track_id + '/rent';
        }
        self.track.license = function(track_id){
            // the fully qualified URL is used because the player doesn't support https
            return 'http://' + document.domain + base_path + '/track/' + track_id + '/license.sdcxml';
        }
        self.track.prelisten = function(track_id){
            return 'http://' + document.domain + base_path + '/track/' + track_id + '/prelisten.sdcxml';
        }
        self.track.reload_license = function(track_id){
            return base_path + '/track/' + track_id + '/reload_license';
        };

    // subscription //
    self.subscribe = function(){
        return base_path + '/subscribe';
    };

    self.unsubscribe = function(){
        return base_path + '/unsubscribe';
    }

    self.renew_master_license = function(){
        return base_path + '/renew_master_license';
    }

    self.master_license = function(){
        return 'http://' + document.domain + base_path + '/master_license.sdcxml';
    };

    self.free_tracks = function(){
        return application.config('base_path') + '/lang/' + language + '/promo';
    }

    self.free_tracks_licenses = function(){
        return application.config('base_path') + '/promo/fetch_licenses';
    }

    //License acqusition
    self.acquire_ppd_license = function(ext_package_id){
        return '/package/' + ext_package_id + '/license/ppd';
    };

    self.acquire_subscription_license = function(ext_package_id){
        return '/package/' + ext_package_id + '/license/subscription';
    };

    self.toggle_lang= function(language){
        return 'http://' + document.domain + base_path  + '/lang/' + language;
    };

    self.download_all_tracks_licenses = function(){
        return base_path + '/my_vault/download_all_licenses';
    }

    self.download_all_tracks = function(){
        return base_path + '/my_vault/download_all.sdcxml';
    }

    self.bulk_purchase = function(session_key){
        return base_path + '/bulk_license/' + session_key + '/purchase'
    }

    self.bulk_download = function(session_key){
        return base_path + '/bulk_license/' + session_key + '/download.sdcxml'
    }
});
TelusModal = util.inherits('TelusModal', Modal, function(self, alpha){
    var logger = logging.ns('telus.TelusModal');
    self.set_content = logger.fun('set_content', function(kwargs){
        var content  =  $(kwargs.template(kwargs).serialize());
        $.each(kwargs.actions || [], function(key, fun){
            $(key, content).bind('click', fun);
        });
        $('.cancel', content).bind('click', self.hide);
        self.elem.empty().append(content);
        self.center();
    });
    logger.leave();
});
TelusUser = util.klass('TelusUser', function(self, application, data){
    var logger = logging.ns('telus.TelusUser');
    self.__init__ = logger.fun('__init__', function(){
        if(data){
            $.extend(self, data)
        }
        else{
            self.has_content = false;
            self.subscriptions = {
                pc              : false, 
                mobile          : false,
                is_cancelled    : false,
                start_date      : null,
                end_date        : null
            };
            self.default_purchase = {pc:true, pc_and_mobile:false};
        }
    }),

    self.pc_only = logger.fun('pc_only', function(){
        if(self.subscriptions.pc && (!self.subscriptions.mobile)){
            return true;
        }
        else{
            return false;
        }
    });
    
    self.pc_and_mobile = logger.fun('pc_and_mobile', function(){
        if(self.subscriptions.pc && self.subscriptions.mobile){
            return true;
        }
        else{
            return false;
        }
    });

    self.subscription_license_type = logger.fun('subscription_license_type', function(){
        if(self.subscriptions.pc){
            if(self.subscriptions.mobile){
                return self.PC_AND_MOBILE;
            }
            else{
                return self.PC;
            }
        }
        return 'no-subscription';
    });
    
    self.PC_AND_MOBILE = 'PC+mobile';
    self.PC = 'PC';
    logger.leave();

});
Player = util.klass('Player', function(self, application){
    self.__init__ = function(){
        self.initializing = true;
        self.has_sound = false;
        self.sound_man = soundManager;
        self.sound_man.url = application.url.swf('');
        self.sound_man.debugMode = false;
        self.sound_man.onerror = function(){
            /*failed to initialize*/
            self.has_sound = false;
            self.initializing = false;
        }
        self.sound_man.onload = function(){
            self.has_sound = true;
            self.initializing = false;
            if(self.track_id_to_play){
                self.play(self.track_id_to_play);
            }
        }

        self.player = $('#left_column div.player');
        self.play_elem = self.player.find('div.play').bind('click', self.toggle);
        self.title = self.player.find('div.title');
        self.artist = self.player.find('div.artist');
        self.cover = self.player.find('div.cover');
    }

    self.can_play = function(){
        /*checks if playing is possible (no error with Flash initializing)*/
        return self.initializing || self.has_sound;
    }

    self.play = function(track_id){
        if(self.initializing){
            self.track_id_to_play = track_id;
            return;
        }
        application.data.track(track_id, {
            success : function(data){
                self.cover.empty();
                $('<img/>')
                    .appendTo(self.cover.empty())
                    .attr(
                        'src', 
                        application.cover_path(data.track.album_id, 77)
                    )
                   
                self.title.empty().append(data.track.title);
                self.artist.empty().append(data.track.artist);
               
                var sound = self.sound_man.getSoundById('audio_widget');
                if(sound){
                    self.sound_man.destroySound('audio_widget');
                    self.sound = null;
                };
                self.sound = self.sound_man.createSound({
                      id      : 'audio_widget',
                      url     : data.track.prelisten + '.mp3',
                      autoLoad: true,
                      autoPlay: false,
                      onload: function() {
                        self.sound.play();
                        self.play_elem.removeClass('play').addClass('pause');
                      },
                      volume: 100
                });
            }
        });
    }

    self._pause = function(){
        self.sound.pause();
        self.play_elem.removeClass('pause').addClass('play');
    }

    self._resume = function(){
        self.sound.resume();
        self.play_elem.removeClass('play').addClass('pause');
    }

    self.toggle = function(){
        if(self.sound){
            if(self.sound.paused){
                self._resume();
            }
            else{
                self._pause();
            }
        }
    }
});


var telus_app_logger = logging.ns('telus.application');

var TelusApplication = util.inherits('TelusApplication', Application, function(self, content, lang, js_trans, javascript_config, user_data, action){
    var logger = logging.ns('Application');
    self.content_scroll = 0;
    jQuery.history.init();
    self.__init__ = logger.fun('__init__', function(){


        self.message_elem = $('#message');
        self.message_main = $('div.main', self.message_elem);

        self.message_elem.hide();
        self.modal               = new TelusModal(self, 0.8);
        self.device              = new Cookie('device_id');
        self.public_key          = new Cookie('public_key');
        self.subscription_status = new Cookie('subscription_status');
        self.selected_ids        = new Cookie('selected_ids');
        self.render_right_column();
        if(!self.in_player()){
            self.player              = new Player(self);
        }
      
        if(self.in_player()){
            $('#telus').remove();
            $('#left_column').remove();
            $('#site')
                .width(
                    $('#main_column').width() + 
                    170 /*iurii: HACK for Safari: keep in sync with screen_layout.css!*/
/*                    $('#right_column').width()*/ + 1
                )
                .addClass('player');
        }
        else{
            $('#site').addClass('web');
        }

        console.log('device_id: ' + self.device.read());
        var need_login = {
            my_vault:                   true,
            get_subscription:           true,
            settings:                   true,
            bulk_license:               true
        }

        if(need_login[self.content.__type__]){
            if(!self.is_logged_in()){
                if(self._is_continue_login()){
                    if(self.content.session_key){
                        /*hack for bulk_license session management
                        TODO: refactor to make session available for other application
                        */
                        var device_id = self.device.read();
                        console.log('device_id: ' + device_id);
                        self.device.write();
                        self.login('bulk_license/' + self.content.session_key)
                    }
                    else{
                        self.login();
                    }
                    return;
                }
                else{
                    self._need_login_flag = true;
                }
            }
        }
        
        util.get_json({
            url     : self.url.images(),
            success : function(data){
                $.each(data, function(i, image){
                    util.safe_append('body', $('<img>').attr('src', image).css({
                        visibility: 'hidden',
                        height: 0,
                        width: 0
                    }));
                });
            }
        });
       
        self.hide_tabs();
        self.renew_master_license();

        if(action){
            if(content.__type__ == 'track'){
                self.buy_track(content.track.id);
            }
            else if(content.__type__ == 'bundle'){
                self.buy_bundle(content.bundle.id);
            }
        }

        if(content.__type__ == 'license_acqusition'){
            if(content.is_ppd){
                self.acquire_ppd_license(content.track);
            }
            else{
                self.acquire_subscription_license(content.track);
            }
        }
    });

    self.set_promo_tracks_selection_from_cookies = logger.fun('set_promo_tracks_selection_from_cookies', function(){
        if(self.selected_ids){
            selected_ids =  self.selected_ids.read();
            if(selected_ids){
                if(selected_ids.length > 0){
                    ids = selected_ids.split(',');
                    for(index in ids){
                        selector = '#promo input#track_' + ids[index];
                        $(selector).attr('checked', '1');
                    };
                    self.selected_ids.erase();
                    ids = self.get_selected_promo_tracks('#promo input.promo-checkbox:checked');
                    if(ids){
                        self.download_free_tracks(ids);
                    };
                };
            };
        };
    });

    self.acquire_ppd_license = logger.fun('acquire_ppd_license', function(track){
        if(self.is_logged_in()){
            if(self.in_player()){
               self.waiting_popup('loading_license');
               self.post_secure_json({
                   url     : self.url.track.reload_license(track.package_id),
                   success : function(data){
                        self.modal.hide();
                        util.post({
                            url     : self.url.track.license(track.id),
                            data    : data.data
                        });
                    },
                    error   : function(data, message){
                        self.modal.hide();
                        //self.message(message);
                        self.buy_track(track.id);
                    }
                });
            }
        }
        else {
            self.login(self.url.acquire_ppd_license(track.package_id));
        }
    });

    self.acquire_subscription_license = logger.fun('acquire_subscription_license', function(track){
        if(self.is_logged_in()){
            if(self.in_player()){
                if(self.user.subscriptions.pc){
                    self.add_track(track.id);
                } 
                else {
                    self.show_get_subscription();
                }
            }
        }
        else {
            self.login(self.url.acquire_subscription_license(track.package_id));
        }
    });

    self.show_get_subscription = logger.fun('show_get_subscription', function(){
        if(self.is_logged_in()){
            var show = function(){
                self.show_teaser();

                self.set_content({
                    __type__ : 'get_subscription',
                    __view__ : 'customer_widgets.get_subscription'
                });
                self.render_content();
            };

            if(self.user.subscriptions.pc && !self.user.subscriptions.start_date){
                self.reload_user(show);
            }
            else {
                show();
            } 
        } 
        else {
            if(self._is_continue_login()){
                self.login('get_subscription');
            }
        }
        return false;
    });

    self.show_terms_and_conditions = logger.fun('show_terms_and_conditions',function(){
        self.set_content({
            __type__ : 'terms_and_conditions',
            __view__ : 'customer_widgets.terms_and_conditions_text'
        });
        self.render_content();
        return false;
    });

    self.show_help = logger.fun('show_help',function(ignore_history){
        self.set_content({
            __type__ : 'help',
            __view__ : 'customer_widgets.help'
        });
        self.render_content();
        ignore_history || self.add_to_history(self.show_help, [true]);
        return false;
    });
    
    self.setup_tabs = logger.fun('setup_tabs',function(){
        self.drilldown      = new customer.Drilldown(self);
        self.search         = new customer.Search(self);
        self.active_tab     = self.drilldown;
        self.tabs           = [self.drilldown, self.search];
    });

    self.cover_path = logger.fun('cover_path',function(id, size){
        return $.sprintf(
            self.config('cover_resize_url'),
            id,
            size
        )
    });

    self.reload_user = logger.fun('reload_user',function(success){
        self.post_secure_json({
            url     : self.url.user_data(),
            success : function(data){
                self.user = new TelusUser(self, data);
                if(success){
                    success();
                }
            },
            error   : function(data, message){
                self.message(message);
            }
        });
    });

    self.init_user = logger.fun('init_user', function(){
        self.user = new TelusUser(self, user_data);
        if(!user_data && self.is_logged_in()){
            self.reload_user();
        }
    });

    self.render_right_column = logger.fun('render_right_column',function(){
        $('#right_column').empty();
        if(self.is_logged_in()){
            $('#right_column').append(
                customer_widgets.action_box({
                    trans           : self.trans,
                    subscription    : {
                        title   : self.user.subscriptions.pc ? self.trans('manage_subscription') : self.trans('get_subscription'), 
                        action  : 'application.show_get_subscription'
                    },
                    auth            : {
                        title   : self.trans('logout'),
                        action  : 'application.logout'
                    }
                }).serialize()
            );
        }
        else{
            $('#right_column').append(
                customer_widgets.action_box({
                    trans           : self.trans,
                    subscription    : {
                        title   : self.trans('get_subscription'),
                        action  : 'application.show_get_subscription'
                    },
                    auth            : {
                        title   : self.trans('login'),
                        action  : 'application.login'
                    }
                }).serialize()
            );
        }
        
        util.get_json({
            url     : self.url.fragment('featured.html'),
            success : function(data){
                $('#right_column').append(data.content);
                $('#right_column').append(
                    customer_widgets.my_vault_legend({
                        trans : self.trans
                    }).serialize()
                );
                if(self.content.__type__ == 'my_vault'){
                    self.show_legend();
                }
            }
        });
    });

    self.has_offer = logger.fun('has_offer',function(data){
        if('prices' in data && data.prices){
            if(('pc' in data.prices && typeof(data.prices.pc) == "number") || ('mobile_and_pc' in data.prices && typeof(data.prices.mobile_and_pc) == "number")
            ){
                return true;
            }
        }
        else if('offer_count' in data){
            if(data.offer_count > 0){
                return true;
            }
        }
        return false;
    });

    self.can_rent = logger.fun('can_rent',function(item){
        if(self.user && self.user.subscriptions && self.user.subscriptions.pc && self.in_player()){
            if(item.subscriptions > 0){
                return true;
            }
        }
        return false;
    });

    self.is_logged_in = logger.fun('is_logged_in',function(){
        if(self.user_cookie.read()){
            return true;
        }
        else{
            return false;
        }
    });

    self.in_player = logger.fun('in_player',function(){
        if(self.device.read() && self.public_key.read() && self.subscription_status.read()){
            return true;
        }
        else{
            return false;
        }
    });

    self.prelisten = logger.fun('prelisten',function(track_id){
        if(self.in_player()){
            self.navigate(self.url.track.prelisten(track_id));
            return false;
        }
        else if(self.player.can_play()){
            self.player.play(track_id);
            return false;
        }
        else{
            msg = self.trans('no_flex_player') + self.trans('flex_download');
            self.message(msg);
            return false;
        }
    });

    self.prelisten_url = logger.fun('prelisten_url',function(track){
        if(self.in_player()){
            self.url.track.prelisten(track.track_id);
        }
        else{
            return track.prelisten;
        }
    });

    self.renew_master_license = logger.fun('renew_master_license',function(){
        if(self.is_logged_in() && self.in_player()){
            if(self.user.subscriptions.pc){
                if(self.subscription_status.read() != '0'){
                    self.data.renew_master_license(function(data){
                        if(data.master_license){
                            self.subscription_status.write('0');
                            util.post({
                                url     : self.url.master_license(),
                                data    : data.master_license
                            });
                        }
                    });
                }
            }
        }
    });

    
    self.do_get_subscription = logger.fun('do_get_subscription',function(){
        var selection = $('#get_subscription > div.main > div.selection');
        //var get_pc_only = $('#subscription_pc_only')[0].checked;
        var get_pc_only = false; //pc_only disabled
        var get_pc_and_mobile = $('#subscription_pc_and_mobile')[0].checked;
        self.waiting_popup('creating_contract');
        var pc_confirm = function(){ 
            selection.slideExchange(customer_widgets.subscription_confirm({
                application : self,
                title       : self.trans('legend_pc_subscr')
            }).serialize());
        };
        var pc_and_mobile_confirm = function(){
            selection.slideExchange(customer_widgets.subscription_confirm({
                application : self,
                title       : self.trans('legend_pc_mobile_subscr')
            }).serialize());
        };

        if(get_pc_only){
            var subscriptions = {pc:true, mobile:false};
        }
        else if(get_pc_and_mobile){
            var subscriptions ={pc:true, mobile:true};
        }
        var generic_success = function(data, confirm_fun){
            self.user.subscriptions.pc = subscriptions.pc;
            self.user.subscriptions.mobile = subscriptions.mobile;

            self.modal.hide();
            self.render_right_column();

            confirm_fun();
            if(data.master_license){
                util.post({
                    url     : self.url.master_license(),
                    data    : data.master_license
                });
            }
        };
        var error = function(data, message){
            self.modal.hide();
            self.message(message);
        };
        if(get_pc_only){
            var success = function(data){generic_success(data, pc_confirm)};
            if(self.user.pc_only()){
                self.modal.hide();
            }
            else if(self.user.pc_and_mobile()){
                self.data.unsubscribe({pc:false, mobile:true}, success, error);
            }
            else{
                self.data.subscribe({pc:true, mobile:false}, success, error);
            }
        }
        else if(get_pc_and_mobile){
            var success = function(data){generic_success(data, pc_and_mobile_confirm)};
            if(self.user.pc_only()){
                self.data.subscribe({pc:false, mobile:true}, success, error);
            }
            else if(self.user.pc_and_mobile()){
                self.modal.hide();
            }
            else{
                self.data.subscribe({pc:true, mobile:true}, success, error);
            }
        }
    });
    
    self.get_subscription = logger.fun('get_subscription',function(){
        if(self.user.subscriptions.pc || self.user.subscriptions.mobile){
            if(self.user.subscriptions.is_cancelled){
                self.subscription_terms();
            }
            else{
                self.do_get_subscription();
            }
        }
        else{
            self.subscription_terms();
        }
    });

    self.add_bundle = logger.fun('add_bundle',function(bundle_id){
        self.waiting_popup('loading_license');
        util.post_secure_json({
            url     : self.url.bundle.rent(bundle_id),
            success : function(data){
                self.modal.hide();
                util.post({
                    url : self.url.bundle.license(bundle_id),
                    data : {
                        tracks : data.data.tracks,
                        title : data.data.title,
                        license_type : self.user.subscription_license_type()
                    }
                });
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        })
    });

    self.add_track = logger.fun('add_track', function(track_id){
        self.waiting_popup('loading_license');
        util.post_secure_json({
            url     : self.url.track.rent(track_id),
            success : function(data){
                self.modal.hide();
                util.post({
                    url : self.url.track.license(track_id),
                    data : {
                        license : data.data,
                        license_type : self.user.subscription_license_type()
                    }
                });
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        })
    });

    self.do_buy = logger.fun('do_buy', function(content_id, url, purchase_url, content, confirmed_redownload){
        util.post_secure_json({
            data    : { content_type : content.__type__ },
            url     : url.in_library(content_id),
            success : function(data){
                if (confirmed_redownload) {
                    self.perform_actual_buy(content_id, url, purchase_url);
                } else {
                    self.modal.show({
                        application         : self,
                        trans               : self.trans,
                        title               : self.trans('redownload_warning'),
                        pc_price            : content.prices.pc,
                        pc_and_mobile_price : content.prices.mobile_and_pc,
                        content             : content,
                        actions             : {
                            '.buy_song' : function(){
                                url = self.url[content.__type__]
                                self.do_buy(
                                    content.id,
                                    url,
                                    url.purchase_pc_and_mobile(content.id),
                                    content,
                                    true
                                );
                            }
                        },
                        template    : customer_widgets.redownload_warning
                    });
                }
            },
            error   : function(data, message){
                self.perform_actual_buy(content_id, url, purchase_url);
            }
        });
    });

    self.perform_actual_buy = logger.fun('perform_actual_buy', function(content_id, url, purchase_url){
        self.waiting_popup('loading_license');
        util.post_secure_json({
            url     : purchase_url,
            success : function(data){
                self.modal.hide();
                self.user.has_content = true;
                if(self.in_player()){
                    self.message(application.trans('purchase_success'));
                    // self.navigate(url.license(content_id, data.license));
                    util.post({
                        url : url.license(content_id),
                        data : data.data
                    });
                }
                else{
                    self.message(application.trans('purchase_success_my_vault'));
                }
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        });
    });

    self.message = logger.fun('message', function(data){
        self.message_main.empty().append(
            $('<p/>').append(data)
        );
        self.message_elem.slideDown('slow');
    });

    self.hide_message = function(){
        self.message_main.empty();
        self.message_elem.slideUp('fast');
    };

    self.confirm_buy = logger.fun('confirm_buy', function(content){
        self.modal.show({
            application         : self,
            trans               : self.trans,
            title               : self.trans('buy_selection_description'),
            pc_price            : content.prices.pc,
            pc_and_mobile_price : content.prices.mobile_and_pc,
            content             : content,
            actions             : {
                '.buy_song' : function(){
                    url = self.url[content.__type__]
                    self.do_buy(
                        content.id,
                        url,
                        url.purchase_pc_and_mobile(content.id),
                        content,
                        false
                    );
                }
            },
            template    : customer_widgets.buy_popup
       });
    });

    self.first_purchase = logger.fun('first_purchase', function(content){
        self.modal.show({
            application     : self,
            trans           : self.trans,
            lang            : self.language,
            template        : customer_widgets.terms_and_conditions,
            content         : content,
            actions         : {
                '.continue'     : function(){
                    if($('#modal input[type=checkbox]').attr('checked')){
                        self.confirm_buy(content);
                    }
                    else{
                        $('#modal div.terms_read').pulse();
                    }
                }
            }
        });
    });
    
    self.subscription_terms = logger.fun('subscription_terms', function(){
        self.modal.show({
            application     : self,
            trans           : self.trans,
            lang            : self.language,
            template        : customer_widgets.terms_and_conditions,
            actions         : {
                '.continue'     : function(){
                    if($('#modal input[type=checkbox]').attr('checked')){
                        self.do_get_subscription();
                    }
                    else{
                        $('#modal div.terms_read').pulse();
                    }
                }
            }
        });
    });

    self._is_continue_login = function(){
        if(self.config('no_automatic_login') == 'True')
        {
            self.message(self.trans('need_login'));
            return false;
        }
        return true;
    }

    self.buy_track = logger.fun('buy_track', function(track_id){
        if(self.is_logged_in()){
            self.data.track(track_id, {
                success : function(data){
                    if(self.user.has_content){
                        if(data.track.prices){
                            self.confirm_buy(data.track);
                        }
                        else{
                            self.modal.hide();
                            self.message(self.trans('cannot_buy_track'));
                            self.show_track(track_id);
                        }
                    }
                    else{
                        self.first_purchase(data.track);
                    }
                },
                loading : self.waiting_popup
            });
        }
        else{
            if(self._is_continue_login()){
                self.navigate(self.url.login($.serializeJSON({
                    path: 'track/' + track_id + '/buy'
                })));
            }
        }
    });

    self.waiting_popup = logger.fun('waiting_popup', function(title_key){
        var title = self.trans(title_key || 'fetching_data');
        self.waiting_popup_with_title(title);
    });

    self.waiting_popup_with_title = logger.fun('waiting_popup_with_title', function(title){
        self.modal.show({
            application : self,
            title       : title,
            template    : customer_widgets.waiting_popup
        });
    });

    self.buy_bundle = logger.fun('buy_bundle', function(bundle_id){
        if(self.is_logged_in()){
            self.data.bundle(bundle_id, {
                success : function(data){
                    if(self.user.has_content){
                        self.confirm_buy(data.bundle);
                    }
                    else{
                        self.first_purchase(data.bundle);
                    }
                },
                loading : self.waiting_popup
            });
        }
        else{
            if(self._is_continue_login()){
                self.navigate(self.url.login($.serializeJSON({
                    path: 'bundle/' + bundle_id + '/buy'
                })));
            }
        }
    });

    self.content_sub_path = logger.fun('content_sub_path', function(){
        switch(self.content.__type__){
            case 'track':
                return $.sprintf('track/%s', self.content.track.id);
            case 'bundle':
                return $.sprintf('bundle/%s', self.content.bundle.id);
            case 'fragment':
                return $.sprintf('fragment/file/%s', self.content.filename);
            default:
                return self.content.__type__
        }
    });

    self.login = logger.fun('login', function(path){
        // self.basket.save(); #FIXME enable this as soon as the cart is provided
        self.navigate(self.url.login($.serializeJSON({
            path: path || self.content_sub_path()
        })));
    });

    self.logout = logger.fun('logout', function(){
        self.user_cookie.erase();
        self.navigate(self.url.logout());
    });

    self.show_track = logger.fun('show_track', function(track_id, ignore_history){
        self.show_teaser();

        self.data.track(track_id, {success:function(data){
            self.set_content(data);
            self.render_content();
        }});
        ignore_history || self.add_to_history(self.show_track, [track_id, true]);
        return false;
    });

    self.show_bundle = logger.fun('show_bundle', function(bundle_id, ignore_history){
        self.data.bundle(bundle_id, {success:function(data){
            self.set_content(data);
            self.render_content();
        }});
        ignore_history || self.add_to_history(self.show_bundle, [bundle_id, true]);
        return false;
    });

    self.unfold_artist_albums = logger.fun('unfold_artist_albums', function(){
        $('<a/>').addClass('unfold')
            .append(self.trans('see_less'))
            .unbind()
            .bind('click', self.fold_artist_albums)
            .replaceAll(this);

        $('#artist_albums').empty().append(customer_widgets.artist_albums({
            artist_albums: self.content.artist_albums.albums,
            application: self
        }).serialize());
    });

    self.fold_artist_albums = logger.fun('fold_artist_albums', function(){
        $('<a/>').addClass('unfold')
            .append(self.trans('see_all'))
            .unbind()
            .bind('click', self.unfold_artist_albums)
            .replaceAll(this);

        $('#artist_albums').empty().append(customer_widgets.artist_albums({
            artist_albums: genshi2js.slice(self.content.artist_albums.albums, null, 4, null),
            application: self
        }).serialize());
    });
        
    self.render_widgets = logger.fun('render_widgets', function(){
        $.each(self.tabs, function(i, tab){
            tab.update();
            if(tab === self.active_tab){
                tab.show();
                tab.render_breadcrumb();
                tab.render_actions();
                tab.render_sub_navigation();
            }
            else{
                tab.hide();
            }
        });
        self.render_mainnav();
        
        self.search.add_shortcuts();
    });

    self.set_content = logger.fun('set_content', function(data){
        self.content = data;
        self.content_template = eval(data.__view__);
    });

    self.render_content = logger.fun('render_content', function(dont_scroll){
        var params = {application:self, content:self.content, trans:self.trans};
        if(!dont_scroll){
            setTimeout(function(){ // IE hack
                if( $.browser.msie ){
                    $('#ganre-carousel').remove();
                }
                $('#scroller').scrollTo( 
                    $(self.content_template(params).serialize()).appendTo('#content'),
                    {axis:'x', speed:750, onAfter:function(){
                        var items = $('#content > div');
                        if(items.size() > 1){
                            $('#content > div').eq(0).remove();
                            $('#scroller').get(0).scrollLeft = 0;
                        }
                        else{
                            $('#ganre-carousel').jcarousel({ 
//                            $('#ganre-carousel').paging_jcarousel({ 
                                scroll : 4,
                                page_mark_html : ' <div class="carousel-page-mark"/> ',
                                buttonNextHTML : '<div><div class="arrow-right"></div><div class="navigation-next">' + self.trans('next_label') + '&nbsp;&nbsp;</div>',
                                buttonPrevHTML :  ' <div><div class="arrow-left"></div><div class="navigation-prev">&nbsp;' + self.trans('previous_label') + '</div></div>'
                            });
                        }
                        self.set_promo_tracks_selection_from_cookies();
                        if( self._need_login_flag ){
                            self._is_continue_login();
                            self._need_login_flag = false;
                        }
                        else{
                            self.hide_message();
                        }
                    }}
                );
            }, 0)
        }
    });
    
    self.show_my_vault = logger.fun('show_my_vault', function(is_downloaded, show_channel, inclusive){
        if(self.is_logged_in()){
            params = {
                is_downloaded   : is_downloaded || false,
                show_channel    : show_channel || 'all',
                inclusive       : inclusive || false
            };
            self.waiting_popup()
            self.data.my_vault(
                params, 
                function(data){
                    self.modal.hide();
                    self.set_content(data);
                    self.render_content();
                    self.hide_tabs();
                    self.show_legend();
                },
                function(data){
                    self.modal.hide();
                    self.message(data.message);
                }
            );
        } else {
            if(self._is_continue_login()){
                self.login();
            }
        }
        return false;
    });

    self.show_legend = logger.fun('show_legend', function(){
        $('.right_teaser').hide();
        $('#my_vault_legend').show();
    });

    self.show_teaser = logger.fun('show_teaser', function(){
        $('.right_teaser').show();
        $('#my_vault_legend').hide();
    });

    self.reload_license = logger.fun('reload_license', function(track_id, ext_package_id, is_ppd, is_subscription, reloads_left, ppd_license_type){
        if(self.in_player()){
            var track = {
                id          : track_id,
                package_id  : ext_package_id
            };
            
            var is_multiple = is_ppd && is_subscription;
            var is_subscription = is_subscription && !is_ppd;
            if(is_multiple){
                if(reloads_left > 0){
                    self.confirm_reload(track, ppd_license_type);
                } else {
                    self.do_reload(track, self.url.track.rent(track.id), ppd_license_type);
                }
            } else if(is_subscription) {
                var license_type = self.user.subscription_license_type();
                self.do_reload(track, self.url.track.rent(track.id), license_type);
            } else {
                self.do_reload(track, self.url.track.reload_license(track.package_id), ppd_license_type);        
            }
        } else {
            self.message(self.trans('need_device'));
        }
    });

    self.do_reload = logger.fun('do_reload', function(track, url, license_type){
        self.waiting_popup('loading_license');
        util.post_secure_json({
            url     : url,
            data    : { license_type : license_type },
            success : function(data){
                self.modal.hide();
                util.post({
                    url     : self.url.track.license(track.id),
                    data : {
                        license : data.data,
                        license_type : license_type
                    }
                });
                self.show_my_vault(
                    self.content.is_downloaded,
                    self.content.show_channel,
                    self.content.inclusive
                );
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        });
    });
    
    self.confirm_reload = logger.fun('confirm_reload', function(track, ppd_license_type){
        self.modal.show({
            application : self,
            trans       : self.trans,
            title       : self.trans('choose_license_type'),
            template    : customer_widgets.reload_license_popup,
            actions     : {
                '.continue' : function(){
                    var checked = null;
                    $('input', self.modal.elem).each(function(i, node){
                        if(node.checked){
                            checked = node.value;
                        }
                    });
                    
                    if(checked == 'ppd'){
                        self.do_reload(track, self.url.track.reload_license(track.package_id), ppd_license_type);
                    }
                    else if(checked == 'subscription'){
                        var license_type = self.user.subscription_license_type();
                        self.do_reload(track, self.url.track.rent(track.id), license_type);
                    }
                }
            }
        });
    });
    
    var show_fragment_seeall_start = logger.fun('show_fragment_seeall_start', function(target){
        return $('<a/>').append(self.trans('loading'))
            .unbind()
            .replaceAll(target);
    });

    self.show_fragment_seeall_finish = logger.fun('show_fragment_seeall_finish', function(target, file_name, section_name){
        if(typeof(target) == 'undefined')
            return;
        $('<a/>').append(self.trans('see_all'))
                 .unbind()
                 .bind('click', [file_name, section_name], self.show_fragment_seeall)
                 .replaceAll(target);
    });

    self.add_to_history = logger.fun('add_to_history', function(handler, params){
        $.history.register(function(){
                handler.apply(self, params);
                }, {});
    });

    self.show_fragment_seeall = logger.fun('show_fragment_seeall', function(file_name, section_name){
        var target_obj = this;
        var fname = file_name;
        var sname = section_name;
        if(typeof(fname) != 'string'){
            fname = file_name.data[0];
            sname = file_name.data[1];
        };
        var res = self.show_fragment(fname, sname, target_obj, true);
        self.add_to_history(self.show_fragment, [fname, sname, fname.undefined_obj, true]);
        return res;
    });

    
    self.show_fragment = logger.fun('show_fragment', function(file_name, section_name, target, ignore_history){
        var target_obj = target;
        if(typeof(target) != 'undefined'){
            target_obj = show_fragment_seeall_start(target);
        }
        util.get_json({
            url     : self.url.fragment(file_name, section_name),
            success : function(data){
                self.set_content(data);
                self.show_fragment_seeall_finish(target_obj, file_name, section_name);
                self.render_content();
            },
            error: function(){
                self.show_fragment_seeall_finish(target_obj, file_name, section_name);
            }
        });
        ignore_history || self.add_to_history(self.show_fragment, [file_name, section_name, file_name.undefined_obj, true]);
        return false;
    });

    self.toggle_lang = logger.fun('toggle_lang', function(lang){
        window.location.href=self.url.toggle_lang(lang);
        return true;
    });

    self.show_cancel_subscription = logger.fun('show_cancel_subscription', function(){
        $('#cancellation > .wizard').slideExchange(
            customer_widgets.cancel_subscription({
                trans       : self.trans,
                application : self
            }).serialize()
        );
    });

    self.confirm_cancel_subscription = logger.fun('confirm_cancel_subscription', function(){
        var agreed_checkbox = $('#agreed')[0];
        if(agreed_checkbox.checked){
            self.cancel_subscription();
        }
        else{
            $('.option').pulse();
        }
        return false;
    });

    self.cancel_subscription = logger.fun('cancel_subscription', function(){
        var data = {
            pc              : self.user.subscriptions.pc, 
            mobile          : self.user.subscriptions.mobile
        };
        
        var success = function(data){
            self.user.subscriptions.is_cancelled = true;
            
            //var pc_only = $('#subscription_pc_only')[0];
            var pc_only = false; //pc only disabled
            var pc_and_mobile = $('#subscription_pc_and_mobile')[0];
            if(pc_only){
                pc_only.disabled = true;
            }
            if(pc_and_mobile){
                pc_and_mobile.disabled = true;
            }
            
            $('.selection > .button').hide();
            $('#cancellation > .wizard').slideExchange(
                 customer_widgets.cancel_subscription_success({
                    trans       : self.trans,
                    application : self
                 }).serialize()
            );
        };

        var error = function(data, message){
            self.message(message);
        };

        self.data.unsubscribe(data, success, error);
 
        return false;
    });
    
    self.unfold_cancel_subscription = logger.fun('unfold_cancel_subscription', function(){
        var wizard = $('#cancellation > .wizard');
        $('<div/>')
            .addClass('icon fold')
            .unbind()
            .bind('click', self.fold_cancel_subscription)
            .replaceAll(this);

        if(wizard.children().length > 0){
            wizard.show();
        }
        else{
            wizard.append(
                customer_widgets.cancel_subscription({
                    trans       : self.trans,
                    application : self
                }).serialize()
            );
            $('#cancellation > .wizard').show();
        }
    });

    self.fold_cancel_subscription = logger.fun('fold_cancel_subscription', function(){
        $('<div/>')
            .addClass('icon unfold')
            .unbind()
            .bind('click', self.unfold_cancel_subscription)
            .replaceAll(this);

        $('#cancellation > .wizard').hide();
    });

    self.load_free_tracks_data = logger.fun('load_free_tracks_data', function(handlers){
        if(handlers.loading){
            handlers.loading();
        }
        util.get_json({
            url     : self.url.free_tracks(),
            success : function(data){
                handlers.success(data);
            }
        });
    });

    self.show_free_tracks = logger.fun('show_free_tracks', function(ignore_history){
        self.show_teaser();
        self.load_free_tracks_data( {
                success:function(data){
                    self.set_content(data);
                    self.render_content();
        }});
        ignore_history || self.add_to_history(self.show_free_tracks, [true]);
        return false;
    });

    self.download_free_tracks = logger.fun('download_free_tracks', function(track_ids){
        self.waiting_popup('downloading_free_tracks');
        util.post_secure_json({
            url     : self.url.free_tracks_licenses(),
            data : {tracks : track_ids},
            success : function(data){
                self.modal.hide();
                self.user.has_content = true;
                self.message(application.trans('download_free_tracks_success'));
                util.post({
                    url : self.url.bundle.license('free-tracks'),
                    data : data.data
                });
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        });
    });

    self.get_selected_promo_tracks = logger.fun('get_selected_promo_tracks ', function(checkboxes_selector){
        ids = [];
        $(checkboxes_selector).each(function(index, checkbox){
            ids.push(checkbox.id.substr(6));
        });
        return ids;
    });

    self.multiple_download = logger.fun('multiple_download', function(checkboxes_selector){
        ids = self.get_selected_promo_tracks(checkboxes_selector);
        if(ids.length == 0)
            return;

        if(!self.in_player()){
            var msg = application.trans('free_tracks_for_player_only_1');
            msg = msg + self.config('player_download_url');
            msg = msg + application.trans('free_tracks_for_player_only_2')
            self.message(msg);
            return
        }

        if(!self.is_logged_in()){
            if(self._is_continue_login()){
                self.selected_ids.write(ids.join(','));
                self.login('/promo'); /*TODO:refactor: move in config*/
            }
        }
        else{
            self.download_free_tracks(ids);
        }
    });

    self._download_all_by_chunks = logger.fun('download_chunk_of_all_licenses', function(chunk_size, ids_to_ignore, tracks){
        /*Download track licenses by chunks*/
        /*TODO: progress indication with numbers of processed*/
        util.post_secure_json({
            url     : self.url.download_all_tracks_licenses(),
            data : { 
                chunk_size : chunk_size,
                ids_to_ignore : ids_to_ignore,
                tracks : tracks
            },
            success : function(data){
                if(data.remains_count > 0){
                    self.waiting_popup_with_title(self.trans('left_to_load') + data.remains_count.toString());
                    self._download_all_by_chunks(chunk_size, data.ids_to_ignore, data.tracks);
                }
                else{
                    self.waiting_popup('downloading_all_tracks');
                    util.post({
                        url : self.url.download_all_tracks(),
                        data : data.tracks
                    });
                    self.modal.hide();
                    self.user.has_content = true;
                    self.message(application.trans('download_all_tracks_success'));
                    self.show_my_vault( true, 'all', false);
                }
            },
            error   : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        });
    });

    self.download_all = logger.fun('download_all_licenses', function(){
        self.waiting_popup('loading_license');
        self._download_all_by_chunks(5, [], []); 
    });

    self.bulk_download = logger.fun('bulk_download', function(){
        /* finding subdcription type to use for purchase */
        var DEFAULT_PC_MOBILE = 'pc_and_mobile';
        var get_sub_tracks = function(){ /*list of sub tracks as string */
            return $('#bulk_license div.sub_tracks').text();
        };
        var get_sub_type = function(sub_tracks_str){/*type of subscription to use for SUB tracks*/
            var sub_type = 'undefined';
            var sub_checkbox = $('#make_subscription:visible');
            if(sub_checkbox && sub_checkbox.length){
                if(sub_checkbox[0].checked){
                    sub_type = DEFAULT_PC_MOBILE;
                }
                else{
                    sub_type = 'skip';
                };
            }
            else{
                if(sub_tracks_str.length){
                    sub_type = 'current';
                }
                else{
                    sub_type = 'skip';
                };
            };
            return sub_type;
        };
        var sub_tracks = get_sub_tracks();
        var sub_type = get_sub_type(sub_tracks);

        /*finding ppd type to use*/
        var get_ppd_tracks = function(ppd_tracks_str){
            return $('#bulk_license div.ppd_tracks').text();
        };
        var get_ppd_type = function(ppd_tracks_str){
            var ppd_type = 'undefined'
            if(ppd_tracks_str.length){
                ppd_type = DEFAULT_PC_MOBILE;
            }
            else{
                ppd_type = 'skip';
            }
            return ppd_type;
        }

        var ppd_tracks = get_ppd_tracks();
        var ppd_type = get_ppd_type(ppd_tracks);

        /*confirm purchase selection*/
        var select_sub_type = false;
        if(sub_type == 'select'){
            select_sub_type = true;
        }
        var select_ppd_type = false;
        if(ppd_type == 'select'){
            select_ppd_type = true;
        }
        /*extract prices info*/
        var ppd_pc_mobile_price = $('#bulk_license div.ppd_pc_mobile_price').text();
        var sub_pc_mobile_price = $('#bulk_license div.sub_pc_mobile_price').text();
        console.log('SUB-TRACKS:"' + sub_tracks + '"');
        console.log('PPD-TRACKS:"' + ppd_tracks + '"');
        self.modal.show({
            application : self,
            trans       : self.trans,
            title       : self.trans('bulk_license_purchase_confirmation'),
            template    : customer_widgets.bulk_confirm,
            content     : {
                selected_sub_type : sub_tracks.length > 0, 
                selected_ppd_type : ppd_tracks.length > 0,
                sub_price : sub_pc_mobile_price,
                ppd_price : ppd_pc_mobile_price
            },
            actions     : {
                '.continue' : function(){
                    var session_key = $('#bulk_license div.session_key').text();
                    var task_data = {
                        sub_type_purchase : sub_type,
                        sub_tracks : sub_tracks,
                        ppd_type_purchase : ppd_type,
                        ppd_tracks : ppd_tracks,
                        session_key : session_key
                    };
                    /*alert('Selected SUB: ' + sub_type + '.\n Selected PPD: ' + ppd_type + '\nSUB tracks: ' + sub_tracks + '\nPPD tracks: ' + ppd_tracks);*/
                    if(sub_type != 'skip' && sub_type != 'current'){
                        self.waiting_popup('creating_contract');
                        var error_handler = function(data, message){
                            self.modal.hide();
                            self.message(message);
                        };
                        var success_handler = function(data){
                            self.do_bulk_purchasing(task_data);
                        }
                        self.data.subscribe({pc: true, mobile : true},
                                            success_handler, error_handler);
                    }else if(ppd_type != 'skip'){
                        self.do_bulk_purchasing(task_data);
                    }
                }
            }
        });
    });
    self.do_bulk_purchasing = logger.fun('do_bulk_purchasing', function(task_data){
        self.waiting_popup('bulk_purchasing');
        util.post_secure_json({
            url : self.url.bulk_purchase(task_data.session_key),
            data: task_data,
            success : function(data){
                self.modal.hide();
                self.message(self.trans('bulk_purchase_successful'));
                self.do_bulk_downloading(data);
            },
            error : function(data, message){
                self.modal.hide();
                self.message(message);
            }
        });
    });

    self.do_bulk_downloading = logger.fun('do_bulk_downloading', function(data){
        self.waiting_popup('bulk_downloading');
        util.post({
            url : self.url.bulk_download(data.session_key),
            data: data
        });
        self.modal.hide();
    });

    logger.leave();
 
});
telus_app_logger.leave();
TelusDrilldown = util.inherits('TelusDrilldown', Drilldown, function(self, application){
    var logger = logging.ns('telus.TelusDrilldown');
    self.handle_obj_click = logger.fun('handle_obj_click', function(obj_id){
        application.show_track(obj_id);
    });

    self.render_sub_navigation = logger.fun('render_sub_navigation', function(){
        self.sub_navigation.empty().append(customer_widgets.sub_navigation(self.root_data).serialize());
    });
    
    self.drill_to_top = logger.fun('drill_to_top', function(type, id, attr_id, title){
        application.show_tabs();
        self.handle_click(null, type, id, attr_id, title)
    });
    logger.leave();
});
var telus_data_logger = logging.ns('telus.data');
TelusData = util.inherits('TelusData', Data, function(self, application){
    var logger = logging.ns('TelusData');
    self.tracks = {};
    self.bundles = {};
    self.fragments = {};

    self.add_track = logger.fun('add_track', function(content){
        self.tracks[content.track.id] = content;
    });

    self.add_bundle = logger.fun('add_bundle', function(content){
        self.bundles[content.bundle.id] = content;
    });

    self.add_fragment = logger.fun('add_fragment', function(content){
        self.fragments[content.filename] = content;
    });
    
    self.track = logger.fun('track', function(track_id, handlers){
        data = self.tracks[track_id];
        if(data){
            handlers.success(data);
        }
        else{
            if(handlers.loading){
                handlers.loading();
            }
            util.get_json({
                url     : application.url.track(track_id),
                success : function(data){
                    self.add_track(data);
                    handlers.success(data);
                }
            });
        }
    });

    self.bundle = logger.fun('bundle', function(bundle_id, handlers){
        data = self.bundles[bundle_id];
        if(data){
            handlers.success(data);
        }
        else{
            if(handlers.loading){
                handlers.loading();
            }
            util.get_json({
                url     : application.url.bundle(bundle_id),
                success : function(data){
                    self.add_bundle(data);
                    handlers.success(data);
                }
            });
        }
    });

    self.my_vault = logger.fun('my_vault', function(params, success, error){
        util.post_secure_json({
            url     : application.url.my_vault(),
            success : success,
            error   : error,
            data    : params
        });
    });

    self.subscribe = logger.fun('subscribe', function(channels, success, error){
        util.post_secure_json({
            url     : application.url.subscribe(),
            success : success,
            error   : error,
            data    : channels
        });
    });

    self.renew_master_license = logger.fun('renew_master_license', function(success){
        util.post_secure_json({
            url         : application.url.renew_master_license(),
            success     : success,
            data        : {
                subscription_status : application.subscription_status.read()
            },
            cookie_name : application.config('user_cookie')
        });
    });
    
    self.unsubscribe = logger.fun('unsubscribe', function(channels, success, error){
        util.post_secure_json({
            url     : application.url.unsubscribe(),
            success : success,
            error   : error,
            data    : channels
        });
    });
    logger.leave();
});
telus_data_logger.leave();
TelusSearch = util.inherits('TelusSearch', Search, function(self, application){
    var logger = logging.ns('telus.TelusSearch');
    var search_by = 'all'
    var sort_by;
    var term = '';
    var term_with_prefix;
    var count = '';
    var search_by_options = [
        {
            title   : application.trans('search_by_all'),
            key     : 'all' 
        },
        {
            title   : application.trans('songs'),
            key     : 'songs' 
        },
        {
            title   : application.trans('artists'),
            key     : 'artist'
        },
        {
            title   : application.trans('album'),
            key     : 'album'
        }
    ];
    
    self.add_shortcuts = logger.fun('add_shortcuts', function(){
        $('#searchbox').keypress(function(event){
            var code = shortcut.keycode(event);
            if(code == shortcut.KEY_RETURN){
                self.do_search();
            } else{
                event.stopPropagation();
            }
        });
    });
    
    self.tab_data = logger.fun('tab_data', function(){
        return {
            content     : customer_widgets.search_button({
                application : application,
                term        : term
            }),
            css_class   : 'search_button'
        };
    });

    self.render_breadcrumb = logger.fun('render_breadcrumb', function(){
        application.breadcrumb.empty().append(
            customer_widgets.search_breadcrumb({
                trans : application.trans
            }).serialize()
        );
    });
    
    self.render_sub_navigation = logger.fun('render_sub_navigation', function(){
        self.sub_navigation.empty().append(
            customer_widgets.search_sub_navigation({
                application     : application,
                options         : search_by_options,
                search_by_key   : search_by
            }).serialize()
        );
    });

    self.render_actions = logger.fun('render_actions', function(){
        application.actions.empty().append(
            customer_widgets.search_actions({
                trans : application.trans,
                term  : term,
                count : count
            }).serialize()
        );
    });
    
    self.handle_click = logger.fun('handle_click', function(element, type, id, tag_type_id, title){
        application.show_track(id);
    });
    
    self.do_search = logger.fun('do_search', function(search_by_key){
        term = $('#searchbox')[0].value;
        if(term){
            search_by = search_by_key == undefined ? search_by : search_by_key;
            switch(search_by){
                case 'songs':
                    /*TODO: syncronize with name in client widgets*/
                    term_with_prefix = 'title:' + term;
                    break;
                default:
                    term_with_prefix = $.sprintf('%s:%s', search_by, term);
                    sort_by = search_by;
            }
            
            self.render_sub_navigation();
            $('#search').empty();
            
            var level = new drilldown.Level($('#search'), function(offset, amount, prefix, callback){
                if(application.active_tab !== self){
                   application.show_search();
                }
                var success_callback = function(data){
                    data.application = application;
                    callback(data, customer_widgets.search_drilldown(data).serialize());
                    count = data.count;
                    self.render_actions();
                };
                application.data.search(encodeURI(term_with_prefix), offset, amount, sort_by, success_callback);
            });
        }
        return false;
    });
    logger.leave();
})
var telus_logger = logging.ns('telus.telus');
telus = {
    show:telus_logger.fun('show', function(id){
        $('#' + id).show().css('display', 'block');
    }),

    hidden:telus_logger.fun('hidden',function(id) {
        $('#' + id).hide().css('display', 'none');
    }),
    
    popupcenter:telus_logger.fun('popupcenter', function(page, width, height, options) { 
    	var top         = (screen.height - height) / 2;   
		var left        = (screen.width - width) / 2;  
    	var properties  = "menubar=yes,scrollbars=yes,statusbar=yes,resizable=yes,directories=yes,location=yes";
		window.open(
            page, 
            "", 
            "top=" + top + ",left=" + left + ",width=" + width + ",height=" + height + "," + options + properties
        );
	}) 
}
telus_logger.leave();


customer = {
    Application : TelusApplication,
    Drilldown   : TelusDrilldown,
    Data        : TelusData,
    Search      : TelusSearch,
    Basket      : Basket,
    URL         : TelusURL
}