enum TabType
{
	OFFICIAL,
	COMMUNITY,
	LAN,
	FAVORITE,
	NONE
}

enum SelectedPanel
{
	BROWSER,
	FILTERS,
	MENU
}

class ServerBrowserTab extends ScriptedWidgetEventHandler
{
	protected Widget										m_Root;
	protected ScrollWidget									m_ServerListScroller;
	protected SpacerBaseWidget								m_ServerList;
	
	//protected ref array<ref GetServersResultRow>			m_Entries;
	
	protected ref map<string, ref ServerBrowserEntry>		m_EntryWidgets;
	protected ref map<string, ref array<string>>			m_EntryMods;

	protected ref ServerBrowserFilterContainer				m_Filters;
	
	protected ServerBrowserMenuNew							m_Menu;
	protected ServerBrowserEntry							m_SelectedServer;
	
	protected TabType										m_TabType;
	protected ESortType										m_SortType;
	protected ESortOrder									m_SortOrder;
	
	protected SelectedPanel									m_SelectedPanel;
	protected bool											m_Initialized;
	protected bool											m_BegunLoading;
	protected bool											m_Loading;
	protected int											m_TotalServers; // UNUSED
	protected int											m_TotalLoadedServers;
	protected int											m_LastLoadedPage;
	protected int											m_TotalPages;
	protected bool											m_LoadingFinished;
	protected int											m_CurrentPageNum;
	
	protected string										m_CurrentSelectedServer;
	protected int											m_CurrentLoadedPage;
	protected ref GetServersInput							m_CurrentFilterInput;
	
	protected Widget										m_ApplyFilter;
	protected Widget										m_RefreshList;
	protected Widget										m_ResetFilters;
	protected Widget										m_FiltersChanged;
	protected Widget										m_HostSort;
	protected Widget										m_TimeSort;
	protected Widget										m_PopulationSort;
	protected Widget										m_SlotsSort;
	protected Widget										m_PingSort;
	protected Widget										m_FilterSearchText;
	protected Widget										m_FilterSearchTextBox;
	protected TextWidget									m_LoadingText;
	protected ButtonWidget									m_BtnPagePrev;
	protected ButtonWidget									m_BtnPageNext;
	
	protected ref map<ESortType, ref array<ref GetServersResultRow>> m_EntriesSorted;
	protected ref map<ESortType, ESortOrder>				m_SortInverted;
	protected ref set<string> 								m_OnlineFavServers;

	void ServerBrowserTab( Widget parent, ServerBrowserMenuNew menu, TabType type )
	{
		Construct(parent, menu, type);
		m_OnlineFavServers = new set<string>();
		GetGame().GetContentDLCService().m_OnChange.Insert(OnDLCChange);
	}
	
	protected void Construct( Widget parent, ServerBrowserMenuNew menu, TabType type )
	{
		m_SortInverted = new map<ESortType, ESortOrder>;
		m_EntriesSorted = new map<ESortType, ref array<ref GetServersResultRow>>;
		m_EntryMods = new map<string, ref array<string>>;
		m_LoadingText			= TextWidget.Cast( m_Root.FindAnyWidget( "loading_servers_info" ) );
	}
	
	void ~ServerBrowserTab()
	{
		if ( m_Filters )
			m_Filters.SaveFilters();
		
		if (m_Root)
			delete m_Root;
		
		if (GetGame().GetContentDLCService())
			GetGame().GetContentDLCService().m_OnChange.Remove(OnDLCChange);
	}

	ServerBrowserMenuNew GetRootMenu()
	{
		return m_Menu;
	}
	
	bool GetIsServerLoadingFinished()
	{
		return m_LoadingFinished;
	}
	
	override bool OnClick( Widget w, int x, int y, int button )
	{
		
	}
	
	void OnDLCChange(EDLCId dlcId)
	{
		switch (dlcId)
		{
			case EDLCId.DLC_BLISS:
			{
				array<ServerBrowserEntry> serverEntries = m_EntryWidgets.GetValueArray();
				foreach (ServerBrowserEntry entry : serverEntries)
				{
					entry.RefreshDLCIcon();
				}
				break;
			}
			
			default:
				break;
		}
	}
	
	void ScrollToEntry( ServerBrowserEntry entry )
	{
		if ( entry )
		{
			float x, y;
			float x_s, y_s;
			float x_l, y_l;
			
			Widget root			= entry.GetRoot();
			Widget first_child	= root.GetParent().GetChildren();
			Widget last_child	= first_child;
			while ( last_child )
			{
				if ( last_child.GetSibling() )
					last_child = last_child.GetSibling();
				else
					break;
			}
			
			root.GetParent().Update();
			root.Update();
			
			m_ServerListScroller.GetScreenPos( x, y );
			m_ServerListScroller.GetScreenSize( x_s, y_s );
			
			float bottom_pos = y + y_s;
			
			root.GetScreenPos( x_l, y_l );
			root.GetScreenSize( x_s, y_s );
			
			if ( root == first_child )
			{
				m_ServerListScroller.VScrollToPos01( 0 );
			}
			else if ( root == last_child )
			{
				m_ServerListScroller.VScrollToPos01( 1 );
			}
			else if ( y_l + y_s >= bottom_pos )
			{
				m_ServerListScroller.VScrollToPos( m_ServerListScroller.GetVScrollPos() + y_s );
			}
			else if ( y_l <= y )
			{
				m_ServerListScroller.VScrollToPos( m_ServerListScroller.GetVScrollPos() - y_s );
			}
		}
	}
	
	void Focus()
	{
		if ( m_EntryWidgets.Contains( m_CurrentSelectedServer ) )
		{
			m_EntryWidgets.Get( m_CurrentSelectedServer ).Focus();
			ScrollToEntry( m_EntryWidgets.Get( m_CurrentSelectedServer ) );
		}
	}
	
	void OnFilterFocusLost( Widget w )
	{
		m_SelectedPanel = SelectedPanel.FILTERS;
		m_Menu.FilterFocus( false );
	}
	
	void OnFilterFocus( Widget w )
	{
		m_SelectedPanel = SelectedPanel.FILTERS;
		m_Menu.FilterFocus( true );
	}
	
	void OnFilterChanged()
	{
		
	}
	
	void ServerListFocus( bool focus, bool favorite )
	{
		m_SelectedPanel = SelectedPanel.BROWSER;
		
		if (!m_Menu)
			return;
		
		m_Menu.ServerListFocus( focus, favorite );
	}
	
	override bool OnFocus( Widget w, int x, int y )
	{
		if ( IsFocusable( w ) )
		{
			if ( w == m_FilterSearchTextBox )
			{
				ColorHighlight( m_FilterSearchText );
				return false;
			}
			else
			{
				ColorHighlight( w );
			}
			return true;
		}
		return false;
	}
	
	override bool OnFocusLost( Widget w, int x, int y )
	{
		if ( IsFocusable( w ) )
		{
			if ( w == m_FilterSearchTextBox )
			{
				ColorNormal( m_FilterSearchText );
				return true;
			}
			else
			{
				ColorNormal( w );
			}
			return true;
		}
		return false;
	}
	
	override bool OnMouseEnter( Widget w, int x, int y )
	{		
		if ( IsFocusable( w ) )
		{
			ColorHighlight( w );
			if ( w == m_FilterSearchText )
			{
				SetFocus( m_FilterSearchTextBox );
				return true;
			}
			return true;
		}
		return false;
	}
	
	override bool OnMouseLeave( Widget w, Widget enterW, int x, int y )
	{		
		if ( IsFocusable( w ) )
		{
			if ( enterW == m_FilterSearchText || enterW == m_FilterSearchTextBox )
			{
			}
			else
			{
				ColorNormal( w );
			}
			return true;
		}
		return false;
	}
	
	bool IsFocusable( Widget w )
	{
		if ( w )
		{
			return ( w == m_ApplyFilter || w == m_RefreshList || w == m_ResetFilters || w == m_FilterSearchText || w == m_FilterSearchTextBox );
		}
		return false;
	}
	
	void SetPanelFocus()
	{
		
	}
	
	void PressA()
	{
		
	}
	
	void PressX()
	{
		if ( m_Menu.GetServersLoadingTab() == TabType.NONE )
			RefreshList();
	}
	
	void PressY();
	void PressSholderLeft();
	void PressSholderRight();
	void Left();
	void LeftHold();
	void LeftRelease();
	void Right();
	void RightHold();
	void RightRelease();
	void Up();
	void Down();
	
	void OnLoadServerModsAsync(string server_id, array<string> mods)
	{
		m_EntryMods.Set( server_id, mods );
	}
	
	void GetNextEntry()
	{
		Widget focused = GetFocus();
		if ( !focused )
			return;
		Widget sibling = focused.GetSibling();
		if ( !sibling )
			return;
		
		if ( focused.GetName() == "server_browser_list_entry_root" )
		{
			if ( sibling )
				SetFocus( focused.GetSibling() );
			else
				SetFocus( focused.GetParent().GetSibling().GetChildren() );
		}
	}
	
	void GetPrevEntry()
	{
		Widget focused = GetFocus();
		if ( focused && focused.GetName() == "server_browser_list_entry_root" )
		{
			Widget sibling = focused.GetParent().GetChildren();
			if ( focused == sibling )
				return;
			
			while ( sibling )
			{
				if ( sibling && sibling.GetSibling() == focused )
				{
					SetFocus( sibling );
				}
				else
				{
					sibling = sibling.GetSibling();
				}
			}
		}
	}
	
	void GetNextFilter()
	{
	
	}
	
	void GetPrevFilter()
	{
	
	}
	
	void SetCurrentPage(int page_num)
	{
		m_CurrentPageNum = page_num;
	}
	
	int GetCurrentPage()
	{
		return m_CurrentPageNum;
	}
	
	bool IsNotInitialized()
	{
		return !m_Initialized || !m_LoadingFinished;
	}
	
	void ResetFilters()
	{
		m_Filters.ResetFilters();
	}
	
	void ApplyFilters()
	{
	
	}
	
	void AddFavoritesToFilter( ref GetServersInput input )
	{
		m_Menu.AddFavoritesToFilter( input );
	}
	
	void RefreshList()
	{
		m_Menu.SetServersLoadingTab( m_TabType );
		
		m_LoadingFinished = false;
		m_Initialized = true;
		m_BegunLoading = false;
		m_LastLoadedPage = 0;
		m_TotalPages = -1;
		m_TotalServers = 0;
		m_TotalLoadedServers = 0;
		m_CurrentLoadedPage = 0;
		
		m_EntryWidgets.Clear();
		
		#ifndef PLATFORM_WINDOWS // XBOX OR PS
			m_CurrentFilterInput = m_Filters.GetFilterOptionsConsoles();
			m_CurrentFilterInput.m_Page = GetCurrentPage();
			m_CurrentFilterInput.m_SortBy = GetSortOption();
			m_CurrentFilterInput.m_SortOrder = m_SortOrder;
		#else // PLATFORM_WINDOWS
			m_CurrentFilterInput = m_Filters.GetFilterOptionsPC();
			#ifdef PLATFORM_CONSOLE // PC client with -XBOX flag
				m_CurrentFilterInput.m_Page = GetCurrentPage();
			#else	
				m_CurrentFilterInput.m_Page = 0;
			#endif
		#endif

		m_Loading = true;
		switch ( m_TabType )
		{
			case TabType.OFFICIAL:
			{
				m_CurrentFilterInput.SetOfficialFilter( true );
				OnlineServices.LoadServers( m_CurrentFilterInput );
				break;
			}
			case TabType.COMMUNITY:
			{
				m_CurrentFilterInput.SetOfficialFilter( false );
				OnlineServices.LoadServers( m_CurrentFilterInput );
				break;
			}
			case TabType.LAN:
			{
				m_CurrentFilterInput.SetLAN();
				OnlineServices.LoadServers( m_CurrentFilterInput );
				break;
			}
		}
	}
	
	void GetNextPage()
	{
		if ( m_TotalPages > 0 && m_LastLoadedPage < m_TotalPages )
		{
			m_CurrentFilterInput.m_Page = m_LastLoadedPage + 1;
			OnlineServices.LoadServers( m_CurrentFilterInput );
		}
	}
	
	void SelectServer( ServerBrowserEntry server )
	{
#ifdef PLATFORM_CONSOLE
		ScrollToEntry( server );
#endif
		
		m_SelectedServer = server;
		
		if (!m_Menu)
			return;
		
		m_Menu.SelectServer( server );
	}
	
	void OnLoadServersAsyncPC( ref GetServersResult result_list, EBiosError error, string response )
	{
		
	}
	
	void OnLoadServersAsyncConsole( GetServersResult result_list, EBiosError error, string response )
	{
		
	}
	
	void SetSort( ESortType type, ESortOrder order )
	{
		m_SortOrder = order;
		m_SortType	= type;
	}
	
	bool IsPingInRange( int ping, string max_ping )
	{
		int max = max_ping.Substring( 1, max_ping.Length() - 1 ).ToInt();
		
		if ( ping < max )
			return true;
		return false;
	}
	
	bool PassFilter( GetServersResultRow result )
	{			
		if ( !m_Menu || m_Menu.GetServersLoadingTab() != m_TabType )
		{
			return false;
		}
		
		if ( m_Filters.m_PingFilter.IsSet() )
		{
			if ( !IsPingInRange( result.m_Ping, m_Filters.m_PingFilter.GetStringValue() ) )
			{
				return false;
			}
		}

		if ( m_Filters.m_PreviouslyPlayedFilter.IsSet() )
		{
			bool is_visited = g_Game.IsVisited( result.m_HostIp, result.m_HostPort );
			
			if ( !is_visited && m_Filters.m_PreviouslyPlayedFilter.IsEnabled() )
			{
				return false;
			}
			
			if ( is_visited && m_Filters.m_PreviouslyPlayedFilter.IsEnabled() )
			{
				return false;
			}
		}
		
		return true;
	}
	
	// Adds extra servers to the END of the list
	protected void LoadExtraEntries(int index)
	{
		
	}
	
	void Connect( ServerBrowserEntry server )
	{
		if ( !m_Menu )
			return;
		
		if ( m_Menu.GetServersLoadingTab() != TabType.NONE )
			return;
		
		m_SelectedServer = server;
		m_Menu.Connect( server );
	}
	
	string GetSortOption()
	{
		switch ( m_SortType )
		{
			case ESortType.HOST:
			{
				return "name";
			}
			case ESortType.TIME:
			{
				return "name";
			}
			case ESortType.POPULATION:
			{
				return "currentNumberPlayers";
			}
			case ESortType.SLOTS:
			{
				return "freeSlots";
			}
			case ESortType.PING:
			{
				return "name";
			}
		}
		return "";
	}
	
	int AddSorted( GetServersResultRow entry )
	{	
		return -1;
	}
	
	void Unfavorite( string uid )
	{
		ServerBrowserEntry entry;
		if ( m_EntryWidgets.Find( uid, entry ) )
		{
			entry.SetFavorite( false );
		}
	}
	
	TabType GetTabType()
	{
		return m_TabType;
	}
	
	void ButtonEnable( Widget w )
	{
		w.ClearFlags( WidgetFlags.IGNOREPOINTER );
		ColorNormal(w);
	}
	
	void ButtonDisable( Widget w )
	{
		w.SetFlags( WidgetFlags.IGNOREPOINTER );
		ColorDisable(w);
	}
	
	//Coloring functions (Until WidgetStyles are useful)
	void ColorHighlight( Widget w )
	{
		if ( w.IsInherited( ButtonWidget ) )
		{
			ButtonWidget button = ButtonWidget.Cast( w );
			button.SetTextColor( ARGB( 255, 200, 0, 0 ) );
		}
		
		w.SetColor( ARGB( 255, 0, 0, 0) );
		
		TextWidget text1	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text" ) );
		TextWidget text2	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_label" ) );
		TextWidget text3	= TextWidget.Cast(w.FindAnyWidget( w.GetName() + "_text_1" ) );
		ImageWidget image	= ImageWidget.Cast( w.FindAnyWidget( w.GetName() + "_image" ) );
		Widget option		= Widget.Cast( w.FindAnyWidget( w.GetName() + "_option_wrapper" ) );
		Widget option_label = w.FindAnyWidget( "option_label" );
		
		if ( text1 )
		{
			text1.SetColor( ARGB( 255, 255, 0, 0 ) );
		}
		
		if ( text2 )
		{
			text2.SetColor( ARGB( 255, 255, 0, 0 ) );
		}
		
		if ( text3 )
		{
			text3.SetColor( ARGB( 255, 255, 0, 0 ) );
			w.SetAlpha(1);
		}
		
		if ( image )
		{
			image.SetColor( ARGB( 255, 200, 0, 0 ) );
		}
		
		if ( option )
		{
			option.SetColor( ARGB( 255, 255, 0, 0 ) );
		}
		
		if ( option_label )
		{
			option_label.SetColor( ARGB( 255, 255, 0, 0 ) );
		}
	}
	
	void ColorNormal( Widget w )
	{
		if ( (w.GetFlags() & WidgetFlags.IGNOREPOINTER) == WidgetFlags.IGNOREPOINTER )
		{
			return;
		}
		
		if ( w.IsInherited( ButtonWidget ) )
		{
			ButtonWidget button = ButtonWidget.Cast( w );
			button.SetTextColor( ARGB( 255, 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		= w.FindAnyWidget( w.GetName() + "_option_wrapper" );
		Widget option_label = w.FindAnyWidget( "option_label" );
		
		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 ) );
		}
		
		if ( option_label )
		{
			option_label.SetColor( ARGB( 255, 255, 255, 255 ) );
		}
	}
	
	void ColorDisable( Widget w )
	{
		#ifdef PLATFORM_WINDOWS
		SetFocus( null );
		#endif
		
		if ( w )
		{
			ButtonWidget button = ButtonWidget.Cast( w );
			if ( button )
			{
				button.SetTextColor( ColorManager.COLOR_DISABLED_TEXT );
			}
		}
	}
}