/// 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)
    {
        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.SL1.TimerManager(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));
        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;
    }
}