/**
 * Watchdog.
 * @constructor
 */

function watchdog(){
    
    this.request_timeout = 30000;
    this.event_active_id = 0;
    this.reboot_after_ok = false;
    this.running = false;
}

watchdog.prototype.run = function(timeout, timeslot){
    _debug('watchdog.run', timeout, timeslot);

    _debug('watchdog.running', this.running);

    if (this.running){
        return;
    }

    this.request_timeout = timeout*1000 || this.request_timeout;
    timeslot = timeslot*1000;

    _debug('this.request_timeout', this.request_timeout);

    var day_start = new Date();
    day_start.setHours(0);
    day_start.setMinutes(0);
    day_start.setSeconds(0);
    day_start.setMilliseconds(0);
    day_start = day_start.getTime();

    var now = new Date().getTime();

    _debug('now', now);
    _debug('day_start', day_start);

    _debug('Math.floor((now - day_start)/this.request_timeout)', Math.floor((now - day_start)/this.request_timeout));

    var delay = this.request_timeout - ((now - day_start) - Math.floor((now - day_start)/this.request_timeout) * this.request_timeout);

    _debug('delay', delay);

    //delay += timeslot;

    if ((delay + timeslot) > this.request_timeout){
        delay = delay - (this.request_timeout - timeslot);
    }else{
        delay += timeslot;
    }

    _debug('delay', delay);
    _debug('date', new Date(now + delay) + " " + new Date(now + delay).getMilliseconds() + "ms");

    var self = this;

    this.running = true;

    this.send_request(true);

    window.setTimeout(function(){
        window.setInterval(function(){
            self.send_request();
        }, self.request_timeout);
        self.send_request();
    }, delay);
};

watchdog.prototype.send_request = function(init){
    
    var self = this;
    init = init | false;
    
    var cur_play_type = 0;
    
    if (!stb.player.pause.on){
        cur_play_type = stb.get_current_place();
    }
    
    _debug('cur_play_type', cur_play_type);

    _debug('now', new Date() + " " + new Date().getMilliseconds() + "ms");

    stb.load(
        {
            "type"            : "watchdog",
            "action"          : "get_events",
            "cur_play_type"   : cur_play_type,
            "event_active_id" : this.event_active_id,
            "init"            : init
        },
        
        function(result){
            try{
                
                self.parse_result(result.data);
                
            }catch(e){
                _debug(e);
            }
        }
    );
};

watchdog.prototype.parse_result = function(data){
    
    _debug('watchdog.parse_result', data);

    try{
    
        //module.curweather && module.curweather.set && module.curweather.set(data.cur_weather);

        //module.course && module.course.set && data.course && module.course.set(data.course);

        stb.check_additional_services(data.additional_services_on);
    }catch(e){
        _debug(e);
    }
    
    if (typeof(data.id) != 'undefined'){
        
        _debug('data.id', data.id);

        switch(data.event){
            case 'reboot':
            {
                stb.Stop();
                stb.ExecAction('reboot');
                break;
            }
            case 'reload_portal':
            {
                stb.Stop();
                window.location = window.location;
                break;
            }
            case 'send_msg_with_video':
            {

            }
            case 'send_msg_with_url':
            {

            }
            case 'send_msg':
            {

                /*if (data.param1){
                    data.event = 'send_msg_with_video'
                }*/

                if (!stb.msg){
                    return;
                }

                if (this.event_active_id == data.id){
                    return;
                }
                
                this.event_active_id = data.id;
                
                var self = this;

                if (data.event == 'send_msg_with_video'){

                    var msg_callback =  function(){
                        self.send_confirm();

                        var video = {
                            name  : "",
                            cmd   : data.param1,
                            promo : true
                        };

                        if (stb.player.on){
                            video.restore_item = stb.player.cur_media_item.clone();

                            _debug('stb.cur_layer.layer_name', stb.cur_layer.layer_name);

                            if (stb.cur_layer.layer_name === "vclub"){
                                video.restore_item.position = stb.GetPosTime && stb.GetPosTime();
                            }
                        }

                        if (stb.cur_layer.on){
                            stb.cur_layer.hide();
                            video.restore_layer = stb.cur_layer;
                        }

                        video.stop_callback = function(){
                            _debug('promo_video.stop_callback');

                            if (stb.player.cur_media_item.restore_layer){
                                stb.player.cur_media_item.restore_layer.show();
                            }

                            if (stb.player.cur_media_item.restore_item){
                                stb.player.play(stb.player.cur_media_item.restore_item);
                            }
                        };

                        stb.player.play(video);
                    };
                }else if (data.event == 'send_msg_with_url'){
                    var url = data.param1;
                    msg_callback =  function() {
                        self.send_confirm();
                        _debug('open browser');
                        if (stbWindowMgr.openWebFace){

                            if (gSTB.GetSystemPaths){
                                var system_paths = gSTB.GetSystemPaths();
                                _debug('system_paths', system_paths);

                                try{
                                    system_paths = JSON.parse(system_paths);
                                }catch (e){
                                    _debug(e);
                                }

                                if (system_paths && system_paths.result && system_paths.result.root){
                                    var path = system_paths.result.root;
                                }
                            }else{
                                path = '/home/web/';
                            }

                            path = path[path.length-1] != '/' ? path+'/' : path;
                            _debug('path', path);
                            stbWindowMgr.openWebFace(path+'public/app/ibman/index.html?mode=2&url='+encodeURIComponent(url)+'&view=1');
                            module.internet.win_inited = true;
                        }
                    }
                }else{

                    msg_callback = function(){
                        self.send_confirm(function(){
                            if (data.reboot_after_ok == 1){
                                stb.Stop();
                                stb.ExecAction('reboot');
                            }
                        });
                    };
                }

                stb.msg.push(
                    {
                        msg               : (data.send_time ? '<span style="color: #555">[' + data.send_time + ']</span> ' : '') + data.msg.replace('%mac%', stb.mac).replace('%sn%', stb.serial_number),
                        auto_hide_timeout : data.auto_hide_timeout || 0,
                        callback          : msg_callback || function () {},
                        valid_until       : data.valid_until
                    }
                );
                
                this.reboot_after_ok = data.reboot_after_ok;
                
                break;
            }
            case 'update_channels':
            {
                stb.load_channels();
                stb.load_fav_channels();
                stb.load_fav_itv();
                break;
            }
            case 'update_subscription':
            {
                if (stb.cur_off_on){
                    stb.Stop();
                    stb.ExecAction('reboot');
                }else{
                    stb.load_channels();
                    stb.load_fav_channels();
                    stb.load_fav_itv();
                }
                break;
            }
            case 'update_epg':
            {
                _debug('stb.user.timeslot_ratio', stb.user.timeslot_ratio);
                _debug('stb.user.epg_update_time_range', stb.user.epg_update_time_range);

                if (stb.user.timeslot_ratio){
                    var delay = stb.user.timeslot_ratio * stb.user.epg_update_time_range;
                }else{
                    delay = 0 ;
                }

                _debug('delay', delay);

                window.clearTimeout(this.update_epg_timeout);

                this.update_epg_timeout = window.setTimeout(function(){
                    stb.epg_loader.epg = null;
                    stb.epg_loader.load();
                }, delay * 1000);
                break;
            }
            case 'cut_off':
            {
                stb.cut_off();
                break;
            }
            case 'cut_on':
            {
                stb.cut_on();
                break;
            }
            case 'update_image':
            {
                keydown_observer.emulate_key(key.MENU);
                stbUpdate.startAutoUpdate(stb.user['update_url'], false);
                break;
            }
            case 'mount_all_storages':
            {
                stb.set_storages(data.msg);
                break;
            }
            case 'show_menu': // reset paused
            {
                keydown_observer.emulate_key(key.MENU);
                break;
            }
            case 'play_channel':
            {
                keydown_observer.emulate_key(key.MENU);
                
                stb.user.fav_itv_on = 0;
                
                var ch_idx = stb.player.channels.getIdxByNumber(parseInt(data.msg));
                
                stb.player.ch_idx = ch_idx || 0;
                stb.player.cur_media_item = stb.player.channels[stb.player.ch_idx];
                stb.player.cur_tv_item = stb.player.channels[stb.player.ch_idx];
                stb.player.last_not_locked_tv_item = stb.player.channels[stb.player.ch_idx];

                //keydown_observer.emulate_key(key.EXIT);
                main_menu.hide();
                stb.player.play_last();
                break;
            }
            case 'play_radio_channel': {
                keydown_observer.emulate_key(key.MENU);
                stb.load_radio_channel(parseInt(data.msg));
                break;
            }
            case 'update_modules':
            {
                stb.update_modules();
                break;
            }
        }
    }
};

watchdog.prototype.send_confirm = function(callback){
    
    stb.load(
    {
        "type"   : "watchdog",
        "action" : "confirm_event",
        "event_active_id" : this.event_active_id
    },
    
    function(result){
        _debug(result);
        callback && callback();
    });
    
    this.event_active_id = 0;
};