String.prototype.getAtvUrl = function () {
    if('production' != project.environment)
    {
        var url = this.replace(project.getBaseUrl(), 'http://atv.at/');
        //var url = this.replace(project.getBaseUrl(), 'http://stage-frontend.atv.invaliddomain.de/');

        return url;
    }

    return this;
};

project.player.Proxy = new Class({
    Implements: [Options, project.player.Logging],

    log_prefix: 'Proxy',

    baseurl: project.getBaseUrl(),

    json: {
        contentset_type: 'normal',
        active_playlist_id: null,
        active_playlist_page: null,
        active_clip_id: null,
        first_tab_title: '',
        second_tab_title: '',

        request: {
            player_contentset: {
                //url: 'player_contentset_json_CONTENTSET_ID_CLIP_ID.json',
                url: 'player_contentset_json/CONTENTSET_ID/CLIP_ID/RELATED',
                data: null,
                obj: null
            },
            player_playlist_page: {
                //url: 'player_playlist_page_json_CONTENTSET_ID_PLAYLIST_ID_PAGE.json',
                url: 'player_playlist_page_json/CONTENTSET_ID/PLAYLIST_ID/PAGE',
                data: null,
                obj: null
            },
            player_related_playlist_page: {
                //url: 'player_playlist_page_json_CONTENTSET_ID_PLAYLIST_ID_PAGE.json',
                url: 'player_related_playlist_json/CONTENTSET_ID/CLIP_ID',
                data: null,
                obj: null
            },
            player_userplaylist: {
                url: 'player_userplaylist_json/CONTENTSET_ID/CLIP_ID',
                data: null,
                obj: null
            }
        }
    },

    actions: {
        obj: null,
        visible: false
    },
    header: {
        obj: null
    },
    player: {
        obj: null,
        active_clip: null,
        advertising: false,
        autoplay: false,
        fullscreen: 'false' // flash gibt hier per info.message einen string zurueck, deswegen das boolean als string
    },
    playlist_tabs: {
        obj: null
    },
    playlist: {
        obj: null,
        active: null,
        cache: [],
        for_recommendation: 0
    },
    pagination: {
        obj: null
    },
    details: {
        obj: null
    },
    layer: {
        obj: null
    },
    advertising: {
        obj: null
    },
    skinbranding: {
        dom_element: null,
        default_image: null,
        click_event: null
    },
    playlist_cache: null,
    tracking: {
        obj: null
    },

    options: {
        contentset_id: null,
        clip_id: null,
        is_user: null,
        related: null
    },

    initialize: function(options)
    {
        var that = this;

        that.setOptions(options);

        that.tracking.obj = new project.player.Tracking({
            'proxy': that
        });
        that.playlist_cache = new project.player.PlaylistCache();
        that.header.obj = new project.player.Header();
        that.details.obj = new project.player.Detail({
            'proxy': that
        });
        that.pagination.obj = new project.player.Pagination({
            change_page_callback: function(page) {
                that.changePage(page);
            }
        });
        that.playlist.obj = new project.player.Playlist({
            'proxy': that
        });
        
        that.getContentsetJson();
    },

    getContentsetJson: function()
    {
        var that = this;

        var jsonRequest = new Request.JSON({
            url: that.getContentsetRequestUrl(),
            onSuccess: function(json) {

                if(0 == json.length)
                {
                    var json = JSON.decode(unescape(that.options.json.replace(/\+/g, " ")));
                }

                that.json.request.player_contentset.data = json;
                that.logger({'getContentsetJson loaded': json});

                // normal, ugc
                that.json.contentset_type = json.contentset_type;

                that.json.active_playlist_id = json.active_playlist_id;
                that.json.active_playlist_page = json.active_playlist_page;

                that.json.active_clip_id = json.active_clip_id;
                that.player.autoplay = json.autostart;

                that.json.first_tab_title = json.first_tab_title;
                that.json.second_tab_title = json.second_tab_title;

                // playlist for recommandtion on end of video
                that.playlist.for_recommendation = json.recommendation_playlist_id || 0;

                // set active playlist
                that.playlist.active = that.getActivePlaylist(json);

                // set active clip
                that.player.active_clip = that.getActiveClip(that.playlist.active);

                // trigger comments
                that.triggerChangedCommentTarget(that.player.active_clip.id)

                // set skinbranding
                that.setSkinbranding(that.player.active_clip.skinbranding_url);
                that.setDefaultSkinbranding();

                // update header
                that.updateHeader(that.player.active_clip);

                // Layer
                that.layer.obj = new project.player.Layer({
                    proxy: that
                });
                that.layer.obj.update(that.player.active_clip);

                // Playlist Tabs
                that.playlist_tabs.obj = new project.player.PlaylistTabs({
                    proxy: that,
                    contentset_type: json.contentset_type,
                    playlists: json.playlists,
                    active_playlist_id: that.playlist.active.id,
                    is_user: that.options.is_user,
                    related: that.options.related,
                    change_playlist_callback: function( playlist_id, page_count, playlist_type ) {
                        that.logger('PlaylistTabs: change_playlist_callback');
                        that.changePlaylist( playlist_id );
                        that.advertising.obj.adReload();
                    },
                    load_user_playlist_callback: function()
                    {
                        that.logger('PlaylistTabs: load_user_playlist_callback');
                        that.changeUserPlaylist();
                        that.advertising.obj.adReload();
                    }
                });



                if('Filme' == that.player.active_clip.category)
                {
                    that.showDetailOverlay(that.player.active_clip);

                    $('playlist_overlay_close').setStyle('visibility', 'hidden');
                    $('playlist_overlay_title').setStyles({
                        padding: 0,
                        background: 'none'
                    });

                    // preview image
                    var preview_image = new Element('img', {
                        'src': that.player.active_clip.image_url.getAtvUrl()
                    });
                    $('proxy_player').empty();
                    $('proxy_player').grab(preview_image);
                    $('proxy_player').show();
                }
                else
                {
                    // load playlist
                    that.playlist.obj.load({
                        items: that.playlist.active.pages[that.json.active_playlist_page],
                        active_page: that.json.active_playlist_page,
                        active_clip_id: that.player.active_clip.id,
                        is_user: that.options.is_user,
                        related: that.options.related
                    });

                    // cache playlist page
                    that.playlist_cache.addPageItems(
                        that.playlist.active.id,
                        that.json.active_playlist_page,
                        that.playlist.active.pages[that.json.active_playlist_page]
                    );

                    // update pagination
                    that.pagination.obj.update(that.playlist.active.page_count, that.json.active_playlist_page);

                    // load player (flash or html5)
                    that.initPlayer();
                }

                // actions
                that.actions.obj = new project.player.Actions({
                    'proxy': that,
                    'visible': !that.options.actions_disabled,
                    'comments_disabled': json.comments_disabled,
                    'embed_disabled': json.embed_disabled
                });
                that.actions.obj.update(that.player.active_clip)

                // advertising
                try
                {
                    that.advertising.obj = new project.player.Advertising({
                        'proxy': that
                    });
                    that.player.advertising = json.player_advertising;
                }
                catch(err)
                {
                    // adblock !!!
                }

                // hide player loading layer
                $('player_loading').hide();
            }
        }).get();
    },


    /*
     * Init Player
     */
    initPlayer: function() {
        var that = this;

        if(null == that.player.obj)
        {
            var ua = navigator.userAgent;
            var isiUser = /iPad/i.test(ua) || /iPhone OS/i.test(ua) || /Midori/i.test(ua); // || /Chrome/i.test(ua);
            if(isiUser)
            {
                that.logger('Html5');
                that.player.obj = new project.player.Html5Player({
                    'proxy': that
                });
            }
            else
            {
                that.logger('Flash');
                that.player.obj = new project.player.FlashPlayer({
                    'proxy': that
                });
            }
        }
    },

    /*
     * Tracking (action)
     */
    track: function(action)
    {
        var clip = this.player.active_clip;

        this.tracking.obj.trackAll({
            'name': clip.keyValueName || '',
            'staffel': clip.keyValueSeason || '',
            'folge': clip.keyValueEpisode || '',
            'art': clip.keyValueType || '',
            'laenge': clip.keyValueLength || '',
            'programid': clip.zoneCategoryName || '',
            'action': action
        });
    },

    /*
     * Trigger Comments, update Clip id
     */
    triggerChangedCommentTarget: function(clip_id)
    {
        if(comments)
        {
            comments.triggerChangedCommentTarget(clip_id);
        }
    },

    advertisingReset: function()
    {
        try
        {
            this.advertising.obj.reset();
            this.advertising.obj.setSkinbrandingVisible(true);
        }
        catch(err)
        {

        }
    },

    setFullscreenState: function(state)
    {
        this.logger('setFullscreenState (' + state + ')');
        this.player.fullscreen = state;
        
    },

    /*
     * Change Page
     */
    changePage: function(page)
    {
        var that = this;

        that.logger({'changePage': page});

        // lock pagination
        that.pagination.obj.lock();
        $('playlist_loading').show();

        // request playlist json
        that.getPlaylistJson(that.options.contentset_id, that.playlist.active.id, page, 'normal', function(items) {
            // update playlist items
            that.playlist.obj.load({
                'items': items,
                'active_page': page,
                'active_clip_id': that.player.active_clip.id
            });

            // update pagination
            that.pagination.obj.gotoPage(page);

            // release pagination
            that.pagination.obj.release();
            $('playlist_loading').hide();
        });

        // tracking
        that.track('Playliste');

        // adReload
        that.advertising.obj.adReload();
    },



    /*
     * Change Clip
     */
    changeClip: function(clip, options)
    {
        var that = this;

        that.logger({'changeClip': clip});

        // update active clip
        that.player.active_clip = clip;

        // trigger comments
        this.triggerChangedCommentTarget(clip.id);

        // set default skinbranding
        that.setDefaultSkinbranding();

        // update actions
        that.actions.obj.update(clip)

        //hide and update layer
        that.layer.obj.hide();
        that.layer.obj.update(clip);

        // Update Header
        that.updateHeader(clip);
        
        // reload playlists if contentset is ugc and playlist is related (id =1)
        if( 'ugc' == that.json.contentset_type && 1 == that.playlist.active.id )
        {
            that.getRelatedPlaylistJson(clip.contentset_id, clip.id, function(items) {
                that.playlist.obj.load({
                    'items': items,
                    'active_page': 1,
                    'active_clip_id': clip.id
                });

                // update contentset id
                that.options.contentset_id = clip.contentset_id;

                // update second tab title
                that.playlist_tabs.obj.setSecondTabTitle(clip.username + "'s Videos", 0);

                // activate first page
                that.pagination.obj.gotoPage(1);
            });
        }

        that.player.obj.changeClip(clip, options.autoplay);

        // tracking
        that.track('Clip');
    },


    /*
     * Update Header
     */
    updateHeader: function(clip) {
        this.header.obj.setTitle(clip.title);
        this.header.obj.setSubTitle(clip.subtitle);
        this.header.obj.setFavorites(clip.favorites);
        this.header.obj.setHosts(clip.hosts);
        this.header.obj.setUsername({
            'username': clip.username,
            'userlink': clip.user_link
        });
    },


    /*
     * Change Playlist
     */
    changePlaylist: function(playlist_id)
    {
        var that = this;
        var page = 1;

        that.logger({'changePlaylist': playlist_id});
        
        // set active playlist
        that.playlist.active.id = playlist_id;

        $('playlist_loading').show();

        // Load Playlist JSON and update Playlist
        that.getPlaylistJson(that.options.contentset_id, playlist_id, page, that.json.contentset_type, function(items, page_count) {
            that.playlist.obj.load({
                items: items,
                active_page: page,
                active_clip_id: that.player.active_clip.id
            });

            $('playlist_loading').hide();

            // Update Pagination
            that.pagination.obj.update(page_count, page);
        });

        // tracking
        that.track('Playliste');
    },



    /*
     * Change User Playlist
     */
    changeUserPlaylist: function()
    {
        var that = this;
        var page = 1;

        that.logger('changeUserPlaylist');

        $('playlist_loading').show();

        // Load Playlist JSON and update Playlist
        that.getUserPlaylistJson(that.options.contentset_id, that.player.active_clip.id, function(items, page_count) {

            that.playlist.obj.load({
                items: items,
                active_page: page,
                active_clip_id: that.player.active_clip.id
            });

            $('playlist_loading').hide();

            // Update Pagination
            that.pagination.obj.update(page_count, page);
        });

        // tracking
        that.track('Playliste');
    },



    /*
     * show playlistitem detail overlay
     */
    showDetailOverlay: function(clip)
    {
        this.details.obj.update(clip);
        this.details.obj.show();

        // tracking
        this.track('Playliste');
    },


    getRelatedPlaylistJson: function(contentset_id, clip_id, callback)
    {
        var that = this;

        that.logger('getRelatedPlaylistJson (contentset: ' + contentset_id + ' | clip: ' + clip_id + ')');

        // kill request if is running
        if(null !== that.json.request.player_related_playlist_page.obj)
        {
            if(that.json.request.player_related_playlist_page.obj.running)
            {
                that.json.request.player_related_playlist_page.obj.cancel();
            }
        }

        var url = that.json.request.player_related_playlist_page.url.replace(/CONTENTSET_ID/g, contentset_id);
        url = url.replace(/CLIP_ID/g, clip_id);
        url = that.baseurl + url;

        that.json.request.player_related_playlist_page.obj = new Request.JSON({
            url: url,
            onSuccess: function(pages) {
                for(var page, i=0; page = pages[++i];)
                {
                    that.playlist_cache.addPageItems(1, i, page);
                }

                callback( that.playlist_cache.getPageItems(1,1) );
            }
        }).get();
    },



    getUserPlaylistJson: function(contentset_id, clip_id, callback)
    {
        var that = this;
        var page = 1;
        var playlist_id = contentset_id + '-' + clip_id;

        that.logger('getUserPlaylistJson (contentset: ' + contentset_id + ' | clip: ' + clip_id + ')');

        if(null !== that.json.request.player_userplaylist.obj)
        {
            if(that.json.request.player_userplaylist.obj.running)
            {
                that.json.request.player_userplaylist.obj.cancel();
            }
        }

        var url = that.json.request.player_userplaylist.url.replace(/CONTENTSET_ID/g, contentset_id);
        url = url.replace(/CLIP_ID/g, clip_id);
        url = that.baseurl + url;

        that.json.request.player_userplaylist.obj = new Request.JSON({
            url: url,
            onSuccess: function(pages) {
                var playlist = pages[0];

                callback( playlist.pages[page], playlist.page_count );
            }
        }).get();


    },

    /*
     * get playlist json
     */
    getPlaylistJson: function(contentset_id, playlist_id, page, playlist_type, callback)
    {
        // TODO: add tyoe (related playlist for user contentsets)

        var that = this;

        that.logger({'getPlaylistJson': url});
        that.logger({'playlist type': playlist_type});
        that.logger({'playlist id': playlist_id});
        that.logger({'playlist page': page});

        if('ugc' == playlist_type)
        {
            playlist_id = playlist_id + '-' + that.player.active_clip.id;
        }

        // check if playlist items are already cached for playlist page
        if(null === that.playlist_cache.getPageItems(playlist_id, page))
        {
            if('ugc' == playlist_type)
            {
                that.logger('getPlaylistJson => UGC');

                that.getRelatedPlaylistJson(contentset_id, that.player.active_clip.id, function(json) {
                    var page_count = 1;
                    json.each(function(page) {
                       page_count++;
                    });

                    callback(json, page_count);
                });


            }
            else
            {
                var url = that.json.request.player_playlist_page.url;
                url = url.replace(/CONTENTSET_ID/g, contentset_id);
                url = url.replace(/PLAYLIST_ID/g, playlist_id);
                url = url.replace(/PAGE/g, page);
                url = that.baseurl + url;

                var jsonRequest = new Request.JSON({
                    url: url,
                    onSuccess: function(json) {
                        that.playlist_cache.addPageItems(playlist_id, page, json[page]);
                        that.playlist_cache.setPlaylistPageCount(playlist_id, json['total_page_count']);
                        callback(json[page], json['total_page_count']);
                    }
                }).get();
            }
        }
        else
        {
            var items = that.playlist_cache.getPageItems(playlist_id, page);
            var page_count = that.playlist_cache.getPlaylistPageCount(playlist_id);
            callback(items, page_count);
        }
    },



    getActivePlaylist: function(json)
    {
        var active_playlist = null;

        json.playlists.each(function(playlist) {
            if(json.active_playlist_id == playlist.id)
            {
                active_playlist = playlist;
            }
        });

        this.logger({'active_playlist': active_playlist});
        this.logger({'active_playlist_id': active_playlist.id});

        return active_playlist;
    },



    getActiveClip: function(playlist) {
        var that = this;
        var active_clip = null;
        var clips = playlist.pages[that.json.active_playlist_page];

        clips.each(function(clip) {
            if(that.json.active_clip_id == clip.id)
            {
                active_clip = clip;
            }
        });

        that.logger({'active_clip': active_clip});
        that.logger({'active_clip_id': active_clip.id});

        return active_clip;
    },

    getContentsetRequestUrl: function()
    {
        var url = this.json.request.player_contentset.url.replace(/CONTENTSET_ID/g, this.options.contentset_id);

        if (null !== this.options.clip_id)
        {
            url = url.replace(/CLIP_ID/g, this.options.clip_id);

            if(null !== this.options.related)
            {
                url = url.replace(/RELATED/g, this.options.related);
            }
        }

        url = url.replace(/\/CLIP_ID/g, '');
        url = url.replace(/\/RELATED/g, '');
        url = this.baseurl + url;

        this.logger({'contentset request url': url});


        return url;
    },


    setSkinbranding: function(image_url, click_url)
    {
        this.logger({'skin_branding_image': image_url.getAtvUrl() });
        this.logger({'skin_branding_url': click_url });

        this.skinbranding.dom_element = new Element('div', {
            'id': 'skinbranding',
            'styles': {
                'background-image': 'url(' + image_url.getAtvUrl() + ')'
            }
        });
        $('skin').grab(this.skinbranding.dom_element);


        // click event
        this.skinbranding.click_event = function() {
            window.open(click_url);
        }

        if(click_url)
        {
            this.skinbranding.dom_element.addEvent('click', this.skinbranding.click_event);
        }
        else
        {
            this.skinbranding.dom_element.removeEvent('click', this.skinbranding.click_event);
        }
    },


    setDefaultSkinbranding: function()
    {
        var that = this;
        that.skinbranding.default_image = that.player.active_clip.skinbranding_url.getAtvUrl();
        that.logger('set default skinbranding: ' + that.skinbranding.default_image);
    },


    resetSkinbranding: function()
    {
        this.skinbranding.dom_element.removeEvent('click', this.skinbranding.click_event);
        this.skinbranding.dom_element.setStyle('background-image', 'url(' + this.skinbranding.default_image + ')');
    }
});