/// SL1 MediaPlayer Area
SL1PlayerArea = function(container, containingWindow, id)
{
	SL1PlayerArea.initializeBase(this, [container, containingWindow, id]);
			
	this.media = null;
	this.SlideCheckInterval = 5000;
	
	this.SetupPlayer = function()
	{	    
	    var playerVideoArea = $('PlayerVideo');
	    playerVideoArea.setAttribute('align','center');
	                      
		this.CreateObject();    
	    this.AdjustSize();	 
 	}
 	 	
 	this.CreateObject = function()
 	{
 		Silverlight.createObjectEx({
 			source: this.GetXamlLocation(), 
 			parentElement:$('PlayerVideo'), 
 			id:'EmbeddedPlayer',
 			properties:
 				{width:LayoutOptions.VideoWidth, 
 				height:LayoutOptions.VideoHeight,
 				background:'black', 
 				isWindowless:'false', 
 				framerate:'24',
 				version:'1.0'}, 
 			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)
    {
	    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();
	    
   	    if(Manifest.UnicastVideoUrl && Manifest.UnicastVideoUrl.length > 0)
	    {
	        this.pci.SetMedia(Manifest.UnicastVideoUrl);
	    }
	    else
	    {
	        this.pci.SetMedia(Manifest.VideoUrl);
	    }
	    
	    this.Volume = new SfMediaPlayer.Volume(this.pci);	  
  		this.timerManager = new SfMediaPlayer.SL1.TimerManager(this);
	}
	
	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));
		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:
    	        if(mPlayer.PlayerDetect.IsMacPPC())
                {
                    this.timerManager.pollLiveSlides = true;	
	            }    	            
    	    	break;
    	    case SfKernel.PresentationPlayStatus.OnDemand:
    		    this.AddTimelineMarkers();
    	        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.AddTimelineMarkers = function()
	{		
		var markers = this.media['markers'];	
		markers.clear();
		
		for (var i=0; i<Manifest.Slides.length; ++i)
		{
			var marker = this.embeddedPlayer.content.createFromXaml("<TimelineMarker Time='" + this.getFormattedTiming(Manifest.Slides[i].Time) + "' Type='MS5' Text='HE(\"S\", " + (i+1) + ")' />");
			markers.add(marker);
		}

		var marker = this.embeddedPlayer.content.createFromXaml("<TimelineMarker Time='" + this.getFormattedTiming((this.pci.GetMediaDuration() - 250)) + "' Type='MS5' Text='HE(\"E\")' />");
		markers.add(marker);
	}

	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');
	    
	    if(Silverlight.isInstalled('1.0'))
	    {	        
		    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;
    }

}

/// SL1 MediaPlayer Timer Manager

SfMediaPlayer.SL1.TimerManager = function(mediaPlayer)
{
    this.player = mediaPlayer;    
	this.positionTimer = null;
	this.slideUpdateTimer = null;	
	this.pollLiveSlides = false;
	this.timerInterval = 200;
			
	this.Start = function()
	{
		clearTimeout(this.positionTimer);
		this.TimedUpdate();
		
        if(this.pollLiveSlides)
	    {
	    	clearTimeout(this.slideUpdateTimer);
            this.TimedSlideUpdate();	            
	    }
	}
	
	this.Stop = function()
	{
		this.PostTimerUpdatedEvent(this.player.pci.GetPosition());
		clearTimeout(this.positionTimer);
    	clearTimeout(this.slideUpdateTimer);
	}
	
	this.PostTimerUpdatedEvent = function(pos)
	{
		mPlayer.EventManager.PostEvent(SfKernel.EventType.TimerLoop, this, {"Position":pos});
	}

	this.TimedUpdate = function()
	{
	    if(!mPlayer.PlayerSliderInstance.IsCurrentlyDragging && this.player.pci.GetPlayState() == SfKernel.MediaState.Playing)
	    {
       	   var currentPosition = this.player.pci.GetPosition();
       	   
       	   if(this.player.LastSeekPosition > currentPosition)
       	   {       	        
       	        this.positionTimer = setTimeout(this.TimedUpdate.bind(this),this.timerInterval);
       	        return;
       	   }
       	   
	       this.PostTimerUpdatedEvent(currentPosition);
	       	       	    
	       if(this.player.StopTime && this.player.StopTime < currentPosition)
	       {	            
	            this.player.Pause();
	            this.player.StopTime = null;
	            mPlayer.PlayerPositionPanelInstance.SetDisplayText(Localization.MediaPlayer.ClipEnded);
	            return;
	       }
	                   
         }
         	    	   		
		this.positionTimer = setTimeout(this.TimedUpdate.bind(this), this.timerInterval);
	}
	
	this.TimedSlideUpdate = function()
	{
		SonicFoundry.Mediasite.Player.DataAccess.PlayerService.GetLiveStatus
		(
			Manifest.PresentationId,
			Function.createDelegate(this, this.GetPresentationStatusInformationOnSuccess),
			Function.createDelegate(this, this.GetPresentationStatusInformationOnFailure),
			'GetLiveStatus'
		);
	}
		
	this.GetPresentationStatusInformationOnSuccess = function(result, context)
	{
    	if (result.PlayStatus != SfKernel.PresentationPlayStatus.Live)
		{
		    mPlayer.EventManager.PostEvent(SfKernel.EventType.Script, this, {Command: SfKernel.ScriptCmdType.EndPresentation});
		}
		else
		{		 
		    if(result.CurrentSlide > 0 && result.CurrentSlide > mPlayer.CurrentSlideNumber)
		    {	    		
		        for(var i=mPlayer.CurrentSlideNumber; i<result.CurrentSlide; i++)
		        {
		            this.player.ScriptParser.HE('S', i+1);
		        }		        
		    }   		    
    	    this.slideUpdateTimer = setTimeout(this.TimedSlideUpdate.bind(this), this.player.SlideCheckInterval);
		}
	}
	
	this.GetPresentationStatusInformationOnFailure = function(error, context)
	{
		Sys.Debug.trace("GetPresentationStatusInformationOnFailure(): " + error.Message);
	    this.slideUpdateTimer = setTimeout(this.TimedSlideUpdate.bind(this), this.player.SlideCheckInterval);
	}

	
	
}


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

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;
    }
}