class ServerBrowserTabConsolePages extends ServerBrowserTab
{
	private bool m_IsFilterChanged;
	private bool m_IsFilterFocused;
	protected bool m_MouseKeyboardControlled
	
	private Widget m_WidgetNavFilters;
	private Widget m_WidgetNavServers;
	
	protected Widget								m_ButtonPageLeftImg;
	protected Widget								m_ButtonPageRightImg;
	
	protected int									m_PreviousPage;
	protected int									m_TotalServersCount;
	protected int									m_PageStartNum;
	protected int									m_PageEndNum;
	protected int									m_PagesCount;
	protected int									m_ServersEstimateCount;
	protected int									m_TimeLastServerRefresh;
	protected int									m_TimeLastServerRefreshHoldButton;
	
	protected Widget								m_PnlPagesPanel;
	protected TextWidget							m_PnlPagesLoadingText;
	protected ref array<ref ServerBrowserEntry>		m_ServerListEntiers;
	
	protected override void Construct( Widget parent, ServerBrowserMenuNew menu, TabType type )
	{
		m_Root = GetGame().GetWorkspace().CreateWidgets( "gui/layouts/new_ui/server_browser/xbox/server_browser_tab_console_pages.layout", parent );
		
		m_ServerListScroller	= ScrollWidget.Cast( m_Root.FindAnyWidget( "server_list_scroller" ) );
		m_ServerList			= SpacerBaseWidget.Cast( m_ServerListScroller.FindAnyWidget( "server_list_content" ) );
		m_ServerListScroller.VScrollToPos01( 0 );
		
		m_ServerListEntiers		= new array<ref ServerBrowserEntry>;
		m_EntryWidgets			= new map<string, ref ServerBrowserEntry>;
		m_EntriesSorted			= new map<ESortType, ref array<ref GetServersResultRow>>;
		
		m_EntriesSorted[ESortType.HOST] = new array<ref GetServersResultRow>;
		m_EntriesSorted[ESortType.POPULATION] = new array<ref GetServersResultRow>;
		
		m_Menu					= menu;
		m_TabType				= type;
		
		m_ApplyFilter			= m_Root.FindAnyWidget( "apply_filter_button" );
		m_ResetFilters			= m_Root.FindAnyWidget( "reset_filter_button" );
		m_RefreshList			= m_Root.FindAnyWidget( "refresh_list_button" );
		m_FiltersChanged		= m_Root.FindAnyWidget( "unapplied_filters_notify" );
		m_HostSort				= m_Root.FindAnyWidget( "server_list_content_header_host" );
		m_TimeSort				= m_Root.FindAnyWidget( "server_list_content_header_time" );
		m_PopulationSort		= m_Root.FindAnyWidget( "server_list_content_header_population" );
		m_SlotsSort				= m_Root.FindAnyWidget( "server_list_content_header_slots" );
		m_PingSort				= m_Root.FindAnyWidget( "server_list_content_header_ping" );
		m_FilterSearchText		= m_Root.FindAnyWidget( "search_name_button" );
		m_FilterSearchTextBox	= m_Root.FindAnyWidget( "search_name_setting_option" );
		m_LoadingText			= TextWidget.Cast( m_Root.FindAnyWidget( "loading_servers_info" ) );
		m_WidgetNavFilters		= m_Root.FindAnyWidget( "filters_root_nav_wrapper" );
		m_WidgetNavServers		= m_Root.FindAnyWidget( "server_list_root_nav_wrapper" );
		
		m_BtnPagePrev			= ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_prev" ) ) ;
		m_BtnPageNext			= ButtonWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_next" ) ) ;
		
		#ifdef PLATFORM_PS4
			m_ButtonPageLeftImg = m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_ps4" );
			m_ButtonPageRightImg = m_Root.FindAnyWidget( "servers_navigation_page_next_icon_ps4" );
			m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_xbox" ).Show( false );
			m_Root.FindAnyWidget( "servers_navigation_page_next_icon_xbox" ).Show( false );
		#else
			m_ButtonPageLeftImg = m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_xbox" );
			m_ButtonPageRightImg = m_Root.FindAnyWidget( "servers_navigation_page_next_icon_xbox" );
			m_Root.FindAnyWidget( "servers_navigation_page_prev_icon_ps4" ).Show( false );
			m_Root.FindAnyWidget( "servers_navigation_page_next_icon_ps4" ).Show( false );
		#endif
		
		ShowHideConsoleWidgets();		
		
		m_Filters				= new ServerBrowserFilterContainer( m_Root.FindAnyWidget( "filters_content" ), this );
		
		m_PnlPagesPanel			= m_Root.FindAnyWidget( "servers_navigation_spacer" );
		m_PreviousPage			= 1;
		SetCurrentPage( 1 );
		m_PnlPagesPanel.Show( true );
		m_LoadingFinished		= true;
		
		m_Filters.OnSortChanged( m_Filters.m_SortingFilter.GetValue() );
		SetFocusFilters();
		UpdatePageButtons();
		
		m_Root.SetHandler( this );
		m_FilterSearchTextBox.SetHandler( this );
		
		GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);

		OnInputDeviceChanged(GetGame().GetInput().GetCurrentInputDevice());
	}
	
	void ShowHideConsoleWidgets()
	{
		bool is_xbox = true;
		
#ifdef PLATFORM_PS4
		is_xbox = false;
#endif
		
		m_Root.FindAnyWidget( "filters_button_wrapper" ).Show( GetGame().GetInput().IsEnabledMouseAndKeyboard() );
		
		m_Root.FindAnyWidget( "filters_root_nav_img_lb_xbox" ).Show( is_xbox );
		m_Root.FindAnyWidget( "filters_root_nav_img_rb_xbox" ).Show( is_xbox );
		m_Root.FindAnyWidget( "server_list_root_nav_img_lb_xbox" ).Show( is_xbox );
		m_Root.FindAnyWidget( "server_list_root_nav_img_rb_xbox" ).Show( is_xbox );
		
		m_Root.FindAnyWidget( "filters_root_nav_img_l1_ps4" ).Show( !is_xbox );
		m_Root.FindAnyWidget( "filters_root_nav_img_r1_ps4" ).Show( !is_xbox );
		m_Root.FindAnyWidget( "server_list_root_nav_img_l1_ps4" ).Show( !is_xbox );
		m_Root.FindAnyWidget( "server_list_root_nav_img_r1_ps4" ).Show( !is_xbox );
	}

	protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
	{
		switch (pInputDeviceType)
		{
		case EInputDeviceType.CONTROLLER:
			ShowHideConsoleWidgets();
			UpdatePageButtons();
			m_WidgetNavFilters.Show(m_IsFilterFocused);
			m_WidgetNavServers.Show(!m_IsFilterFocused);
			m_MouseKeyboardControlled = false;
		break;

		default:
			if (GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
			{
				m_WidgetNavFilters.Show(false);
				m_WidgetNavServers.Show(false);
				m_ButtonPageLeftImg.Show(false);
				m_ButtonPageRightImg.Show(false);
				m_MouseKeyboardControlled = true;
			}
		break;
		}
	}
	
	override void OnLoadServersAsyncConsole( GetServersResult result_list, EBiosError error, string response )
	{	
		if ( error != EBiosError.OK )
		{
			m_LoadingText.SetText( string.Format("Error: %1", ErrorModuleHandler.GetClientMessage(ErrorCategory.BIOSError, error)) );
			m_Menu.SetServersLoadingTab( TabType.NONE );
			m_LoadingFinished = true;
			SetFocusFilters();
			return;
		}
				
		m_PagesCount = result_list.m_Pages;
		m_TotalServersCount = result_list.m_NumServers;
		
		LoadEntries( result_list.m_Page, result_list.m_Results );				
		
		if (m_TotalLoadedServers == 0)
		{
			SetFocusFilters();
		}
		
		OnLoadServersAsyncFinished();
		UpdatePageButtons();
	}
	
	void OnLoadServersAsyncFinished()
	{
		string msg = "#servers_found: " + m_TotalLoadedServers;
		if ( m_TotalLoadedServers == 0 )
		{
			msg = "#server_browser_tab_unable_to_get_server";
		}
		m_LoadingText.SetText( msg );
		m_LoadingFinished = true;
		
		m_Menu.SetServersLoadingTab( TabType.NONE );
	}
	
 	protected void LoadEntries( int cur_page_index , GetServersResultRowArray page_entries )
	{
		int index = 0;
		ServerBrowserEntry entry;
		m_TotalLoadedServers = m_TotalServersCount;
		
		if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
		{
			return;
		}
		
		// only load servers if they correspond to current page
		if (cur_page_index != m_CurrentPageNum)
		{
			return;
		}
		
		if ( m_PagesCount && page_entries )
		{
			foreach ( GetServersResultRow result : page_entries )
			{
				if ( PassFilter( result ) )
				{
					string ipPort = result.GetIpPort();
					bool isFavorited = m_Menu.IsFavorited(ipPort);
					
					entry = GetServerEntryByIndex( index );
					entry.SetIsOnline(true);
					entry.FillInfo( result );
					entry.SetFavorite(isFavorited);
					entry.UpdateEntry();
					
					if (isFavorited && m_OnlineFavServers.Find(ipPort) == -1)
					{
						m_OnlineFavServers.Insert(ipPort);
					}
										
					m_EntryWidgets.Insert(ipPort, entry);
					m_EntriesSorted[m_SortType].Insert( result );
					
					index++;
				}
				
				if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
				{
					return;
				}
			}
		}
		
		LoadExtraEntries(index);
		m_ServerList.Update();
		SetFocusServers();
	}
	
	protected ServerBrowserEntry GetServerEntryByIndex( int index )
	{
		ServerBrowserEntry entry;
		
		if ( index >= 0 )
		{
			if ( index < m_ServerListEntiers.Count() )
			{
				entry = m_ServerListEntiers[index];
			}
			else
			{
				entry = new ServerBrowserEntry( m_ServerList, index, this );				
				m_ServerListEntiers.Insert(entry);
			}
		}
		else
		{
			return null;
		}
		
		entry.Show( true );
		
		return entry;
	}
	
	override void OnFilterChanged()
	{
		m_IsFilterChanged = true;
	}
	
	bool CanRefreshServerList()
	{	
		return m_LoadingFinished;
	}
	
	override void RefreshList()
	{
		for ( int i = 0; i < m_ServerListEntiers.Count(); i++ )
		{
			m_ServerListEntiers[i].Show(false);
		}
		
		for ( int j = 0; j < m_EntriesSorted.Count(); j++ )
		{
			array<ref GetServersResultRow> result_rows = m_EntriesSorted.GetElement(j);
			
			if ( result_rows )
			{
				result_rows.Clear();
			}
		}
		
		m_IsFilterChanged = false;
		m_Filters.SaveFilters();
		
		super.RefreshList();
		
		m_ServerListScroller.VScrollToPos01( 0 );
		
		m_LoadingText.SetText( "#dayz_game_loading" );
	}
	
	override void ResetFilters()
	{
		super.ResetFilters();
		
		m_IsFilterChanged = false;
	}
	
	override void ApplyFilters()
	{
		if ( m_IsFilterChanged )
		{
			SetCurrentPage(1);
		}
		
		m_IsFilterChanged = false;
		m_CurrentFilterInput = m_Filters.GetFilterOptionsConsoles();
		RefreshList();
	}
	
	override void PressA()
	{
		
	}
	
	override void PressX()
	{
		if ( (GetGame().GetTime() - m_TimeLastServerRefresh) > 1000 )
		{
			m_TimeLastServerRefresh = GetGame().GetTime();
			
			if ( m_IsFilterChanged)
			{
				SetCurrentPage(1);
			}
			m_OnlineFavServers.Clear();
			RefreshList();
		}
		
	}
	
	override void PressY()
	{
		switch ( m_SelectedPanel )
		{
			case SelectedPanel.BROWSER:
			{
				if ( m_SelectedServer )
				{
					m_Menu.ServerListFocus( true, m_SelectedServer.ToggleFavorite() );
				}
				break;
			}
			case SelectedPanel.FILTERS:
			{
				if ( m_Filters )
				{
					m_Filters.ResetFilters();
				}
				break;
			}
		}
	}
	
	override void Left()
	{
		if ( !m_IsFilterFocused )
		{
			int curr_page = GetCurrentPage();
			m_PreviousPage = curr_page;
			if ( curr_page > 1 )
			{
				SetCurrentPage( curr_page - 1 );
				UpdatePageButtons();
			}
		}
	}
	
	override void LeftHold()
	{
		if ( !m_IsFilterFocused )
		{
			if ( (GetGame().GetTime() - m_TimeLastServerRefreshHoldButton) > 100 )
			{
				m_TimeLastServerRefreshHoldButton = GetGame().GetTime();
				Left();
			}
		}		
	}
	
	override void LeftRelease()
	{
		if ( !m_IsFilterFocused && GetCurrentPage() != m_PreviousPage )
		{
			RefreshList();
		}
	}
	
	override void Right()
	{
		if ( !m_IsFilterFocused )
		{
			int curr_page = GetCurrentPage();
			m_PreviousPage = curr_page;
			if ( curr_page < m_PagesCount )
			{
				SetCurrentPage( curr_page + 1 );
				UpdatePageButtons();
			}
		}
	}
	
	override void RightHold()
	{
		if ( !m_IsFilterFocused )
		{
			if ( (GetGame().GetTime() - m_TimeLastServerRefreshHoldButton) > 100 )
			{				
				m_TimeLastServerRefreshHoldButton = GetGame().GetTime();
				Right();
			}
		}
	}
	
	override void RightRelease()
	{
		if ( !m_IsFilterFocused && GetCurrentPage() != m_PreviousPage )
		{
			RefreshList();
		}
	}
	
	override void PressSholderLeft()
	{
		if ( m_IsFilterFocused )
		{
			SetFocusServers();
		}
		else
		{
			SetFocusFilters();
		}
	}
	
	override void PressSholderRight()
	{
		if ( m_IsFilterFocused )
		{
			SetFocusServers();
		}
		else
		{
			SetFocusFilters();
		}
	}
	override void Focus()
	{
		if ( m_EntryWidgets.Contains( m_CurrentSelectedServer ) )
		{
			m_EntryWidgets.Get( m_CurrentSelectedServer ).Focus();
			ScrollToEntry( m_EntryWidgets.Get( m_CurrentSelectedServer ) );
		}
		
		array<ref GetServersResultRow> entries = m_EntriesSorted[m_SortType];
		if ( entries && entries.Count() > 0 )
			SetFocusServers();
		else
			SetFocusFilters();
	}
	
	
	void SetFocusFilters()
	{
		SetEnableFilters(true);
		SetEnableServers(false);
		
		// if loaded servers is 0, then hide Top navigation menu <Left / Right>
		if (!m_MouseKeyboardControlled)
		{
			m_WidgetNavFilters.Show(true);
			m_WidgetNavServers.Show(false);
		}
		
		m_Filters.Focus();
		m_IsFilterFocused = true;
		
		UpdatePageButtons();
	}
	
	void SetFocusServers()
	{
		SetEnableServers(true);
		SetEnableFilters(false);
		
		if (!m_MouseKeyboardControlled)
		{
			m_WidgetNavFilters.Show(false);
			m_WidgetNavServers.Show(true);
		}

		array<ref GetServersResultRow> entries = m_EntriesSorted[m_SortType];
		if ( entries && entries.Count() > 0 )
		{
			m_EntryWidgets.Get(entries.Get(0).GetIpPort()).Focus();
		}
		else
		{
			SetFocus( null );
		}
		
		m_IsFilterFocused = false;
		m_Menu.ShowYButton(true);
		m_Menu.ShowAButton(true);
		
		UpdatePageButtons();
	}
	
	void SetEnableFilters(bool enable)
	{		
		Widget w_filters = m_Root.FindAnyWidget("filters_content");
		Widget w_content = m_Root.FindAnyWidget("server_list_scroller");
		w_content.Enable( !enable );
		
		if ( enable )
		{
			SetFocus( ButtonWidget.Cast(w_filters.FindWidget("sort_button")) );
		}
	}
	
	void SetEnableServers(bool enable)
	{		
		Widget w_filters = m_Root.FindAnyWidget("filters_content");
		Widget w_content = m_Root.FindAnyWidget("server_list_scroller");
		w_content.Enable( enable );
	}
	
	void UpdatePageButtons()
	{
		TextWidget wgt_page_stat = TextWidget.Cast( m_Root.FindAnyWidget( "servers_navigation_page_status" ) );		
		
		wgt_page_stat.SetText( GetCurrentPage().ToString() +" / "+ m_PagesCount.ToString() );
				
		if ( !m_IsFilterFocused && (m_PagesCount > 1) && !m_MouseKeyboardControlled )
		{
			bool can_left = (GetCurrentPage() > 1);
			m_ButtonPageLeftImg.Show( can_left );
			m_BtnPagePrev.Show( can_left );
			
			bool can_right = (GetCurrentPage() < m_PagesCount);
			m_ButtonPageRightImg.Show( can_right );
			m_BtnPageNext.Show( can_right );
		}
		else
		{
			m_ButtonPageLeftImg.Show( false );
			m_BtnPagePrev.Show( false );
			m_ButtonPageRightImg.Show( false );
			m_BtnPageNext.Show( false );
		}
	}
	
	override bool OnClick( Widget w, int x, int y, int button )
	{
		super.OnClick( w, x, y, button );
		
		if ( button == MouseState.LEFT )
		{
			if ( w == m_ResetFilters )
			{
				ResetFilters();
			}
			else if ( w == m_ApplyFilter )
			{
				ApplyFilters();
				return true;
			}
			else if ( w == m_RefreshList )
			{
				if ( m_Loading && !m_LoadingFinished )
				{
					PressX();
				}
				else
				{
					RefreshList();
				}
				
				return true;
			}
			else if ( w == m_BtnPagePrev )
			{
				Left();
				return true;
			}
			else if ( w == m_BtnPageNext )
			{
				Right();
				return true;
			}
		}
		return false;
	}
	
	//Coloring functions (Until WidgetStyles are useful)
	override void ColorHighlight( Widget w )
	{
		if ( !w )
		{
			return;
		}
		
		w.SetColor( ARGB( 255, 200, 0, 0) );
	}
	
	override void ColorNormal( Widget w )
	{
		if ( !w )
		{
			return
		}
		
		if ( (w.GetFlags() & WidgetFlags.IGNOREPOINTER) == WidgetFlags.IGNOREPOINTER )
		{
			return;
		}
		
		if ( w.IsInherited( ButtonWidget ) )
		{
			ButtonWidget button = ButtonWidget.Cast( w );
			button.SetTextColor( ARGB( 255, 255, 255, 255 ) );
		}
		else if ( !w.IsInherited( EditBoxWidget ) )
		{
			w.SetColor( ARGB( 0, 255, 255, 255 ) );
		}
		
		TextWidget text1	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text" ) );
		TextWidget text2	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text_1" ) );
		TextWidget text3	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_label" ) );
		ImageWidget image	= ImageWidget.Cast( w.FindAnyWidget( w.GetName() + "_image" ) );
		
		Widget option	= Widget.Cast( w.FindAnyWidget( w.GetName() + "_option_wrapper" ) );
		
		if ( text1 )
		{
			text1.SetColor( ARGB( 255, 255, 255, 255 ) );
		}
		
		if ( text2 )
		{
			text2.SetColor( ARGB( 255, 255, 255, 255 ) );
		}
		
		if ( text3 )
		{
			text3.SetColor( ARGB( 255, 255, 255, 255 ) );
			w.SetAlpha(0);
		}
		
		if ( image )
		{
			image.SetColor( ARGB( 255, 255, 255, 255 ) );
		}
		
		if ( option )
		{
			option.SetColor( ARGB( 150, 255, 255, 255 ) );
		}
	}
	
	override void ColorDisable( Widget w )
	{
		#ifdef PLATFORM_WINDOWS
		SetFocus( null );
		#endif
		
		ButtonWidget button = ButtonWidget.Cast( w );
		if ( button )
		{
			button.SetTextColor( ColorManager.COLOR_DISABLED_TEXT );
		}
	}
}