const int ITEMS_IN_ROW = 8;

class Attachments
{
	protected Container							m_Parent;
	protected EntityAI							m_Entity;
	protected ref AttachmentsWrapper			m_AttachmentsContainer;
	protected ref array<string>					m_AttachmentSlotNames;
	protected ref array<string>					m_AttachmentSlotDisplayable;
	protected ref map<int, SlotsIcon>			m_AttachmentSlots;
	protected ref array<int>					m_AttachmentIDOrdered;
	
	protected int m_RowIndex;
	protected int m_AttachmentSlotID = -1;

	void Attachments( Container parent, EntityAI entity )
	{
		m_Parent					= parent;
		m_Entity					= entity;
		m_AttachmentSlots			= new map<int, SlotsIcon>;
		m_AttachmentIDOrdered		= new array<int>;
		m_AttachmentSlotNames		= GetItemSlots( entity );
		m_AttachmentSlotDisplayable	= new array<string>;
		m_Entity.GetOnItemAttached().Insert( AttachmentAdded );
		m_Entity.GetOnItemDetached().Insert( AttachmentRemoved );
		m_Entity.GetOnAttachmentSetLock().Insert( OnAttachmentReservationSet );
		m_Entity.GetOnAttachmentReleaseLock().Insert( OnAttachmentReservationRelease );
		
	}
	
	void ~Attachments()
	{
		if( m_Entity )
		{
			m_Entity.GetOnItemAttached().Remove( AttachmentAdded );
			m_Entity.GetOnItemDetached().Remove( AttachmentRemoved );
			m_Entity.GetOnAttachmentSetLock().Remove( OnAttachmentReservationSet );
			m_Entity.GetOnAttachmentReleaseLock().Remove( OnAttachmentReservationRelease );
		}
		
		delete m_AttachmentsContainer;
	}
	
	AttachmentsWrapper GetWrapper()
	{
		return m_AttachmentsContainer;
	}
	
	bool IsEmpty()
	{
		return m_AttachmentsContainer.IsEmpty();
	}
	
	bool IsItemActive()
	{
		ItemBase item = ItemBase.Cast( GetFocusedItem() );
		if( !item )
		{
			return false;
		}
		return !IsEmpty() && ( !QuantityConversions.HasItemQuantity( item )  || ( QuantityConversions.HasItemQuantity( item ) && !item.CanBeSplit() ) );
	}
	
	bool IsItemWithQuantityActive()
	{
		ItemBase item = ItemBase.Cast( GetFocusedItem() );
		if( !item )
		{
			return false;
		}
		return !IsEmpty() && QuantityConversions.HasItemQuantity( item ) && item.CanBeSplit();
	}

	void UnfocusAll()
	{
		m_AttachmentsContainer.UnfocusAll();
	}

	void SetDefaultFocus( bool while_micromanagment_mode = false )
	{
		m_AttachmentsContainer.SetDefaultFocus(while_micromanagment_mode);
	}
	
	void SetLastActive()
	{
		m_AttachmentsContainer.SetLastActive();
	}
	
	void SetActive( bool active )
	{
		m_AttachmentsContainer.SetActive(active);
	}
	
	void SelFirstActive()
	{
		m_AttachmentsContainer.SetFirstActive();
	}
	
	SlotsIcon GetFocusedSlotsIcon()
	{
		return m_AttachmentsContainer.GetFocusedSlotsIcon();
	}
	
	EntityAI GetFocusedItem()
	{
		return m_AttachmentsContainer.GetFocusedItem();
	}
	
	int GetFocusedSlot()
	{
		SlotsIcon icon = m_AttachmentsContainer.GetFocusedSlotsIcon();
		if (icon)
			return icon.GetSlotID();
		return -1;
	}
	
	bool SelectItem()
	{
		ItemBase item = ItemBase.Cast( GetFocusedItem() );
		SlotsIcon icon = GetFocusedSlotsIcon();
		
		if (icon && !icon.IsOutOfReach())
		{
			if (item && item.CanPutIntoHands(null))
			{
				ItemManager.GetInstance().SetSelectedItemEx(item, null, icon);
			}
			else
			{
				ItemManager.GetInstance().SetSelectedItemEx(null, null, icon);
			}
			return true;
		}
		return false;
	}
	
	bool Select()
	{
		SlotsIcon selected_slot = ItemManager.GetInstance().GetSelectedIcon();
		EntityAI selected_item = ItemManager.GetInstance().GetSelectedItem();
		SlotsIcon focused_slot = GetFocusedSlotsIcon();
		EntityAI focused_item = GetFocusedItem();
		Man player = GetGame().GetPlayer();
		
		if( focused_slot.IsReserved() || focused_item != selected_item && !(selected_slot && selected_slot.IsOutOfReach() ) )
		{
			if( selected_item )
			{
				if( selected_item.GetInventory().CanRemoveEntity() )
				{
					if( m_Entity.GetInventory().CanAddAttachmentEx( selected_item, focused_slot.GetSlotID() ) )
					{
						player.PredictiveTakeEntityToTargetAttachmentEx( m_Entity, selected_item, focused_slot.GetSlotID() );
						ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
						return true;
					
					}
					else if( m_Entity.GetInventory().CanAddAttachment( selected_item ) )
					{
						player.PredictiveTakeEntityToTargetAttachment(m_Entity, selected_item);
						ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
						return true;
					}
				}
			}
			else
			{
				if ( focused_item && !focused_slot.IsOutOfReach() )
				{
					EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
					InventoryLocation il = new InventoryLocation;
					focused_item.GetInventory().GetCurrentInventoryLocation( il );
					bool reachable = AttachmentsOutOfReach.IsAttachmentReachable( m_Entity, "", il.GetSlot() );
					if( reachable && focused_item.GetInventory().CanRemoveEntity() )
					{
						if( item_in_hands && item_in_hands.GetInventory().CanRemoveEntity() )
						{
							if( GameInventory.CanSwapEntitiesEx( item_in_hands, focused_item ) )
							{
								player.PredictiveSwapEntities( item_in_hands, focused_item );
								return true;
							}
						}
						else
						{
							if( player.GetHumanInventory().CanAddEntityInHands( focused_item ) )
							{
								player.PredictiveTakeEntityToHands( focused_item );
								return true;
							}
						}
					}
				}
			}	
		}
		return false;
	}
	
	int GetRecipeCount( bool recipe_anywhere, EntityAI entity1, EntityAI entity2 )
	{
		PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast( GetPlugin( PluginRecipesManager ) );
		return plugin_recipes_manager.GetValidRecipes( ItemBase.Cast( entity1 ), ItemBase.Cast( entity2 ), null, PlayerBase.Cast( GetGame().GetPlayer() ) );
	}
	
	bool CanCombine()
	{
		ItemBase ent = ItemBase.Cast( GetFocusedItem() );
		ItemBase item_in_hands = ItemBase.Cast(	GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
		
		return ( ItemManager.GetCombinationFlags( item_in_hands, ent ) != 0 );
	}
	
	bool CanCombineAmmo()
	{
		PlayerBase m_player = PlayerBase.Cast( GetGame().GetPlayer() );
		ItemBase ent = ItemBase.Cast(  GetFocusedItem() );
		ItemBase item_in_hands = ItemBase.Cast(	GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
		ActionManagerClient amc;
		Class.CastTo(amc, m_player.GetActionManager());

		return ( amc.CanPerformActionFromInventory( item_in_hands, ent ) );
	}
	
	bool CanEquip()
	{
		EntityAI entity = ItemBase.Cast( GetFocusedItem() );
		InventoryLocation il = new InventoryLocation;
		if( !entity || entity.IsInherited( Magazine ) )
		{
			return false;
		}
		return GetGame().GetPlayer().GetInventory().FindFreeLocationFor( entity, FindInventoryLocationType.ATTACHMENT, il );
	}
	
	bool Combine()
	{
		ItemBase ent = ItemBase.Cast( GetFocusedItem() );
		ItemBase item_in_hands = ItemBase.Cast(	GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
		Icon hands_icon = ItemManager.GetInstance().GetHandsPreview().GetIcon();
		
		if ( item_in_hands && ent && hands_icon )
		{
			return hands_icon.CombineItems( item_in_hands, ent );
		}
		
		return false;
	}
	
	bool SplitItem()
	{
		ItemBase entity = ItemBase.Cast( GetFocusedItem() );
		if( entity && !entity.IsInherited( Magazine ) && !GetFocusedSlotsIcon().IsOutOfReach() )
		{
			if( entity.HasQuantity() )
			{
				entity.OnRightClick();
				return true;
			}
		}
		return false;
	}
	
	bool EquipItem()
	{
		ItemBase entity = ItemBase.Cast( GetFocusedItem() );
		if( entity && !entity.IsInherited( Magazine ) && !GetFocusedSlotsIcon().IsOutOfReach() )
		{
			GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.ATTACHMENT, entity );
			return true;
		}
		return false;
	}
	
	bool TransferItem()
	{
		EntityAI entity = GetFocusedItem();
		if( entity && !GetFocusedSlotsIcon().IsOutOfReach() )
		{
			GetGame().GetPlayer().PredictiveTakeEntityToInventory( FindInventoryLocationType.CARGO, entity );
			return true;
		}
		return false;
	}
	
	bool InspectItem()
	{
		EntityAI entity = GetFocusedItem();
		if( entity )
		{
			m_Parent.InspectItem( entity );
			return true;
		}
		return false;
	}
	
	bool TransferItemToVicinity()
	{
		ItemBase item = ItemBase.Cast(GetFocusedItem());
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer());
		if (item && !GetFocusedSlotsIcon().IsOutOfReach() )
		{
			if (item.GetTargetQuantityMax() < item.GetQuantity())
				item.SplitIntoStackMaxClient( null, -1 );
			else
				player.PhysicalPredictiveDropItem(item);
			return true;
		}
		return false;
	}
	
	bool IsActive()
	{
		return m_Parent.GetMainWidget().FindAnyWidget("AttachmentsWrapper").GetAlpha() > 0;
	}
	
	int GetAttachmentHeight()
	{
		return m_AttachmentsContainer.Count();
	}
	
	void UpdateInterval()
	{
		SlotsIcon icon;
		int slot_id;
		m_AttachmentSlotDisplayable.Clear();
		int i = 0;
		for (i = m_AttachmentSlotNames.Count() - 1; i >=0; --i)
		{
			slot_id = InventorySlots.GetSlotIdFromString( m_AttachmentSlotNames[i] );
			if (m_Entity.CanDisplayAttachmentSlot(slot_id))
			{
				m_AttachmentSlotDisplayable.Insert(m_AttachmentSlotNames[i]);
			}
			else
			{
				icon = m_AttachmentSlots.Get( slot_id );
				if (icon)
				{
					icon.GetMainWidget().Show( false );
					if( GetFocusedSlotsIcon() == icon )
					{
						SetDefaultFocus();
					}
					// radial icon (collabsable icon handling)
					icon.UpdateInterval();
				}
			}
			
		}
		
		if ( m_AttachmentSlotDisplayable.Count() == 0 )
		{
			if (m_Parent)
			{
				m_Parent.UpdateRadialIcon();
				//m_Parent.Close();
			}
		}
		
		for (i = 0; i < m_AttachmentSlotDisplayable.Count(); ++i)
		{
			slot_id = InventorySlots.GetSlotIdFromString( m_AttachmentSlotDisplayable[i] );
			icon = m_AttachmentSlots.Get( slot_id );
			EntityAI item = icon.GetEntity();
			icon.GetMainWidget().Show( true );
			icon.UpdateInterval();
			if ( item )
			{
				bool draggable = true;
				if(icon.IsReserved())
				{
					draggable = false;
				}
				
				if( m_Entity.GetInventory().GetSlotLock( slot_id ) && ItemManager.GetInstance().GetDraggedItem() != item )
				{
					icon.GetMountedWidget().Show( true );
					draggable = false;
				}
				else
				{
					icon.GetMountedWidget().Show( false );
				}
				
				PlayerBase p = PlayerBase.Cast( GetGame().GetPlayer() );
				bool in_hands_condition		= m_Entity.GetHierarchyRoot() && item.GetInventory().CanRemoveEntity();
				bool in_vicinity_condition	= !m_Entity.GetHierarchyRoot() && AttachmentsOutOfReach.IsAttachmentReachable( m_Entity, m_AttachmentSlotDisplayable[i] );
				if( in_hands_condition || in_vicinity_condition )
				{
					icon.GetOutOfReachWidget().Show( false );
				}
				else
				{
					icon.GetOutOfReachWidget().Show( true );
					draggable = false;
				}
				
				if( draggable )
				{
					icon.GetPanelWidget().SetFlags( WidgetFlags.DRAGGABLE );
				}
				else
				{
					icon.GetPanelWidget().ClearFlags( WidgetFlags.DRAGGABLE );
				}
			}
		}
		m_AttachmentsContainer.GetRootWidget().Update();
	}
	
	array<int> GetSlotsSorted()
	{
		return m_AttachmentIDOrdered;
	}
	
	void AttachmentAdded(EntityAI item, string slot, EntityAI parent)
	{
		int slot_id = InventorySlots.GetSlotIdFromString(slot);
		SlotsIcon icon = m_AttachmentSlots.Get(slot_id);
		if (icon)
		{
			icon.SetSlotID(slot_id);
			icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slot_id));
			if (item)
			{
				icon.Init(item);
			}
		}
	}
	
	void AttachmentRemoved(EntityAI item, string slot, EntityAI parent)
	{
		int slot_id = InventorySlots.GetSlotIdFromString(slot);
		SlotsIcon icon = m_AttachmentSlots.Get(slot_id);
		if (icon)
		{
			icon.Clear();
		}
	}
	
	void OnAttachmentReservationSet( EntityAI item, int slot_id )
	{
		SlotsIcon icon = m_AttachmentSlots.Get( slot_id );
		
		if (item)
		{
			icon.Init( item, true );
		}
	}
	
	void OnAttachmentReservationRelease( EntityAI item, int slot_id )
	{
		SlotsIcon icon = m_AttachmentSlots.Get( slot_id );
		icon.Clear();
	}
	

	void InitAttachmentGrid( int att_row_index )
	{
		SlotsIcon icon;
		int i;
		m_RowIndex = att_row_index;

		int number_of_rows = Math.Ceil( m_AttachmentSlotNames.Count() / ITEMS_IN_ROW );
		string name = m_Entity.GetDisplayName();
		name.ToUpper();
		
		m_AttachmentsContainer = new AttachmentsWrapper( m_Parent );
		m_AttachmentsContainer.SetParent( this );
		m_AttachmentsContainer.SetFalseAttachmentsHeaderText(name);
		m_AttachmentsContainer.GetRootWidget().SetSort( att_row_index );
		m_Parent.Insert( m_AttachmentsContainer, att_row_index );
		
		for ( i = 0; i < number_of_rows; i++ )
		{
			SlotsContainer ic = new SlotsContainer( m_AttachmentsContainer, m_Entity );
			m_AttachmentsContainer.Insert( ic );

			if( i == ( number_of_rows - 1 ) && m_AttachmentSlotNames.Count() % ITEMS_IN_ROW != 0 )
			{
				ic.SetColumnCount( m_AttachmentSlotNames.Count() % ITEMS_IN_ROW );
			}
			else
			{
				ic.SetColumnCount( ITEMS_IN_ROW );
			}

			for( int j = 0; j < ITEMS_IN_ROW; j++ )
			{
				icon = ic.GetSlotIcon( j );
				WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader2" );
				WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetGhostSlot(), m_Parent, "OnDropReceivedFromHeader2" );
				WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetPanelWidget(), m_Parent, "OnDropReceivedFromHeader2" );

				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetMainWidget(), m_Parent, "DraggingOverHeader" );
				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetGhostSlot(), m_Parent, "DraggingOverHeader" );
				WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetPanelWidget(), m_Parent, "DraggingOverHeader" );
				
				WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( icon.GetMainWidget(), m_Parent, "MouseClick2" );
				WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( icon.GetGhostSlot(), m_Parent, "MouseClick2" );
				WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( icon.GetPanelWidget(), m_Parent, "MouseClick2" );
			}
		}

		for ( i = 0; i < m_AttachmentSlotNames.Count(); i++ )
		{
			icon = SlotsContainer.Cast( m_AttachmentsContainer.Get( ( i / ITEMS_IN_ROW ) ) ).GetSlotIcon( i % ITEMS_IN_ROW );
			WidgetEventHandler.GetInstance().RegisterOnDoubleClick( icon.GetPanelWidget(), m_Parent, "DoubleClick" );
			
			string path = "CfgSlots" + " Slot_" + m_AttachmentSlotNames[i];

			//Show different magazine icon for firearms and pistols
			if ( m_AttachmentSlotNames[i] == "magazine" )
			{
				if ( !m_Entity.IsInherited( Pistol_Base ) )
					path = "CfgSlots" + " Slot_" + "magazine2";
			}
			
			string icon_name = ""; //icon_name must be in format "set:<setname> image:<imagename>"
			if( GetGame().ConfigGetText( path + " ghostIcon", icon_name ) && icon_name != "" )
				icon.GetGhostSlot().LoadImageFile( 0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY,icon_name) );
			int slot_id = InventorySlots.GetSlotIdFromString( m_AttachmentSlotNames[i] );
			m_AttachmentSlots.Insert( slot_id, icon );
			m_AttachmentIDOrdered.Insert(slot_id);
			
			icon.SetSlotID(slot_id);
			icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slot_id));
			
			EntityAI item = m_Entity.GetInventory().FindAttachment( slot_id );
			if( item )
				AttachmentAdded( item, m_AttachmentSlotNames[i], m_Entity );
			else
				icon.Clear();
			
			if (m_Entity.CanDisplayAttachmentSlot(slot_id))
			{
				icon.GetMainWidget().Show( true );
			}
			else
			{
				icon.GetMainWidget().Show( false );
			}
		}
		
		if( m_AttachmentSlotNames.Count() > 0 )
		{
			int row_index = number_of_rows - 1;
			SlotsContainer row_last = SlotsContainer.Cast( m_AttachmentsContainer.Get( row_index ) );
			if( row_last )
			{
				for( int k = ((m_AttachmentSlotNames.Count() - 1) % ITEMS_IN_ROW) + 1; k < ITEMS_IN_ROW; k++ )
				{
					row_last.GetSlotIcon( k ).GetMainWidget().Show( false );
				}
				row_last.GetRootWidget().Update();
				row_last.GetRootWidget().GetParent().Update();
			}
		}
		
		m_AttachmentsContainer.RecomputeOpenedContainers();
	}

	array<string> GetItemSlots( EntityAI e )
	{
		TStringArray searching_in = new TStringArray;
		searching_in.Insert( CFG_VEHICLESPATH );
		searching_in.Insert( CFG_WEAPONSPATH );
		searching_in.Insert( CFG_MAGAZINESPATH );

		array<string> attachments_slots	= new array<string>;
		int i = 0;
		for ( int s = 0; s < searching_in.Count(); ++s )
		{
			string cfg_name = searching_in.Get( s );
			string path = cfg_name + " " + e.GetType();

			if ( GetGame().ConfigIsExisting( path ) )
			{
				GetGame().ConfigGetTextArray( path + " attachments", attachments_slots );
				if ( e.IsWeapon() && (!e.ConfigIsExisting("DisplayMagazine") || e.ConfigGetBool("DisplayMagazine")) )
				{
					attachments_slots.Insert( "magazine" );
				}

				return attachments_slots;
			}
		}
		if ( e.IsWeapon() && (!e.ConfigIsExisting("DisplayMagazine") || e.ConfigGetBool("DisplayMagazine")) )
		{
			attachments_slots.Insert( "magazine" );
		}

		return attachments_slots;
	}
	
	void ShowFalseAttachmentsHeader(bool show)
	{
		m_AttachmentsContainer.ShowFalseAttachmentsHeader(show);
	}
	
	void SetFalseAttachmentsHeaderText(string text)
	{
		m_AttachmentsContainer.SetFalseAttachmentsHeaderText(text);
	}
	
	TextWidget GetFalseHeaderTextWidget()
	{
		return m_AttachmentsContainer.GetFalseHeaderTextWidget();
	}
	
	void SetAttachmentSlotID(int slotID)
	{
		m_AttachmentSlotID = slotID;
	}
	
	int GetAttachmentSlotID()
	{
		return m_AttachmentSlotID;
	}
}