var TNT_PLAYER="TNT_PLAYER";
var findPlayer=xmp.baseplayer.BasePlayer.findPlayer;
var eligibleVideoCount = 0;

/********************************************************************************
                          TNT PLAYER FUNCTIONS 
********************************************************************************/

function TNTPlayer(options, parameters, listener){
	var categoryFilterArray = ['BandwidthRecorder' /*,'AjaxRequestManager', 'VideoContentMetaFileLoader'*/]; // allows filtering out of categories with too many messages.
	TNTPlayer.ctor.call(this, TNT_PLAYER, options, parameters);
	this.listener = listener;
}

function resizePlayer(viewport, sizestr) {
	var width = "576"; 
	var height = "324"; 
	var x = "0"; 
	var y = "0";	
	
	var size = sizestr.split("x")
	if (size.length > 1) {
		width = size[0];
		height = size[1];
		x = ((576 - width) / 2).toString();
		y = ((324 - height) / 2).toString();
	}
	
	if (viewport && viewport.getSize() != null) {	
		viewport.moveTo(x, y, width, height);
	}
}

xmp.DERIVE_CLASS(xmp.baseplayer.BasePlayer,TNTPlayer);

TNTPlayer.prototype.finiEx = function() {
	TNTPlayer.base.fini.call(this);
};

TNTPlayer.prototype.handleRegisterNodeListeners = function(playerCtx) {
	if (playerCtx === this.getMainPlayerContext()) {
		var listeners = [{object: new AdNodeListener(this), nodes:["PreRoll", "PostRoll", "Promo", "SponsoredAd", "HouseAd", "AdInsertNotForSale"]},
						{object: new VideoNodeListener(this), nodes:["Content"]},
						{object: new NextUpSlateNodeListener(this), nodes:["NextUpSlate"]}];
	
		for (var i = 0; i < listeners.length; i++){
			this.registerNodeListener(listeners[i].object, listeners[i].nodes, playerCtx );
		}
	} else {   
		// Overlay
	}
};

TNTPlayer.prototype.handleMediaPlayerReady = function(playerCtx) {
	if (playerCtx === this.getMainPlayerContext()) {
		this.setVolume(80, playerCtx);
		callScrubbarMethod('handleSetVolume', 80);
	
		this.setMute(false, playerCtx);
	} 
	
	this.setViewportConfig(xmp.SWF_MIME_TYPE, xmp.DHTML_VIEWPORT, playerCtx);
	this.setViewportConfig(xmp.FLASH_MIME_TYPE, xmp.DHTML_VIEWPORT, playerCtx);
	this.setViewportConfig(xmp.WINDOWS_MEDIA_MIME_TYPE, xmp.DHTML_VIEWPORT, playerCtx);
	this.setViewportConfig(xmp.IMAGE_MIME_TYPE, xmp.DHTML_VIEWPORT, playerCtx);
	this.setViewportConfig(xmp.DHTML_MIME_TYPE, xmp.DHTML_VIEWPORT, playerCtx);
};

TNTPlayer.prototype.handleCreateViewport = function(type, name, parameters, settings, playerCtx){
	if (playerCtx !== this.getMainPlayerContext()) {
        return null;
    } else if (type === xmp.FLASH_VIEWPORT) {
		return this.createFlashViewport(type, name, parameters, settings);
	} else if (type === xmp.DHTML_VIEWPORT) {
		return this.createDHTMLViewport(type, name, parameters, settings);
	}
	return null;
};

TNTPlayer.prototype.handleDestroyViewport = function(type, name, playerCtx){
	var viewport = ((navigator.appName.indexOf(xmp.MICROSOFT_BROWSER) !== -1 || 
					navigator.appName.indexOf(xmp.OPERA_BROWSER) !== -1) ? 
					window[name] : document[name]);
	
	if (viewport) {
		var parent = ((navigator.appName.indexOf(xmp.MICROSOFT_BROWSER) !== -1 || 
						navigator.appName.indexOf(xmp.OPERA_BROWSER) !== -1) ? 
						viewport.parentElement : viewport.parentNode);
		parent.removeChild(viewport);
	}
};

TNTPlayer.prototype.handleBootstrapped = function(success) {
	this.listener.onBootstrapped(success);
};

TNTPlayer.prototype.handleFatalException = function(err) {
	if (err.name === "PlugInNotFoundError" || err.name === "InvalidPlugInVersionError") {
		window.location = err.plugIn.downloadUrl;
	}
};

TNTPlayer.prototype.createFlashViewport = function(type, name, parameters, settings) {
	var viewport = new SWFObject(xmp.makeSWFPath() + "TestFlashViewport.swf", name, "576", "324", 8, "#FFFFFF");
	
	for (var i = 0; i < parameters.length; i++) {
		viewport.addParam(parameters[i].name, parameters[i].value);
	}

	for (i = 0; i < settings.length; i++) {
		viewport.addVariable(settings[i].name, settings[i].value);
	}
	
	// removed per Chad and 113007 XMP release
	//viewport.addVariable(xmp.FLASH_NATIVE_PLAYER_COMPONENT, xmp.makeSWFPath() + "FlashMediaPlayer.swf");
	viewport.write(document.getElementById("TNT_CONTAINER").id);
	
	// Store reference to flash container to use later to set container flash content.
	flash_container = xmp.findDomElement(name);
	flash_container.style.cssText = "position: absolute";
	return flash_container;
};

TNTPlayer.prototype.createDHTMLViewport = function(type, name, parameters, settings) {
	var viewport = document.createElement("div");
	viewport.setAttribute(xmp.ID_ATTRIBUTE, name);
	viewport.setAttribute(xmp.NAME_ATTRIBUTE, name);
	
	var sample_container = document.getElementById("TNT_CONTAINER");
	
	viewport.style.position = "absolute";
	viewport.style.backgroundColor = "#000000";
	viewport.style.width = "576px";
	viewport.style.height = "324px";	
	
	// Add viewport to basic container.
	tkutils.insertDomChildBefore(sample_container, viewport);
	
	return viewport;
};

TNTPlayer.prototype.seekEx = function() {
	var time = callScrubbarMethod('handleGetTime', false);
	this.seek(time, this.getMainPlayerContext());
};

TNTPlayer.prototype.setVolumeEx = function(){
	var volume = callScrubbarMethod('handleGetVolume', false);
	if (volume != undefined) {
		this.setVolume(volume, this.getMainPlayerContext());
	} else {
      	this.setVolume(80, this.getMainPlayerContext());
    }
};

TNTPlayer.prototype.setMuteEx = function() {
	this.setMute(true, this.getMainPlayerContext());
	callScrubbarMethod('handleSetVolume', 0);
};

TNTPlayer.prototype.setFullScreenEx = function() {
	if (this.isAvailable(xmp.FULLSCREEN, this.getMainPlayerContext())) {
		alert("Entering FullScreen. Press ESC to exit FullScreen.");
		this.setFullscreen(true, this.getMainPlayerContext());
	} else {
		// could use if we decide to go back to .flv
		alert("Double-click the video to enter Fullscreen. Press ESC to exit FullScreen.");
	}
};

TNTPlayer.prototype.playEx = function() {
	this.getViewport(this.getMainPlayerContext()).hideOverlays(xmp.ALL_OVERLAYS);				
	callScrubbarMethod('handleScrubEnabled', true);
	this.play(this.getMainPlayerContext());
};

TNTPlayer.prototype.pauseEx = function() {
	callScrubbarMethod('handleScrubEnabled', false);
	this.pause(this.getMainPlayerContext());
};

TNTPlayer.prototype.disableAllCommands = function() {
	callScrubbarMethod('handleScrubEnabled', false);
	callScrubbarMethod('handleTogglePlay', false);
	callScrubbarMethod('handleSetTRT', 0);
	callScrubbarMethod('handleTimelineChange', 0);
};

TNTPlayer.prototype.handlePlayListEnded = function() {
	nextVideo();
};

/********************************************************************************
                           BASE NODE LISTENER 
********************************************************************************/

function BaseNodeListener(name, player, disable_commands) {
	BaseNodeListener.ctor.call(this, name, player);
	this.disable_commands = disable_commands;
}

xmp.DERIVE_CLASS(xmp.baseplayer.listeners.AbstractNodeListener, BaseNodeListener);

BaseNodeListener.prototype.handleDynamicRules = function(node){};

BaseNodeListener.prototype.handleOpen = function(node) {
	if (true === this.disable_commands){
		this.getPlayer().disableAllCommands();
	}
	this.setStatus(node,"Opened");
};

BaseNodeListener.prototype.handleRender = function(node){
	this.getPlayer().open(node, this.getPlayerContext());
};

BaseNodeListener.prototype.handleConnecting = function(node) {
	if (node.isContentType()) {
		var item = node.getPlayableData();
		var viewport = this.getPlayer().getViewport(this.getPlayerContext());
		resizePlayer(viewport, item.getDataObject().sizes[0]);
	} 
};

BaseNodeListener.prototype.handleConnected = function(node) {};
BaseNodeListener.prototype.handlePlay = function(node){};
BaseNodeListener.prototype.handlePause = function(node){};
BaseNodeListener.prototype.handleStop = function(node){};
BaseNodeListener.prototype.handleRewind = function(node){};
BaseNodeListener.prototype.handleFastForward = function(node){};
BaseNodeListener.prototype.handleSeekable = function(node){};

BaseNodeListener.prototype.handleEnded = function(node) {
	callScrubbarMethod('handleScrubEnabled', false);
	callScrubbarMethod('handleTogglePlay', false);
	callScrubbarMethod('handleSetTRT', 0);
	callScrubbarMethod('handleTimelineChange', 0);
	this.getPlayer().advance();
};

BaseNodeListener.prototype.handleBuffering = function(node, buffStateObj) { 
	var amount = 0.01 * buffStateObj.percent;
	this.setStatus(node, amount);
};

BaseNodeListener.prototype.handleTimelineChange = function(node, position, duration){
	callScrubbarMethod('handleTogglePlay', true);
	callScrubbarMethod('handleSetTRT', duration);
	callScrubbarMethod('handleTimelineChange', position);
};

BaseNodeListener.prototype.handleError = function(node, err) {
	this.getPlayer().advance();
};

BaseNodeListener.prototype.setStatus = function(node, status) {};

BaseNodeListener.prototype.loadSynchUnit = function(node) {
	var res = node.getMetaResource('synch_unit');	
	if (!res) {
		return;
	}
	if(res.isError()) {
		return;
	}	
	var data = res.getDataObject();
	if(res.getMetadata('played_synch_unit',false)) {
		return;
	}
	res.setMetadata('played_synch_unit', true);
	this._createBannerAd("banner_ad_iframe" , data);
};

BaseNodeListener.prototype._createBannerAd = function(adId, cnnad_url){
	var adBanner = document.getElementById("banner_ad_div");
	var html = '<iframe hspace="0" vspace="0" marginHeight="0" marginWidth="0" src="'
				+ cnnad_url + '&page.allowcompete=yes&domId=' 
				+ adId + '" border="0" frameBorder="0" width="300" height="250" scrolling="no"  id="'
				+ adId + '" style="position: absolute;" ></iframe>';
	adBanner.innerHTML = html;
};

/********************************************************************************
                          AdNodeListener
                       - drives ad videos
 *******************************************************************************/

var AD_NODE_LISTENER = "Ad";

function AdNodeListener(player) {
	AdNodeListener.ctor.call(this, AD_NODE_LISTENER, player, true);
	this.PreRollFound = false;
}

xmp.DERIVE_CLASS(BaseNodeListener, AdNodeListener);

AdNodeListener.prototype.canUserControl=function(node){
	var canControl = xmp.baseplayer.BasePlayer.getSettingsManager().getContextNode().getNodeForPath('BasePlayer').getBoolean('user can control ad', false);
	return canControl;
};

AdNodeListener.prototype.handleInitialize = function(node) {};

AdNodeListener.prototype.handlePlay = function(node) {
	callScrubbarMethod('handleScrubEnabled', false);
};

AdNodeListener.prototype.handleComplete = function(node) {
	var data = node.getPlayableData();
	node.setURI( data.getPlayableId() );
	node.setMimeTypes( data.getMimeTypeArray() );
	node.setStreamingMode( xmp.AD_STREAMING_MODE );
   
	this.loadSynchUnit(node);
	
	callScrubbarMethod('handlePlayEnabled', true);
	callScrubbarMethod('handleScrubEnabled', false);
	callScrubbarMethod('handleSetTRT', node.getPlayableData().getDataObject().trt);
};

AdNodeListener.prototype.handleRender = function(node) {
	var res = node.getMetaResource('primary');
	
	AdNodeListener.base.handleRender.call(this, node);
};

AdNodeListener.prototype.handleConnecting = function(node) {
	var viewport = this.getPlayer().getViewport(this.getPlayerContext());
	resizePlayer(viewport, "576x324");	
};

AdNodeListener.prototype.handleDynamicRules = function(node){
	var nodeTypeId = node.getNodeTypeId();
	
	if ((nodeTypeId === 'PreRoll') && !this.PreRollFound) {
		this.PreRollFound=true;
		
		if (TNTRules.DontPlayRule.isActive()) {
			var ruleContext = null;
			this.getPlayer().registerRuleClass("DontPlayRule", "TNTRules.DontPlayRule");
			node.addNewRule("DontPlayRule",null);
			node.addRule(ruleContext);
		}
	}
};

AdNodeListener.prototype.handleOverrideAdResources = function(node, overrideContext) {
	var contextName = overrideContext.expandString('${player.context_name}');
	var nodeTypeId = node.getNodeTypeId();
	
	if (contextName.indexOf('Mosaic') !== -1){
		if (nodeTypeId === 'PreRoll') {
			overrideContext.getResource('primary').setId('');
			overrideContext.getResource('synch_unit').setId('');
		}
	}
};

/********************************************************************************
                          NextupSlateNodeListener
             - drives DHTML object between video content pieces
 *******************************************************************************/
 
var NEXTUP_SLATE_NODE_LISTENER = "NextUpSlate";
var HEADLINE = "headline";

function NextUpSlateNodeListener(player) {
	NextUpSlateNodeListener.ctor.call(this, NEXTUP_SLATE_NODE_LISTENER, player);
}

xmp.DERIVE_CLASS(xmp.baseplayer.listeners.DefaultSlateNodeListener, NextUpSlateNodeListener);

NextUpSlateNodeListener.prototype.handleComplete = function(node) {
	//NextUpSlateNodeListener.base.handleComplete.call(this, node);
	//node.setMetadata(HEADLINE,this._findNextContentNode().getPlayableData().getDataObject().headline);

	xmp.baseplayer.listeners.DefaultNextUpSlateNodeListener.base.handleComplete.call(this, node);
	
	var op = this.i_$18C();
	if(op !== null){
		node.setMetadata("headline", op.getPlayableData().getDataObject().headline);
	}
	
	// resize to original dimensions before showing slate
	var viewport = this.getPlayer().getViewport(this.getPlayerContext());
	resizePlayer(viewport, "576x324");

	callScrubbarMethod('handleScrubEnabled', false);
	callScrubbarMethod('handlePlayEnabled', false);
	callScrubbarMethod('handleSetTRT', 0);
	callScrubbarMethod('handleTimelineChange', 0);
};

/********************************************************************************
                          VideoNodeListener
                 - drives all video content nodes
 *******************************************************************************/
 
var VIDEO_NODE_LISTENER = "Video";

function VideoNodeListener(player) {
	VideoNodeListener.ctor.call(this, VIDEO_NODE_LISTENER, player, false);
}

xmp.DERIVE_CLASS(BaseNodeListener, VideoNodeListener);

VideoNodeListener.prototype.handleEnded = function(node) {
	callScrubbarMethod('handleScrubEnabled', false);
	callScrubbarMethod('handleTogglePlay', false);
	callScrubbarMethod('handleSetTRT', 0);
	callScrubbarMethod('handleTimelineChange', 0);
	
	// check trt and category to see if this is an ad eligible postclip
	// doing this check here because a video must also finish to be eligible
	var trt = node.getPlayableData().getDataObject().trt;
	var category = node.getPlayableData().getDataObject().category;
	if (trt > 50 && category == 'postclip') {
		eligibleVideoCount++;
		node.setMetadata('eligibleVideoCount', eligibleVideoCount); 
	} 	

	this.getPlayer().advance();
};

VideoNodeListener.prototype.handlePlay = function(node) {}

VideoNodeListener.prototype.handleInitialize = function(node) {
	var item = node.getPlayableData();
	node.setMimeTypes(item.getMimeTypeArray());
	node.setURI(item.getDataObject().location);
	node.setStreamingMode(item.getDataObject().streamingMode);
	
	//node.setSizes(item.getDataObject().sizes);
	var sizes = item.getDataObject().sizes;
	if (sizes && sizes.length > 0) {
		node.i_$UZ(item.getDataObject().sizes);
	}
	
	document.getElementById("DRM_ERROR_MSG").style.visibility = 'hidden';
	document.getElementById("TNT_CONTAINER").style.visibility = 'visible';
};

VideoNodeListener.prototype.handleComplete = function(node) {

	this.handleInitialize(node);

	callScrubbarMethod('handlePlayEnabled', true);
	callScrubbarMethod('handleScrubEnabled', true);
	callScrubbarMethod('handleSetTRT', node.getPlayableData().getDataObject().trt);
	
	if (navigator.platform.indexOf("Mac") != -1 
		&& node.getPlayableData().getDataObject().isDRM == 'true'
		&& node.getPlayableData().getDataObject().isDRM == 'true') {
		
		document.getElementById("DRM_ERROR_MSG").style.visibility = 'visible';
		document.getElementById("TNT_CONTAINER").style.visibility = 'hidden';
	} 
};

VideoNodeListener.prototype.handleError = function(node, err) {
	if (navigator.platform.indexOf("Mac") != -1 
		&& node.getPlayableData().getDataObject().isDRM == 'true'
		&& node.getPlayableData().getDataObject().isDRM == 'true') {
		
		// should have been caught in handleComplete, but just in case..
		document.getElementById("TNT_CONTAINER").style.visibility = 'hidden';
		document.getElementById("DRM_ERROR_MSG").style.visibility = 'visible';
	} else {
		if (err.name === "PlugInNotFoundError" || err.name === "InvalidPlugInVersionError") {
			window.location = err.plugIn.downloadUrl;
		} else {
			this.getPlayer().advance();
		}
	}
};