class ContainerWithCargo extends ClosableContainer
{
	protected ref CargoContainer	m_CargoGrid;
	protected int m_CargoIndex = -1;

	void ContainerWithCargo( Container parent, int sort = -1 )
	{
		m_LockCargo = false;
		m_Parent = parent;

		m_CargoGrid = new CargoContainer( this );
		Insert( m_CargoGrid );
		
		m_CargoGrid.GetRootWidget().SetSort( 1 );
		
		WidgetEventHandler.GetInstance().RegisterOnDraggingOver( m_MainWidget,  this, "DraggingOverGrid" );
		RecomputeOpenedContainers();
	}

	override bool IsDisplayable()
	{
		if (m_Entity)
			return m_Entity.CanDisplayCargo();
		return false;
	}
	
	override bool IsEmpty()
	{
		return m_CargoGrid.IsEmpty();
	}
	
	override bool IsItemActive()
	{
		return m_CargoGrid.IsItemActive();
	}
	
	override bool CanCombine()
	{
		return m_CargoGrid.CanCombine();
	}
	
	override bool CanCombineAmmo()
	{
		return m_CargoGrid.CanCombineAmmo();
	}
	
	override bool IsItemWithQuantityActive()
	{
		return m_CargoGrid.IsItemWithQuantityActive();
	}
	
	void LockCargo(bool value)
	{
		if( value != m_LockCargo )
		{
			if( value )
			{
				m_LockCargo = true;
				OnHide();
			}
			else
			{
				m_LockCargo = false;
				SetOpenState(!m_Closed);
			}
		}	
	}
	
	override void Open()
	{
		if( !m_LockCargo )
		{
			ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), true );
			m_Closed = false;
			SetOpenForSlotIcon(true);
			OnShow();
			m_Parent.m_Parent.Refresh();
		}
		
		if ( m_SlotIcon )
		{
			m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
		}
	}
	
	override void Close()
	{
		if( !m_LockCargo )
		{
			ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), false );
			m_Closed = true;
			SetOpenForSlotIcon(false);
			OnHide();
			m_Parent.m_Parent.Refresh();
		}
		
		if ( m_SlotIcon )
		{
			m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
		}
	}
	
	override bool IsOpened()
	{
		return !m_Closed && !m_LockCargo;
	}
	
	override void UpdateInterval()
	{
		if ( m_Entity )
		{
			if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo()  )
			{
				LockCargo(true);
				if ( m_CargoGrid.IsVisible() )
				{
					RecomputeOpenedContainers();
				}
			}
			else
			{
				LockCargo(false);
				if ( !m_CargoGrid.IsVisible() )
				{
					RecomputeOpenedContainers();
				}
			}
		
			super.UpdateInterval();
			m_CargoGrid.UpdateInterval();
			
			bool hide = m_LockCargo || ItemManager.GetInstance().GetDraggedItem() == m_Entity;
			if (!hide)
			{
				SetOpenForSlotIcon(IsOpened());
			}
			
			if ( m_SlotIcon )
			{
				m_SlotIcon.GetRadialIconPanel().Show( !hide );
			}
		}
	}
	
	override bool IsFirstContainerFocused()
	{
		return m_CargoGrid.IsFirstContainerFocused();
	}
	
	override bool IsLastContainerFocused()
	{
		return m_CargoGrid.IsLastContainerFocused();
	}

	override void SetDefaultFocus( bool while_micromanagment_mode = false )
	{
		m_CargoGrid.SetDefaultFocus( while_micromanagment_mode );
	}
	
	override void UnfocusAll()
	{
		m_CargoGrid.Unfocus();
	}
	
	override bool SplitItem()
	{
		return m_CargoGrid.SplitItem();
	}
	
	override bool EquipItem()
	{
		return m_CargoGrid.EquipItem();
	}
	
	override bool TransferItem()
	{
		return m_CargoGrid.TransferItem();
	}
	
	override bool TransferItemToVicinity()
	{
		return m_CargoGrid.TransferItemToVicinity();
	}
	
	override bool InspectItem()
	{
		return m_CargoGrid.InspectItem();
	}

	void SetEntity( EntityAI entity, int cargo_index = 0, bool immedUpdate = true )
	{
		m_Entity = entity;
		m_CargoIndex = cargo_index;

		SetOpenState( true );

		m_CargoGrid.SetEntity( entity, immedUpdate );
		m_CargoGrid.UpdateHeaderText();
		m_ClosableHeader.SetItemPreview( entity );
		CheckHeaderDragability();
		( Container.Cast( m_Parent ) ).Insert( this, -1, false );
		
		if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() )
			LockCargo(true);
		else
			LockCargo(false);

		if ( immedUpdate )
		{
			Refresh();
			GetMainWidget().Update();
		}
	}

	EntityAI GetEntity()
	{
		return m_Entity;
	}
	
	override EntityAI GetFocusedContainerEntity()
	{
		return m_Entity;
	}

	EntityAI GetItemPreviewItem( Widget w )
	{
		ItemPreviewWidget ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
		if( !ipw )
		{
		  string name = w.GetName();
		  name.Replace( "PanelWidget", "Render" );
		  ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
		}
		if( !ipw )
		{
		  ipw = ItemPreviewWidget.Cast( w );
		}
		if( !ipw || !ipw.IsInherited( ItemPreviewWidget ) )
		{
			return null;
		}
		return ipw.GetItem();
	}

	bool DraggingOverGrid( Widget w, int x, int y, Widget reciever )
	{
		if( w == null )
		{
			return false;
		}
		
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		if( !player.CanManipulateInventory() )
		{
			return false;
		}
		
		EntityAI item = GetItemPreviewItem( w );
		
		if( !item )
		{
			return false;
		}
		
		if( !item.GetInventory().CanRemoveEntity() )
		{
			return false;
		} 

		int color, c_x, c_y;
		
		#ifdef PLATFORM_CONSOLE
		int idx = -1;
		#else
		int idx = 0;
		#endif
		
		CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
		if( cargo )
		{
			c_x = cargo.GetHeight();
			c_y = cargo.GetWidth();
		}
		
		InventoryLocation dst = new InventoryLocation;
		#ifdef PLATFORM_CONSOLE
		x = 0;
		y = cargo.GetItemCount();
		m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
		#else
		dst.SetCargoAuto(cargo, item, x, y, item.GetInventory().GetFlipCargo());
		#endif
		
		#ifdef PLATFORM_CONSOLE
		if( dst.IsValid() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
		#else
		if( m_Entity && c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
		#endif
		{
			ItemManager.GetInstance().HideDropzones();
			if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
			{
				ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
			}
			else
			{
				ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
			}
			color = ColorManager.GREEN_COLOR;
		}
		else
		{
			color = ColorManager.RED_COLOR;
			ItemManager.GetInstance().ShowSourceDropzone( item );
		}

		if( w.FindAnyWidget("Cursor") )
		{
			w.FindAnyWidget("Cursor").SetColor( color );
		}
		else
		{
			string name = w.GetName();
			name.Replace( "PanelWidget", "Cursor" );
			if( w.FindAnyWidget( name ) )
			{
				w.FindAnyWidget( name ).SetColor( color );
			}
		}

		return true;
	}

	void DropReceived( Widget w, int x, int y )
	{
		float xx, yy;
		GetMainWidget().Update();
		GetMainWidget().GetScreenSize( xx, yy );
		if( GetMainWidget().FindAnyWidget("Background") )
		{
			GetMainWidget().FindAnyWidget("Background").Show( true );
			GetMainWidget().FindAnyWidget("Background").SetSize( xx, yy );
		}
		EntityAI item = GetItemPreviewItem( w );
		if( !item )
		{
			return;
		}
		
		#ifdef PLATFORM_CONSOLE
		if( m_CargoGrid.HasItem( item ) )
		{
			return;
		}
		#endif
		
		#ifdef PLATFORM_CONSOLE
		int idx = -1;
		#else
		int idx = 0;
		#endif
		int c_x, c_y;
		
		CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
		
		if( cargo )
		{
			c_x = cargo.GetHeight();
			c_y = cargo.GetWidth();
		}
		
		InventoryLocation dst = new InventoryLocation;
		#ifdef PLATFORM_CONSOLE
		x = 0;
		y = cargo.GetItemCount();
		m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
		#else
		dst.SetCargoAuto(cargo, item, x, y, item.GetInventory().GetFlipCargo());
		#endif
		
		InventoryLocation src = new InventoryLocation;
		item.GetInventory().GetCurrentInventoryLocation(src);

		if(src.CompareLocationOnly(dst) && src.GetFlip() == dst.GetFlip())
			return;
		
		#ifdef PLATFORM_CONSOLE
		if(dst.IsValid() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
		#else
		if( c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
		#endif
		{
			PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
			
			SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst );
			
			Icon icon = m_CargoGrid.GetIcon( item );
			
			if( icon && w && w.FindAnyWidget("Cursor") )
			{
				w.FindAnyWidget("Cursor").SetColor( ColorManager.BASE_COLOR );
				icon.Refresh();
				Refresh();
			}
		}
		
		ItemManager.GetInstance().HideDropzones();
		ItemManager.GetInstance().SetIsDragging( false );
	}
	
	void TakeIntoHands( notnull PlayerBase player, notnull EntityAI item )
	{
		ItemBase item_base = ItemBase.Cast( item );
		
		if( !item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory() )
			return;
		
		float stackable = item_base.GetTargetQuantityMax();
		
		if( stackable == 0 || stackable >= item_base.GetQuantity() )
		{
			player.PredictiveTakeEntityToHands( item );
		}
		else if( stackable != 0 && stackable < item_base.GetQuantity() )
		{
			item_base.SplitIntoStackMaxHandsClient( player );
		}
	}

	override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
	{
		DraggingOver( w, x, y, receiver );
	}

	override void DraggingOver( Widget w, int x, int y, Widget receiver )
	{
		if( !w )
			return;
		EntityAI item = GetItemPreviewItem( w );
		if( !item )
			return;
		
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		if( item.GetInventory().CanRemoveEntity() && player.CanManipulateInventory() && m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && !m_Entity.GetInventory().HasEntityInCargo( item ) )
		{
			ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
			ItemManager.GetInstance().HideDropzones();
			if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
			{
				ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
			}
			else
			{
				ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
			}
		}
		else
		{
			ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
			ItemManager.GetInstance().ShowSourceDropzone( item );
		}
	}

	override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
	{
		EntityAI item = GetItemPreviewItem( w );
		if( !item )
		{
			return;
		}

		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		InventoryLocation src = new InventoryLocation();
		if( GetEntity() && item.GetInventory().GetCurrentInventoryLocation(src))
		{
			InventoryLocation dst = new InventoryLocation();
			if (m_Entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, dst))
			{
				player.PredictiveTakeToDst(src, dst);
			}

			bool can_add = m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() );
			bool in_cargo = !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item );
			if( can_add && in_cargo )
			{
				SplitItemUtils.TakeOrSplitToInventory( player, m_Entity, item );
			}
		}
	}
	
	CargoContainer GetCargo()
	{
		return m_CargoGrid;
	}
}