<?xml version="1.0" encoding="utf-8"?>
<mx:VBox xmlns:mx="http://www.adobe.com/2006/mxml"
		 width="100%" height="100%"
		 paddingBottom="0" paddingRight="0" paddingLeft="0" paddingTop="0"
		 show="initDisplayBoard()"
		 hide="stopBoardTimer()" xmlns:widget="gov.va.med.edp.widget.*">

	<mx:Script>
		<![CDATA[
			import mx.utils.ObjectUtil;
		import gov.va.med.edp.util.BoardTools;
		import gov.va.med.edp.view.LoadingDialog;
		import mx.events.FlexEvent;
		import mx.binding.utils.ChangeWatcher;
		import mx.collections.ArrayCollection;
		import mx.formatters.DateFormatter;
		import mx.core.Application;
		import mx.controls.dataGridClasses.DataGridColumn;
		import mx.events.DataGridEvent;

		import gov.va.med.edp.vo.ColumnSpecVO;
		import gov.va.med.edp.control.DisplayBoardEvent;
		import gov.va.med.edp.model.TrackingModelLocator;
		import gov.va.med.edp.widget.ColorCellRenderer;
		import gov.va.med.edp.control.SortHeaderEvent;
		import gov.va.med.edp.control.NumberEvent;

		[Bindable]
		private var dateFormatter:DateFormatter;
		private var sortColumn:DataGridColumn;

		[Bindable]
		private var model: TrackingModelLocator = TrackingModelLocator.getInstance();

		private	var visibleBoardTimer: Timer = new Timer(1200, 1);
		private	var refreshTimer: Timer = new Timer(30000);
		private var autoScrollTimer: Timer = new Timer(10000);
		private var counter:int = 0;
		private var boardName: String = "";

		private var _disconnected:Boolean = false;
		private var _connecting:Boolean = false;

		private static var MINIMUM_FONT_SIZE:Number = 9;
		private static var MINIMUM_ROW_HEIGHT:int = 18;

		[Bindable]
		public function get disconnected():Boolean {
			return _disconnected;
		}

		public function set disconnected(b:Boolean):void {
			_disconnected = b;
			if (_disconnected) {
				if (dateFormatter == null) {
					dateFormatter = new DateFormatter();
					dateFormatter.formatString = "MMM DD,YY JJ:NN";
				}
				stopBoardTimer();
				currentState = 'disconnected';
			} else {
				currentState = '';
				startBoardTimer();
			}
		}

		[Bindable]
		public function get connecting():Boolean {
			return _connecting;
		}

		public function set connecting(b:Boolean):void {
			_connecting = b;
			if (_connecting) {
				connectingSpinner.play();
			} else {
				connectingSpinner.stop();
			}
		}

		private function initDisplayBoard(): void
		{
			if (model.session.area < 1) return;

			boardName = Application.application.parameters.board;
			model.reloadFunction = reload;

			dispatchBoardInit();
			visibleBoardTimer.addEventListener(TimerEvent.TIMER_COMPLETE, removeLoadingDialog);
			refreshTimer.addEventListener(TimerEvent.TIMER, refreshDisplayBoard);
			refreshTimer.start();
			visibleBoardTimer.start();
			
			autoScrollTimer.addEventListener(TimerEvent.TIMER, doScroll);

			model.reconnectFunction = reconnect;

			LoadingDialog.show();
		}

		private function dispatchBoardInit(): void {
			var resetEvent: DisplayBoardEvent = new DisplayBoardEvent(DisplayBoardEvent.EVENT_INIT_DISPLAY_BOARD);
			resetEvent.name = boardName;
			resetEvent.dispatch();
		}

		private function reconnect():void {
			dispatchBoardInit();
		}

		private function reload():void {
			var url:String = TrackingModelLocator.getInstance().rootURL;
			if (TrackingModelLocator.getInstance().contextRoot.indexOf("main") != -1) {
				url += "board.html";
			} else {
				url += "bigboard.html";
			}
			if (Application.application.parameters.board || Application.application.parameters.area) {
				url += "?";
			}
			if (Application.application.parameters.board) {
				url += "board=" + Application.application.parameters.board;
			}
			if (Application.application.parameters.area) {
				if (Application.application.parameters.board) url += "&";
				url += "area=" + Application.application.parameters.area;
			}
			navigateToURL(new URLRequest(url), "_top");                        
		}

		private function stopBoardTimer(): void
		{
			refreshTimer.reset();
		}

		private function startBoardTimer(): void
		{
			if (!refreshTimer.running) refreshTimer.start();
		}

		private function refreshDisplayBoard(event: TimerEvent): void
		{
			if (model.session.area < 1) return;

			var refreshEvent: DisplayBoardEvent =
					new DisplayBoardEvent(DisplayBoardEvent.EVENT_REFRESH_DISPLAY_BOARD);
			refreshEvent.name = boardName;
			refreshEvent.dispatch();

		}

		private function removeLoadingDialog(event: TimerEvent): void
		{
			LoadingDialog.hide();
		}

		private function set readyToBuild(value: Boolean): void
		{
			if (value == true) {
				callLater(buildColumns);
			}
		}

		private function buildColumns(): void
		{
			clearBoardProperties();
			var newCols:Array = new Array();
			var newCol: DataGridColumn;
			for each (var colInfo: ColumnSpecVO in model.boardSpec.columns) {
				newCol = new DataGridColumn(colInfo.attribute);
				newCol.headerText = colInfo.header;
				newCol.dataField = colInfo.attribute;
				newCol.width = colInfo.width;

				//set the label and sort function for any minute based columns
				if (colInfo.attribute.indexOf("min") != -1) {
					newCol.sortCompareFunction = sortMinutes;
					newCol.labelFunction = BoardTools.displayTimeAsHrsAndMins;
				}


				if ((colInfo.attribute == "@last4") || (colInfo.attribute == "@ptNm")) {
					newCol.itemRenderer = new ClassFactory(gov.va.med.edp.widget.PatientCellRenderer);
				} else if (colInfo.attribute == "@visit") {
					newCol.itemRenderer = new ClassFactory(gov.va.med.edp.widget.VisitRenderer);
				} else {
					newCol.itemRenderer = new ClassFactory(gov.va.med.edp.widget.ColorCellRenderer);
				}
				newCols.push(newCol);
			}

			board.columns = newCols;

			//Set the Board properties here..
			board.width = model.boardSpec.displayBoardProperties.displaySize.width;

			//start the timer and get original DG properties
			doScroll(new TimerEvent(TimerEvent.TIMER));
			initAutoScrollTimer();

			board.setVisible(true);
		}

		private function initAutoScrollTimer(): void {
			autoScrollTimer.reset();
			autoScrollTimer.delay = model.boardSpec.displayBoardProperties.scrollDelay * 1000;
			autoScrollTimer.start();
		}

		private function clearBoardProperties(): void
		{
			counter = 0;
			if (board != null) {
				board.invalidateSize();
				board.invalidateDisplayList();
				board.invalidateProperties();
				board.invalidateList();
				board.initialize();
			}
		}

		// this must be called later by handleHeader for the sortField to be accurate
		private function saveSortInfo(col:DataGridColumn): void
		{
			var sortEvent:SortHeaderEvent =
					new SortHeaderEvent(SortHeaderEvent.EVENT_SORT_DISPLAY_BOARD);
			sortEvent.sortDescending = col.sortDescending;
			sortEvent.sortField = col.dataField;
			sortEvent.dispatch();
		}

		private function handleHeader(event:DataGridEvent): void
		{
			sortColumn = DataGridColumn(event.currentTarget.columns[event.columnIndex]);
			callLater(saveSortInfo, [sortColumn]);
		}


		private function sortMinutes(obj1:Object, obj2:Object):int
		{
			if (sortColumn == null) return 0;

			var num1:Number = parseInt(obj1[sortColumn.dataField]);
			var num2:Number = parseInt(obj2[sortColumn.dataField]);
			return ObjectUtil.numericCompare(num1, num2);
		}

		private function doScroll(event: TimerEvent): void
		{
			if (isSquishOrAutoScrollingNeeded()) {
				if (model.boardSpec.displayBoardProperties.squish) {
					doSquishIfPossible();
				} else {
					startScrolling();
				}
			} else {
				board.verticalScrollPosition = 0;
				resetOriginalBoardProperties();
			}
		}


		private function isSquishOrAutoScrollingNeeded(): Boolean
		{
			var neededRowHeight: Number = model.boardData.length * getGridRowHeight();
			if ((neededRowHeight + board.headerHeight) < board.height) {
				return false;
			}
			return true;
		}


		private function doSquishIfPossible(): void
		{
			if (isSquishPossible()) {
				squishDGRows();
			} else {
				startScrolling();
			}
		}


		private function isSquishPossible(): Boolean
		{
			if (getSquishedGridRowHt() >= MINIMUM_ROW_HEIGHT) {
				return true;
			}
			return false;
		}

		private function squishDGRows(): void
		{
			board.verticalScrollPolicy = "off";
			var userConfiguredFontSize:int = model.boardSpec.displayBoardProperties.fontSize;
			var squishedFontSize: Number = (getSquishedGridRowHt() / getGridRowHeight()) * userConfiguredFontSize;

			var changeEvent: NumberEvent = new NumberEvent(NumberEvent.EVENT_CHANGE_SQUISH_FONT_SIZE);

			if (squishedFontSize >= MINIMUM_FONT_SIZE && squishedFontSize <= userConfiguredFontSize) {
				changeEvent.value = squishedFontSize;
				board.setStyle("fontSize", squishedFontSize);
				board.rowHeight = getSquishedGridRowHt();

			} else if (squishedFontSize > userConfiguredFontSize) {
				changeEvent.value = userConfiguredFontSize;
				board.setStyle("fontSize", userConfiguredFontSize);
				board.rowHeight = getGridRowHeight();
			} else {
				changeEvent.value = MINIMUM_FONT_SIZE;
				board.setStyle("fontSize", MINIMUM_FONT_SIZE);
				board.rowHeight = MINIMUM_ROW_HEIGHT
			}
			changeEvent.dispatch();
		}

		private function getSquishedGridRowHt(): Number
		{
			//40 pixels for making sure we see all the screen...Sometimes there is plastic that cover the actual screen in laptops etc..
			//saw this on one of testing laptops where some portion of last row was hidden under plastic covering.. 
			var boardHeight:Number = (board.height - board.headerHeight - 40);
			var rowHeight:Number = boardHeight / (model.boardData.length + 1);
			return rowHeight
		}

		//There is now way to calculate row height since everything is dynamic
		//we can only go of something that we do know and it's user configured Font size.
		private function getGridRowHeight(): int {
			var rowHt:int = Math.floor(model.boardSpec.displayBoardProperties.fontSize * 2);
			return rowHt;
		}

		private function startScrolling(): void {
			//Reset the board properties back to original settings
			resetOriginalBoardProperties();

			//recalcuate the loops here in case the dataprovider has changed..
			var actualRowCountNum:Number = (board.height - board.headerHeight) / getGridRowHeight();  //account for header
			var actualRowCount:int = Math.floor(actualRowCountNum);
			var loopsNum:Number = (model.boardData.length + 1) / (actualRowCount);
			var numOfLoops:int = Math.ceil(loopsNum);


			if (counter >= numOfLoops) counter = 0;
			board.verticalScrollPosition = (counter * actualRowCount);
			counter++;
		}

		private function resetOriginalBoardProperties(): void {
			board.verticalScrollPolicy = "auto";
			board.setStyle("fontSize", model.boardSpec.displayBoardProperties.fontSize);
			board.rowHeight = getGridRowHeight();
			var changeEvent: NumberEvent = new NumberEvent(NumberEvent.EVENT_CHANGE_SQUISH_FONT_SIZE);
			changeEvent.value = model.boardSpec.displayBoardProperties.fontSize;
			changeEvent.dispatch();
		}
                    
		]]>
	</mx:Script>

	<mx:HBox
			id="mainArea"
			width="100%" height="100%"
			styleName="contentArea">
		<widget:DataGrid
				id="board"
				dataProvider="{model.boardData}"
				headerRelease="handleHeader(event)"
				width="100%" height="100%"
				useRollOver="false"/>
	</mx:HBox>

	<mx:Binding source="model.boardSpec.specReady" destination="readyToBuild"/>
	<mx:Binding source="model.disconnected" destination="disconnected"/>
	<mx:Binding source="model.connecting" destination="connecting"/>

	<mx:states>
		<mx:State name="disconnected">
			<mx:AddChild relativeTo="{mainArea}" position="before">
				<mx:target>
					<mx:VBox id="disconnectedBoardPanel" width="100%">
						<mx:ApplicationControlBar paddingBottom="0" paddingTop="0" dock="true" width="100%"
												  fillColors="[#FF0000,#BF0000]" fillAlphas="[0.8,0.8]">
							<mx:Text id="disconnectionMessage" horizontalCenter="0" verticalCenter="0"
									 textAlign="center" width="100%" height="100%" color="white"
									 fontSize="{model.boardSpec.displayBoardProperties.fontSize}">
								<mx:text>This board is disconnected from the server. Last updated
									{dateFormatter.format(model.boardLastUpdated)}. {model.connecting ? "Trying to reconnect..." : "Will try to reconnect in " + model.reconnectSeconds + " seconds."}
								</mx:text>
							</mx:Text>
							<widget:Spinner id="connectingSpinner" autoPlay="false" tickColor="#FFFFFF"/>
						</mx:ApplicationControlBar>
					</mx:VBox>
				</mx:target>
			</mx:AddChild>
		</mx:State>
	</mx:states>
</mx:VBox>