YAHOO.namespace("sputnik");

var lastKnownPos = 0;
var started = false;

SilverlightEventOnMediaEnded = function(ctx) {
    ctx.playerHandler.setState(ctx.playerHandler.states.PROGRAM_END);
    window.playerTracker.complete();
};
SilverlightEventOnPlayStarted = function(pos,ctx) {
	if (!started)
		ctx.playerHandler.setState(ctx.playerHandler.states.PLAYING);
    // We have no stop button thus no play button (this event will not occur)
};
SilverlightEventOnPlayResumed = function(pos,ctx) {
    // Does not seem to get called!
    //TODO: this is a PROBLEM!
    window.playerTracker.resume();
}
SilverlightEventOnPlayPaused = function(pos,ctx) {
	pos = parseInt(pos);
    window.playerTracker.pause(parseInt(pos/1000));
};
SilverlightEventOnPlayStopped = function(pos,ctx) {
    // We have no stop  button
};
SilverlightEventOnFastForwardStarted = function(pos,ctx) {
	pos = parseInt(pos);
    lastKnownPos = parseInt(pos/1000);
};
SilverlightEventOnFastForwardStopped = function(pos,ctx) {
	pos = parseInt(pos);
    window.playerTracker.scrub( lastKnownPos, parseInt(pos/1000) );
};
SilverlightEventOnFastRewindStarted = function(pos,ctx) {
	pos = parseInt(pos);
    lastKnownPos = parseInt(pos/1000);
};
SilverlightEventOnFastRewindStopped = function(pos,ctx) {
    window.playerTracker.scrub( lastKnownPos, parseInt(pos/1000) );
};
SilverlightEventOnMuteOn = function(ctx) {};
SilverlightEventOnMuteOff = function(ctx) {};
SilverlightEventOnScrub = function(from, to, ctx) {
	from = parseInt(from);
	to = parseInt(to);
    window.playerTracker.scrub( parseInt(from/1000), parseInt(to/1000) );
};
SilverlightEventOnFullscreen = function(ctx) {};
SilverlightEventOnFullscreenRestored = function(ctx) {};
SilverlightEventOnControlLoaded = function(ctx) {};
SilverlightEventOnError = function(msg, ctx) {
    //console.log(msg);
    //ctx.playerHandler.setState(ctx.playerHandler.states.CONNECTION_ERROR);
};
SilverlightEventOnMediaFailed = function(m,ctx) {
	var label = '';
	if(ctx.attribs.isBroadcast)
		label += 'broadcast ';
	else
		label += 'vod ';
	label += ctx.playerHandler.objectID;
	_gaq.push(['_trackEvent', 'PlayerOld', 'MediaFailed: '+m, label]);
}

YAHOO.sputnik.player.silverlight = function(container, objectID, options) {

    // Initialize YUI libraries
    this.dom = YAHOO.util.Dom;
    this.event = YAHOO.util.Event;
    this.rpc = YAHOO.util.Connect;
    this.json = YAHOO.lang.JSON;

    //Player handler object
    //Handles dialog and general flow
    this.playerHandler = new YAHOO.sputnik.player(container, objectID);

    /**
     * Triggered when player has loaded
     */
    this.onPlayerLoaded = new YAHOO.util.CustomEvent("onPlayerLoaded", this);

    //Placeholder for playerobject
    this.player = null;

    //Different attributes
    this.attribs = YAHOO.lang.merge({
        playerId: null,
        width: 658,
        height: 403,
        isBroadcast: false,
		playing: false
    }, options);

    /**
     * Statecodes for the different states the wmp player can have
     */
    this.states = {
        INITIALIZING_PLAYER : 	'initializing_player',
        SILVERLIGHT_NOT_INSTALLED : 'silverlight_not_installed',
        SILVERLIGHT_UPGRADE_NEEDED : 'silverlight_upgrade_needed',
        BROWSER_RESTART_REQUIRED : 'browser_restart_required',
        DRM_NOT_SUPPORTED   :   'drm_not_supported'
    }

	this.construct = function()
	{
	    //Subscribe to statechanges for our events
		this.playerHandler.onStateChange.subscribe(this.handleStates, this);

		//When user is ready, load player
        this.playerHandler.onUserReady.subscribe(this.initializePlayer, this);

        // when player is fully loaded
        this.onPlayerLoaded.subscribe(this.playProgram, this);

        //Handle show/hide player/controls
        this.playerHandler.onHidePlayer.subscribe(this.hidePlayer, this);
        this.playerHandler.onShowPlayer.subscribe(this.showPlayer, this);

        this.playerHandler.onDRMRequired.subscribe(this.handleDRMRequired, this);

        this.playerHandler.isBroadcast = this.attribs.isBroadcast;
        //Inititalze the playerhandle and begin the player flow
		this.playerHandler.construct();
	}

	this.handleStates = function(type, args, me)
	{
		switch(args[0])
		{
			// Initialize the silverlight player
			case me.states.INITIALIZING_PLAYER:
		        me.playerHandler.hidePlayer();
                me.playerHandler.showDialog("dialog-initializing");
                break;

            case me.states.SILVERLIGHT_NOT_INSTALLED:
                me.playerHandler.showDialog("dialog-silverlightnotinstalled");
                break;

            case me.states.SILVERLIGHT_UPGRADE_NEEDED:
                me.playerHandler.showDialog("dialog-silverlightupgradeneeded");
                break;

            case me.states.BROWSER_RESTART_REQUIRED:
                me.playerHandler.showDialog("dialog-browserrestartrequired");
                break;

            case me.states.DRM_NOT_SUPPORTED:
		        me.playerHandler.hidePlayer();
                me.playerHandler.showDialog("dialog-drmnotsupported");
                break;
		}
	}

	this.handleDRMRequired= function(type, args, me)
	{
	    me.playerHandler.onClientReady.fire();
	    // me.playerHandler.setState(me.states.DRM_NOT_SUPPORTED);
	}

    /**
     * Initialize the player embed for faster loading
     */
    this.initializePlayer = function(type, args, me)
    {

        if(!Silverlight.isInstalled()) {
			_gaq.push(['_trackEvent', 'PlayerOld', 'SilverlightNotInstalled']);
            Silverlight.WaitForInstallCompletion();
            me.playerHandler.setState(me.states.SILVERLIGHT_NOT_INSTALLED);
            return;
        }

        me.playerHandler.setState(me.states.INITIALIZING_PLAYER);
        var ticket = args[0];
	    var container = me._getPlayerEmbedElm();

	    var getSilverlightMethodCall = "javascript:Silverlight.getSilverlight(\"3.0.40624.0\");"
        var installImageUrl = "http://go.microsoft.com/fwlink/?LinkId=108181";
        var imageAltText = "Get Microsoft Silverlight";
        var altHtml =
            "<a href='{1}' style='text-decoration: none;'>" +
            "<img src='{2}' alt='{3}' " +
            "style='border-style: none'/></a>";
        altHtml = altHtml.replace('{1}', getSilverlightMethodCall);
        altHtml = altHtml.replace('{2}', installImageUrl);
        altHtml = altHtml.replace('{3}', imageAltText);

	    me.player = Silverlight.createObject(
	    	"/silverlight/Sputnik.VideoPlayer.xap",
            container,
            me.attribs.playerId,
            {
                width: me.attribs.width,
                height: me.attribs.height,
                version: "2.0",
                background: "black",
                minRuntimeVersion: '4.0.50401.0',
                windowless: "true",
				initParams: "bufferTime=10"
            },
            {
                onLoad : function(plugIn, context, sender) {
                    context.me.player = plugIn;
                    if(typeof context.me.player.Content.ScriptableMembers != "undefined") {
						context.me.player.Content.ScriptableMembers.Subscribe("OnMediaFailed", "SilverlightEventOnMediaFailed", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnMediaEnded", "SilverlightEventOnMediaEnded", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnError", "SilverlightEventOnError", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnPlayStopped", "SilverlightEventOnPlayStopped", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnPlayStarted", "SilverlightEventOnPlayStarted", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnPlayResumed", "SilverlightEventOnPlayResumed", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnPlayPaused", "SilverlightEventOnPlayPaused", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnScrub", "SilverlightEventOnScrub", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnFastForwardStarted", "SilverlightEventOnFastForwardStarted", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnFastRewindStarted", "SilverlightEventOnFastRewindStarted", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnFastForwardStopped", "SilverlightEventOnFastForwardStopped", context.me);
                        context.me.player.Content.ScriptableMembers.Subscribe("OnFastRewindStopped", "SilverlightEventOnFastRewindStopped", context.me);
                        context.me.onPlayerLoaded.fire(context.ticket);
                    }
                },
                onError : function(sender, error) {

                    switch(error.errorCode) {
                        case 8001:
							_gaq.push(['_trackEvent', 'PlayerOld', 'SilverlightUpgradeNeeded']);
                            window.player.playerHandler.setState(window.player.states.SILVERLIGHT_UPGRADE_NEEDED);
                            break;

                        case 8002:
							_gaq.push(['_trackEvent', 'PlayerOld', 'SilverlightBrowserRestartRequired']);
                            window.player.playerHandler.setState(window.player.states.BROWSER_RESTART_REQUIRED);
                            break;

                        default:
							_gaq.push(['_trackEvent', 'PlayerOld', 'SilverlightError', 'errorCode ' + error.errorCode]);
                            window.player.playerHandler.setState(window.player.playerHandler.states.CONNECTION_ERROR);
                    }


                }
            },
            "",
            {"me" : me, "ticket" : ticket}
        );

    }

    /**
     * Play the program
     */
    this.playProgram = function(type, args, me)
    {
		$('#dialog-initializing p').html('Starter afspilning...');
    	var ticket = 0;
    	if(args.length > 0)
    		ticket = args[0];
		me.player.Content.ScriptableMembers.InvokeVideo("http://" + TV2.getDynSite("sputnik") + me.getPlaylistPath(ticket));
		window.playerTracker.start();
		this.attribs.playing = true;
		me.playerHandler.addProgramView(null);
    }

	this.isPlaying = function() {
		return this.attribs.playing;
	}

    /**
     * Get path to playlist file
     * @param string ticket
     * @return string
     */
    this.getPlaylistPath = function(ticket)
    {
	if(this.attribs.isBroadcast)
	{
	   return '/player/playlist/output/xml/isBroadcast/true/id/'+this.playerHandler.objectID+'/ticket/'+ticket+'/';
	}
	else
	{
	   return '/player/playlist/output/xml/id/'+this.playerHandler.objectID+'/ticket/'+ticket+'/';
	}
    }

    /**
     * Hides the player area
     */
    this.hidePlayer = function(type, args, me)
    {
        var player = me._getPlayerEmbedElm()
        player.style.height = "1px"; // or else the silverlight plugin won't load
        me.dom.setStyle(player, 'opacity', 0.01);
    }

    /**
     * Show the player area
     */
    this.showPlayer = function(type, args, me)
    {
        var player = me._getPlayerEmbedElm()
        player.style.height = me.attribs.height + "px";
        me.dom.setStyle(player, 'opacity', 1);
    }

    /**
     * Get placeholder for player embed from DOM
     * @return DOMNode
     */
    this._getPlayerEmbedElm = function()
    {
        var elms = this.dom.getElementsByClassName("player-embed", "div", this.playerHandler.container);
        if(elms.length > 0)
           return elms[0];
        return null;
    }

	this.construct();
}