/// SL1 MediaPlayer Area
SL1PlayerArea = function(container, containingWindow, id) {
    SL1PlayerArea.initializeBase(this, [container, containingWindow, id]);

    this.media = null;

    this.SetupPlayer = function() {
        var playerVideoArea = $('PlayerVideo');
        playerVideoArea.setAttribute('align', 'center');

        this.CreateObject();
        this.AdjustSize();
    }

    this.CreateObject = function() {

        var versionRequired = '1.0';

        if (Silverlight.isInstalled("3.0.40624")) {
            versionRequired = "3.0.40723";  //force SL3 GDR 1 if RTM is found
        }

        Silverlight.createObjectEx({
            source: this.GetXamlLocation(),
            parentElement: $('PlayerVideo'),
            id: 'EmbeddedPlayer',
            properties:
 				{ width: LayoutOptions.VideoWidth,
 				    height: LayoutOptions.VideoHeight,
 				    background: 'black',
 				    isWindowless: 'false',
 				    framerate: '24',
 				    version: versionRequired
 				},
            events:
 				{ onError: this.OnMediaError.bind(this), onLoad: this.OnMediaLoad.bind(this) },
            context: null
        });
    }

    this.GetXamlLocation = function() {
        var mainStylesheetLink = document.getElementById("mainStylesheet").href;
        return mainStylesheetLink.replace(/main.css/i, "SL1.xaml");
    }

    this.OnMediaError = function(sender, args) {
        if (args['errorCode'] == 1001 && Manifest.VideoUrl.toLowerCase().substr(0, 4) == 'http') {
            return;
        }

        this.HandleMediaPlayerError(this.FormatErrorMessage(args));
    }

    this.OnMediaLoad = function() {
        this.embeddedPlayer = $('EmbeddedPlayer');
        mss.OnLoad(this.embeddedPlayer);

        this.media = mss.FindName('media');
        this.media.width = LayoutOptions.VideoWidth;
        this.media.height = LayoutOptions.VideoHeight;

        this.AttachMediaEvents();

        this.pci = new SfMediaPlayer.SL1.PlayerControl(this.media);

        this.AddEventHandlers();

        this.SetMediaSource();

        this.Volume = new SfMediaPlayer.Volume(this.pci);
        this.timerManager = new SfMediaPlayer.TimerManager(this);

        if (mPlayer.CurrentSlidePanelInstance && Manifest.PlayStatus == SfKernel.PresentationPlayStatus.OnDemand) {
            mPlayer.EventManager.Events.addHandler(SfKernel.EventType.TimerLoop, this.TimerLoopEventHandler.bind(this));
        }
    }

    this.SetMediaSource = function() {
        if (Manifest.UnicastVideoUrl && Manifest.UnicastVideoUrl.length > 0) {
            this.pci.SetMedia(Manifest.UnicastVideoUrl);
        }
        else {
            this.pci.SetMedia(Manifest.VideoUrl);
        }
    }

    this.fullScreenChange = function(sender, args) {
        var embeddedSLMedia = mss.FindName('media');
        embeddedSLMedia.Width = mss.content.ActualWidth;
        embeddedSLMedia.Height = mss.content.ActualHeight;
        this.hideFullScreenPrompt();
    }

    this.hideFullScreenPrompt = function() {
        mss.SetVisible("fsText", false);
        mss.SetVisible("fsTextBackground", false);
    }

    this.MouseEnter = function(sender, args) {
        if (this.embeddedPlayer.content.fullScreen) {
            return;
        }

        var playState = this.pci.GetPlayState();

        if (playState != SfKernel.MediaState.Playing && playState != SfKernel.MediaState.Paused) {
            return;
        }

        mss.SetVisible("fsTextBackground", true);
        mss.SetVisible("fsText", true);

        var fsText = mss.FindName("fsText");
        var fsTextBackground = mss.FindName("fsTextBackground");
        fsText.Text = Localization.MediaPlayer.SilverlightFullScreenPrompt;
        fsText.width = LayoutOptions.VideoWidth;
        fsTextBackground.width = LayoutOptions.VideoWidth;
        mss.AlignText(mss.FindName("fsText"), TextAlign.CenterVertical | TextAlign.CenterHorizontal);

    }

    this.MouseLeave = function(sender, args) {
        this.hideFullScreenPrompt();
    }

    this.MouseLeftButtonUp = function(sender, args) {
        var playState = this.pci.GetPlayState();

        if (playState != SfKernel.MediaState.Playing && playState != SfKernel.MediaState.Paused) {
            return;
        }

        if (!this.embeddedPlayer.content.fullScreen) {
            this.embeddedPlayer.content.fullScreen = true;
            return;
        }

        if (Manifest.PlayStatus == SfKernel.PresentationPlayStatus.OnDemand) {
            if (playState == SfKernel.MediaState.Paused) {
                this.Play();
            }
            else if (playState == SfKernel.MediaState.Playing) {
                this.Pause();
            }
        }
    }

    this.AttachMediaEvents = function() {
        this.embeddedPlayer.content.onFullScreenChange = SfEvent.createDelegate(this, this.fullScreenChange);

        var videoArea = mss.FindName("videoArea");
        {
            videoArea.addEventListener("MouseEnter", SfEvent.createDelegate(this, this.MouseEnter));
            videoArea.addEventListener("MouseLeave", SfEvent.createDelegate(this, this.MouseLeave));
            videoArea.addEventListener("MouseLeftButtonUp", SfEvent.createDelegate(this, this.MouseLeftButtonUp));
        }

        this.media.addEventListener('mediaOpened', this.OnMediaOpened.bind(this));
        this.media.addEventListener('mediaFailed', this.OnMediaFailed.bind(this));
        this.media.addEventListener('currentStateChanged', this.OnMediaCurrentStateChanged.bind(this));

        if (!GlobalOptions.UseLiveEventPolling) {
            this.media.addEventListener('markerReached', this.OnMediaMarkerReached.bind(this));
        }
    }

    this.OnMediaOpened = function() {
        mPlayer.VolumeSliderInstance.OnLoad();
        mPlayer.PlayerSliderInstance.OnLoad();
        mPlayer.ReportViewerPageOpened();

        if (this.media.NaturalVideoHeight == 0) {
            Manifest.HasVideo = false;
        }
        else {
            Manifest.HasVideo = true;
        }

        mPlayer.EventManager.PostEvent(SfKernel.EventType.MediaOpened, this, null);

        this.InitVolume();
        this.HandleAudioOnly();
        this.LoadAudioLanguages();

        switch (Manifest.PlayStatus) {
            case SfKernel.PresentationPlayStatus.Live:
            case SfKernel.PresentationPlayStatus.LivePaused:
                if (GlobalOptions.UseLiveEventPolling || mPlayer.PlayerDetect.IsMacPPC()) {
                    this.timerManager.pollLiveEvents = true;
                }
                break;
        }

        this.PostMediaLengthObtainedEvent();
        this.CheckStartStopTimes();

        this.timerManager.Start();
    }

    this.LoadAudioLanguages = function() {
        var languageCount = this.pci.GetAudioLanguageCount();
        if (languageCount > 1) {
            var AudioLanguages = new Array(languageCount);
            for (var i = 0; i < languageCount; ++i) {
                //Silverlight currently does not provide locale info
                AudioLanguages[i] = new SfKernel.AudioLanguageEntry(i, 0, Localization.Common.AudioTrack + ' ' + (i + 1));
            }

            mPlayer.LoadAudioLanguages(AudioLanguages, 1);
        }
    }

    this.OnMediaFailed = function(sender, args) {
        this.HandleMediaPlayerError(this.FormatErrorMessage(args));
    }

    this.OnMediaLoaded = function(sender, args) {
    }

    this.OnMediaCurrentStateChanged = function(sender, args) {
        var playState = this.pci.GetPlayState();

        if (this.currentMediaState != playState) {
            this.currentMediaState = playState;
            mPlayer.EventManager.PostEvent(SfKernel.EventType.PlayStateChanged, this, playState);
            this.CheckIfLiveEnded(playState);
        }
    }

    this.OnMediaMarkerReached = function(sender, args) {
        var scriptType = args['marker']['type'];
        var scriptParam = args['marker']['text'];
        this.ScriptParser.ParseScriptFromStream(scriptType, scriptParam);
    }

    this.TimerLoopEventHandler = function(sender, args) {
        this.HandleSlideChangeWhenPositionChanges(args["Position"]);
    }

    this.getFormattedTiming = function(posInMS) {
        var parsed = this.pci.ParseTime(posInMS);
        return parsed.HH + ":" + parsed.MM + ":" + parsed.SS + "." + parsed.FF;
    }

    this.FormatErrorMessage = function(args) {
        var errorDescription;

        switch (args['errorCode']) {
            case 4001:
                errorDescription = Localization.MediaPlayer.SilverlightNetworkError + "<br/> (" + args['errorMessage'] + ")";
                break;
            case 2203:
                errorDescription = Localization.MediaPlayer.SilverlightSetValueError + args['methodName'] + "<br/><br/>";
                break;
            default:
                errorDescription = Localization.MediaPlayer.GeneralError + "<br/> (" + args['errorCode'] + " - " + args['errorMessage'] + ")";
                break;
        }

        return errorDescription;
    }

    this.HideMediaPlayerDiv = function() {
        var playerElement = $('PlayerVideo');
        var notReady = $('PlayerNotStarted');

        var validSLVersion = Silverlight.isInstalled('1.0');
        if (validSLVersion) {
            if (Silverlight.isInstalled('3.0') && !Silverlight.isInstalled('3.0.40723')) {
                validSLVersion = false;
            }
        }

        if (validSLVersion) {
            if (playerElement) {
                playerElement.style.display = 'none';
            }
            if (notReady) {
                notReady.style.display = '';
            }
        }
        else {
            if (playerElement) {
                playerElement.setAttribute("align", "center");
                playerElement.style.display = '';
                var slPluginHelper = new Object();
                slPluginHelper.version = '1.0';
                playerElement.innerHTML = Silverlight.buildPromptHTML(slPluginHelper);
            }
            if (notReady) {
                notReady.style.display = 'none';
            }
        }

    }
}
SL1PlayerArea.registerClass('SL1PlayerArea', MediaPlayerArea);


/// SL1 MediaPlayer Control

Type.registerNamespace('SfMediaPlayer.SL1');
SfMediaPlayer.SL1.PlayerControl = function(embeddedMedia)
{
	this.media = embeddedMedia;
	
	this.Play = function()
	{
		this.media.play();
	}
	
	this.Stop = function()
	{
		this.media.stop();		
	}
	
	this.Pause = function()
	{
		this.media.pause();
	}

	this.GetPlayState = function()
	{
		var state = this.media.currentState;
		return this.convertSL1StateToPlayState(state);
	}
	
	this.SetMedia = function(loc)
	{
		this.media.source = loc;
	}
	
	this.GetPosition = function()
	{
		return this.media.position.seconds * 1000;
	}
	
	this.ParseTime = function(timeInMS)
	{
		var hh = Math.floor(timeInMS/3600000);
		
		var remainingMS = timeInMS - hh*3600000;
		var mm = Math.floor(remainingMS/60000);
		
		remainingMS = remainingMS - mm*60000;
		var ss = Math.floor(remainingMS/1000);
		
		remainingMS = remainingMS = ss*1000;
		var ff = Math.floor(remainingMS);

		return {HH:hh, MM:mm, SS:ss, FF:ff};		
	}
	
	this.SetPosition = function(posInMS)
	{	
		var parsed = this.ParseTime(posInMS);		
		var strPos = String.format('{0}:{1}:{2}.{3}', parsed.HH, parsed.MM, parsed.SS, parsed.FF);
		
		try
		{
	        if(this.GetPlayState() == SfKernel.MediaState.Playing)
		    {
		        //prevent SL video freeze bug
		        this.Pause();
		        this.media.position = strPos;		    
		        this.Play();
		    }
		    else
		    {
		        this.media.position = strPos;		    
		    }

		}
		catch(e)
		{		
		}		
	}
	
	this.GetMediaDuration = function()
	{
		return this.media.naturalDuration.seconds * 1000;
	}

	this.SetVolume = function(val)
	{   
		this.media.volume = val/100;
	}
	
	this.GetVolume = function()
	{
		return this.media.volume * 100;
	}
	
	this.SetMute = function(val)
	{
		this.media.isMuted = val;
	}
			
	this.convertSL1StateToPlayState = function(state)
	{
		switch (state.toLowerCase())
		{
			case 'buffering':
				return SfKernel.MediaState.Buffering;
			case 'closed':
				return SfKernel.MediaState.Closed;
			case 'error':
				return SfKernel.MediaState.Error;
			case 'opening':
				return SfKernel.MediaState.Opening;
			case 'paused':
				return SfKernel.MediaState.Paused;
			case 'playing':
				return SfKernel.MediaState.Playing;
			case 'stopped':
				return SfKernel.MediaState.Stopped;
			default:
				return SfKernel.MediaState.Undefined;
		}
	}

	this.SetPlaybackSpeed = function(speed)
	{
		throw Error.notImplemented();
	}
	
    this.SetFullScreen = function(fs)
	{
		throw Error.notImplemented();
	}

    this.GetAudioLanguageCount = function()
    {
        return this.media.AudioStreamCount;
    }
    
	this.SetAudioLanguageIndex = function(index)
	{
		this.media.AudioStreamIndex  = index;
    }

}


////////////////////////////////////////////

function SfEvent(name)
{
    this.Name=name;
    this.delegateList=new Array(0);
}

SfEvent.createDelegate = function(instance, method) 
{
	return function() {
        return method.apply(instance, arguments);
    }
}

SfEvent.prototype=
{

    Invoke:function(objParameters)
	{
	    for (var i=0;i<this.delegateList.length;i++)
	    {
	        if (this.delegateList[i])
	        {
	            this.delegateList[i](objParameters);
	        }
	    }

    },
    
    addListener:function(delegate)
    {
    
        for(var i=0;i<this.delegateList.length;i++)
        {
            if (this.delegateList[i]==null)
            {
                this.delegateList[i]=delegate;
                return i;
            }
        }
        
        var newList = new Array(this.delegateList.length+1);
        
        for(var i=0;i<this.delegateList.length;i++)
        {
            newList[i]=this.delegateList[i];
        }
        
        newList[this.delegateList.length]=delegate;
        
        this.delegateList=newList;
        
        return (this.delegateList.length-1);
    },
    
    removeListener:function(token)
    {
        if (this.delegateList.length>token)
        {
            this.delegateList[token]=null;
        }
    }
}

function EventList() 
{
    this.namedEvents=new Array(arguments.length);
    
    for(var i=0;i<arguments.length;i++)
    {
        this.namedEvents[i]=new Event(arguments[i]);
    }
}

EventList.prototype=
{

    Invoke:function(name,objParameters)
	{
	    var event = this.findEvent(name);
	    
	    if (event)
	    {
	        event.Invoke(objParameters);
	    }

    },
    
    addListener:function(name,delegate)
    {
        var event = this.findEvent(name);
	    
	    if (event)
	    {
	        return event.addListener(delegate);
	    }
	    
	    return null;
    },
    removeListener:function(name,token)
    {
        var event = this.findEvent(name);
	    
	    if (event)
	    {
	        event.removeListener(token);
	    }
    },
    findEvent:function(name)
    {
        for(var i=0;i<this.namedEvents.length;i++)
        {
            if (this.namedEvents[i].Name==name)
            {
                return this.namedEvents[i];
            }
        }
        
        return null;
    }
}

function mss(){}

mss.control=null;
mss.content=null;

mss.OnLoad=function(silverlightControl)
{
    mss.control=silverlightControl;
    mss.content=mss.control.content;
}
    
mss.Animate=function(animationName) 
{
    var animation = mss.FindName(animationName);
	
    if (animation!=null)
    {
        animation.begin();
        return true;
    }
    return false;
}

mss.FindName=function(name) 
{
    return mss.content.findName(name);
}

mss.SetVisible = function(canvasName,show) 
{
    var panel = mss.FindName(canvasName);
    
    if (panel!=null)
    {
        if (show)
        {
           panel.SetValue("Visibility","Visible");
        }
        else
        {
           panel.SetValue("Visibility","Collapsed");
        }
    }
}
function TextAlign(){}
TextAlign.CenterVertical=1;
TextAlign.CenterHorizontal=2;

mss.AlignText=function(textBlock,textAlign)
{

        if ((textAlign & TextAlign.CenterHorizontal)==TextAlign.CenterHorizontal)
        {
            textBlock.SetValue("Canvas.Left", 0);
            var newLeft = ((textBlock.Width - textBlock.ActualWidth) / 2)+ textBlock.GetValue("Canvas.Left"); 
            
            textBlock.SetValue("Canvas.Left", newLeft); 
        }
 

        if ((textAlign & TextAlign.CenterVertical)==TextAlign.CenterVertical)
        {
            textBlock.SetValue("Canvas.Top", 0);
            var newTop = ((textBlock.Height - textBlock.ActualHeight) / 2) + textBlock.GetValue("Canvas.Top");
                 
            textBlock.SetValue("Canvas.Top", newTop);
        }
}

function Rectangle(left,top,width,height)
{
    this.Left=left;
    this.Top=top;
    this.Width=width;
    this.Height=height;
}

Rectangle.prototype =
{
    SetCanvasRect:function(canvas)
	{
	    canvas.SetValue("Canvas.Left",this.Left);
        canvas.SetValue("Canvas.Top",this.Top);
	    canvas.width=this.Width;
        canvas.height=this.Height;

    },
    
    SetCanvasSize:function(canvas)
	{
	    canvas.width=this.Width;
        canvas.height=this.Height;
    },
    
    GetCanvasRect:function(canvas)
	{
	    this.Width=canvas.width;
        this.Height=canvas.height;
        this.Left=canvas.GetValue("Canvas.Left");
        this.Top=canvas.GetValue("Canvas.Top");
    },
    
    SetClipRect:function(rectangleGeometry)
	{
        var rectDimensions=this.Left+","+this.Top+","+this.Width+","+this.Height;
        rectangleGeometry["Rect"]=rectDimensions;
    },
    
    Clone:function()
    {
        return new Rectangle(this.Left,this.Top,this.Width,this.Height);
    },
    
    ToString:function()
    {
        return this.Left+","+this.Top+","+this.Width+","+this.Height;
    }
}