#ifdef WORKBENCH
// Mechanism-only fixture: radio delivery and automatic artillery scheduling are
// explicitly bypassed. All ammunition and inventory operations remain physical.
modded class ERR_MortarSystem
{
 protected ERR_NativeMortarTransferProbe m_ERRTransferFixture;
 bool ERR_HoldForTransfer(ERR_NativeMortarTransferProbe owner)
 {
  if (!ERR_NativeMortarTransferProbe.Enabled() || m_Stopped || m_ERRTransferFixture || !owner) return false;
  m_ERRTransferFixture = owner; return true;
 }
 void ERR_ReleaseTransferHold(ERR_NativeMortarTransferProbe owner)
 {
  if (m_ERRTransferFixture == owner) m_ERRTransferFixture = null;
 }
 override void Tick(float now)
 {
  if (m_ERRTransferFixture) return;
  super.Tick(now);
 }
 ERR_MortarBattery ERR_TransferBattery()
 {
  if (m_Batteries.Count() != 1) return null;
  return m_Batteries[0];
 }
}
modded class ERR_MortarBattery
{
 ERR_MortarSupplyTransfer ERR_TransferForProbe() { return m_Transfer; }
 int ERR_TransferAttempts() { return m_AttemptedShells.Count(); }
}
modded class ERR_MortarSupplyTransfer
{
 int ERR_CallbackState() { return m_Acknowledgement; }
 IEntity ERR_TransferredShell() { return m_Shell; }
 IEntity ERR_TransferRecipient() { return m_Gunner; }
 bool ERR_RequestAccepted() { return m_Accepted; }
}
class ERR_NativeMortarMoveCallback : ScriptedInventoryOperationCallback
{
 int Result;
 protected override void OnComplete() { if (Result == 0) Result = 1; }
 protected override void OnFailed() { if (Result == 0) Result = -1; }
}
class ERR_NativeMortarShellOwner
{
 IEntity Shell;
 IEntity OriginalOwner;
}

class ERR_NativeMortarTransferProbe
{
 protected ERR_GameMode m_Mode;
 protected ERR_MortarSystem m_System;
 protected ERR_MortarBattery m_Battery;
 protected IEntity m_Gunner;
 protected BaseCompartmentSlot m_Seat;
 protected ref array<IEntity> m_Crew = {};
 protected ref array<IEntity> m_Boxes = {};
 protected ref array<BaseInventoryStorageComponent> m_Stores = {};
 protected ref array<ref ERR_NativeMortarShellOwner> m_Original = {};
 protected ref ERR_NativeMortarMoveCallback m_MoveCallback;
 protected IEntity m_MoveShell;
 protected BaseInventoryStorageComponent m_MoveDestination;
 protected float m_MoveDeadline;
 protected ref ERR_MortarSupplyTransfer m_ObservedTransfer;
 protected IEntity m_FirstShell;
 protected IEntity m_SecondShell;
 protected int m_AttemptsAtStart;
 protected int m_ShotsAtStart;
 protected int m_CallbackAtCancel;
 protected int m_CancelOrder;
 protected int m_Step;
 protected float m_Deadline;
 protected float m_StepDeadline;
 protected float m_Wait;
 protected bool m_Held;
 protected bool m_Stopped;
 protected bool m_Complete;
 static const ResourceName STORE = "{EBBC859CCD94D96D}Prefabs/Props/EmptyStorages/USSR_AmmoBox_empty.et";
 static bool Enabled()
 {
  string enabled, outcome;
  return Replication.IsServer() && System.GetCLIParam("errSmoke", enabled) && enabled == "1" && System.GetCLIParam("errSmokeOutcome", outcome) && outcome == "mortar-transfer";
 }
 void ERR_NativeMortarTransferProbe(ERR_GameMode mode)
 {
  m_Mode = mode; m_Deadline = GetGame().GetWorld().GetWorldTime() + 180000;
 }
 protected bool Check(bool condition, string detail)
 {
  if (condition) { Print("ERR SMOKE PASS: mortar transfer " + detail); return true; }
  Print("ERR SMOKE FAIL: mortar transfer " + detail, LogLevel.ERROR); Stop(); return false;
 }
 protected bool IsShell(IEntity item)
 {
  return item && item.GetPrefabData() && item.GetPrefabData().GetPrefabName() == ERR_MortarBattery.SHELL;
 }
 protected InventoryStorageManagerComponent Inventory(IEntity actor)
 {
  if (!actor) return null;
  return InventoryStorageManagerComponent.Cast(actor.FindComponent(InventoryStorageManagerComponent));
 }
 protected bool Has(IEntity actor, IEntity item)
 {
  array<IEntity> items = {}; ERR_Inventory.Items(Inventory(actor), items);
  return item && items.Contains(item);
 }
 protected IEntity CrewOwner(IEntity item)
 {
  foreach (IEntity actor : m_Crew) if (Has(actor, item)) return actor;
  return null;
 }
 protected IEntity OriginalOwner(IEntity item)
 {
  foreach (ERR_NativeMortarShellOwner entry : m_Original) if (entry.Shell == item) return entry.OriginalOwner;
  return null;
 }
 protected bool InStore(IEntity item)
 {
  foreach (BaseInventoryStorageComponent storage : m_Stores) if (storage && storage.Contains(item)) return true;
  return false;
 }
 static bool Conservation(int originals, int actual, bool allOriginal, bool singleOwner)
 {
  return originals == 27 && actual == originals && allOriginal && singleOwner;
 }
 protected bool Conserved()
 {
  array<IEntity> actual = {};
  foreach (IEntity actor : m_Crew)
  {
   array<IEntity> items = {}; ERR_Inventory.Items(Inventory(actor), items);
   foreach (IEntity item : items) if (IsShell(item) && !actual.Contains(item)) actual.Insert(item);
  }
  foreach (BaseInventoryStorageComponent storage : m_Stores)
  {
   if (!storage) return false;
   array<IEntity> items = {}; storage.GetAll(items);
   foreach (IEntity item : items) if (IsShell(item) && !actual.Contains(item)) actual.Insert(item);
  }
  bool allOriginal = true;
  bool singleOwner = true;
  foreach (ERR_NativeMortarShellOwner entry : m_Original)
  {
   if (!entry.Shell || !actual.Contains(entry.Shell)) allOriginal = false;
   int owners;
   foreach (IEntity actor : m_Crew) if (Has(actor, entry.Shell)) owners++;
   foreach (BaseInventoryStorageComponent storage : m_Stores) if (storage && storage.Contains(entry.Shell)) owners++;
   if (owners != 1) singleOwner = false;
  }
  return Conservation(m_Original.Count(), actual.Count(), allOriginal, singleOwner);
 }
 protected IEntity FirstGunnerShell()
 {
  array<IEntity> items = {}; ERR_Inventory.Items(Inventory(m_Gunner), items);
  foreach (IEntity item : items) if (IsShell(item)) return item;
  return null;
 }
 protected bool BeginMove(IEntity shell, BaseInventoryStorageComponent destination, float now)
 {
  if (!shell || !destination || m_MoveCallback) return false;
  IEntity current = CrewOwner(shell);
  // A vanilla empty box has storage but no inventory manager. The original
  // recipient manager performs its explicit pickup from the external storage.
  if (!current) current = OriginalOwner(shell);
  InventoryStorageManagerComponent manager = Inventory(current);
  if (!manager) return false;
  m_MoveShell = shell; m_MoveDestination = destination;
  m_MoveCallback = new ERR_NativeMortarMoveCallback(); m_MoveDeadline = now + 8000;
  if (!manager.TryMoveItemToStorage(shell, destination, -1, m_MoveCallback)) return false;
  return true;
 }
 protected int MoveResult(float now)
 {
  if (!m_MoveCallback) return 1;
  if (m_MoveCallback.Result < 0 || now >= m_MoveDeadline) return -1;
  if (m_MoveCallback.Result == 0 || !m_MoveShell || !m_MoveDestination || !m_MoveDestination.Contains(m_MoveShell)) return 0;
  InventoryItemComponent item = InventoryItemComponent.Cast(m_MoveShell.FindComponent(InventoryItemComponent));
  if (!item || !item.GetParentSlot() || item.GetParentSlot().GetStorage() != m_MoveDestination) return 0;
  m_MoveCallback = null; m_MoveShell = null; m_MoveDestination = null;
  return 1;
 }
 protected bool Stash(IEntity shell, float now)
 {
  foreach (BaseInventoryStorageComponent storage : m_Stores)
   if (storage && storage.GetEstimatedCountFitForItem(shell) > 0) return BeginMove(shell, storage, now);
  return false;
 }
 protected void StageOrder(float now)
 {
  ERR_HQReport report = new ERR_HQReport();
  report.Target = GetGame().GetPlayerController().GetControlledEntity();
  report.Source = m_Battery.Group;
  report.Position = m_Battery.Gun.GetOrigin() + "700 0 0";
  report.ObservedAt = now; report.DetailsObservedAt = now;
  report.TravelMode = "on foot"; report.MessageId = 900001 + m_Battery.OrderId;
  m_Battery.BeginRequest(report, now);
  m_Battery.PendingSupplyReport = report.Snapshot();
  PrintFormat("ERR MORTAR TRANSFER FIXTURE: synthetic supply order=%1; radio bypassed; scheduler held; no artillery activity authorized", m_Battery.OrderId);
 }
 protected bool NoFire()
 {
  return m_Battery && m_Battery.TotalShots == m_ShotsAtStart && !m_Battery.Activity && !m_Battery.RadioOrder && !m_Battery.Released;
 }
 void Stop()
 {
  if (m_Stopped) return;
  m_Stopped = true;
  if (m_Battery) m_Battery.Cancel("native transfer fixture stopped");
  if (m_System)
  {
   m_System.Stop(); // do not resume automatic fire while test items may be stored
   if (m_Held) m_System.ERR_ReleaseTransferHold(this);
  }
  m_Held = false;
  // Never delete a box containing borrowed shells or an outstanding operation.
  // Failure preserves it for diagnosis/normal round-owned cleanup.
  if (!m_MoveCallback)
  {
   foreach (IEntity box : m_Boxes)
   {
    if (!box) continue;
    BaseInventoryStorageComponent storage = BaseInventoryStorageComponent.Cast(box.FindComponent(BaseInventoryStorageComponent));
    array<IEntity> items = {}; if (storage) storage.GetAll(items);
    if (storage && items.IsEmpty()) ERR_Actors.DeleteSpawned(box);
   }
  }
 }
 int Tick(float now)
 {
  if (m_Complete) return 1;
  if (m_Stopped) return -1;
  if (!Enabled() || now > m_Deadline) { Check(false, "enabled server fixture and bounded 180-second deadline"); return -1; }
  if (now < m_Wait) return 0;
  if (m_MoveCallback)
  {
   int moved = MoveResult(now);
   if (moved < 0) { Check(false, "fixture inventory move completed with exact destination before deadline; borrowed shells retained"); return -1; }
   if (moved == 0) return 0;
   if (!Check(Conserved(), "all original 27 shell identities conserved after fixture move")) return -1;
  }
  if (m_Step == 0)
  {
   m_System = ERR_MortarSystem.Get();
   if (!m_System) return 0;
   m_Battery = m_System.ERR_TransferBattery();
   if (!m_Battery || !m_Battery.StartupActivated) return 0;
   if (!Check(m_Battery.Operational() && m_Battery.CountShells() == 27 && !m_Battery.Activity && !m_Battery.RadioOrder && !m_Battery.CommandOpen, "actual initialized idle battery has finite 27 shells")) return -1;
   if (!Check(m_System.ERR_HoldForTransfer(this), "opt-in mechanism fixture holds automatic mortar scheduler")) return -1;
   m_Held = true; m_AttemptsAtStart = m_Battery.ERR_TransferAttempts(); m_ShotsAtStart = m_Battery.TotalShots;
   array<AIAgent> agents = {}; m_Battery.Group.GetAgents(agents);
   foreach (AIAgent agent : agents)
   {
    if (!agent || !ERR_Actors.CanFight(agent.GetControlledEntity())) continue;
    IEntity actor = agent.GetControlledEntity(); if (m_Crew.Contains(actor)) continue;
    m_Crew.Insert(actor);
    array<IEntity> items = {}; ERR_Inventory.Items(Inventory(actor), items);
    foreach (IEntity item : items)
    {
     if (!IsShell(item)) continue;
     ERR_NativeMortarShellOwner entry = new ERR_NativeMortarShellOwner(); entry.Shell = item; entry.OriginalOwner = actor; m_Original.Insert(entry);
    }
    if (!m_Gunner && actor != m_Battery.RadioOperator) m_Gunner = actor;
   }
   if (!Check(m_Crew.Count() == 4 && m_Original.Count() == 27 && m_Gunner != null, "four real crew and original shell-owner identities captured")) return -1;
   SCR_AIVehicleUsageComponent usage = SCR_AIVehicleUsageComponent.Cast(m_Battery.Gun.FindComponent(SCR_AIVehicleUsageComponent));
   if (usage) m_Seat = usage.GetTurretCompartmentSlot();
   if (m_Seat && m_Seat.GetOccupant())
   {
    IEntity occupant = m_Seat.GetOccupant();
    if (!Check(m_Crew.Contains(occupant) && occupant != m_Battery.RadioOperator && ERR_Actors.CanFight(occupant), "existing native seat occupant is original fighting gunner")) return -1;
    m_Gunner = occupant;
   }
   else
   {
    CompartmentAccessComponent access = CompartmentAccessComponent.Cast(m_Gunner.FindComponent(CompartmentAccessComponent));
    if (!Check(m_Seat && access && access.GetInVehicle(m_Battery.Gun, m_Seat, true, -1, ECloseDoorAfterActions.INVALID, false), "native seating request selects actual original crew gunner")) return -1;
   }
   if (!Check(m_Battery.InventoryShells(Inventory(m_Gunner)) == 9, "selected actual gunner owns its original nine physical shells")) return -1;
   for (int i = 0; i < 2; i++)
   {
    IEntity box = ERR_Actors.Spawn(STORE, ERR_Actors.Ground(m_Battery.Gun.GetOrigin() + Vector(3 + i * 2, 0, 3)));
    if (!Check(box != null, "fixture-owned empty vanilla storage created")) return -1;
    m_Boxes.Insert(box); m_Mode.Own(box);
    BaseInventoryStorageComponent storage = BaseInventoryStorageComponent.Cast(box.FindComponent(BaseInventoryStorageComponent));
    if (!Check(storage != null, "real vanilla storage component available without attaching it to gunner inventory")) return -1;
    m_Stores.Insert(storage);
   }
   m_Step = 1; m_StepDeadline = now + 8000; m_Wait = now + 500; return 0;
  }
  if (!NoFire()) { Check(false, "no artillery activity, committed load or physical projectile during inventory mechanism test"); return -1; }
  if (m_Step == 1)
  {
   if (m_Seat.GetOccupant() != m_Gunner)
   {
    if (now >= m_StepDeadline) { Check(false, "actual original gunner occupies native mortar seat"); return -1; }
    return 0;
   }
   if (!Check(Conserved(), "27 original shells have exactly one observed owner each")) return -1;
   m_Step = 2;
  }
  if (m_Step == 2 || m_Step == 5)
  {
   IEntity shell = FirstGunnerShell();
   if (shell)
   {
    if (!Check(Stash(shell, now), "one existing gunner shell move to vanilla store accepted; no shell minted")) return -1;
    return 0;
   }
   if (!Check(m_Battery.InventoryShells(Inventory(m_Gunner)) == 0 && Conserved(), "actual gunner empty while all 27 original shells remain in crew or fixture storage")) return -1;
   StageOrder(now);
   ERR_MortarSupplyState started = m_Battery.SupplyState(now);
   m_ObservedTransfer = m_Battery.ERR_TransferForProbe();
   if (!Check(started == ERR_MortarSupplyState.PENDING && m_ObservedTransfer && m_ObservedTransfer.ERR_RequestAccepted() && m_ObservedTransfer.ERR_TransferRecipient() == m_Gunner && m_ObservedTransfer.CapturedOrder() == m_Battery.OrderId, "production exact-shell request accepted once with captured current order and real gunner")) return -1;
   if (m_Step == 2)
   {
    m_FirstShell = m_ObservedTransfer.ERR_TransferredShell();
    m_Step = 3;
   }
   else
   {
    m_SecondShell = m_ObservedTransfer.ERR_TransferredShell(); m_CallbackAtCancel = m_ObservedTransfer.ERR_CallbackState(); m_CancelOrder = m_Battery.OrderId;
    m_Battery.Cancel("native fixture cancels authorization immediately after accepted inventory request");
    if (!Check(m_SecondShell && m_SecondShell != m_FirstShell && !m_Battery.CommandOpen && m_Battery.SupplyState(now) == ERR_MortarSupplyState.FAILED, "canceled current order cannot report supply READY or issue another request")) return -1;
    PrintFormat("ERR MORTAR TRANSFER CANCEL: callbackBeforeCancel=%1 order=%2; accepted native move is not retracted", m_CallbackAtCancel, m_CancelOrder);
    m_Step = 6;
   }
   m_StepDeadline = now + 8000; m_Wait = now + 250; return 0;
  }
  if (m_Step == 3)
  {
   ERR_MortarSupplyState state = m_Battery.SupplyState(now);
   if (state == ERR_MortarSupplyState.FAILED || now >= m_StepDeadline) { Check(false, "production transfer completes within its bounded deadline"); return -1; }
   if (state == ERR_MortarSupplyState.PENDING) return 0;
   if (!Check(m_ObservedTransfer.ERR_CallbackState() == 1 && Has(m_Gunner, m_FirstShell) && !Has(OriginalOwner(m_FirstShell), m_FirstShell) && Conserved() && m_Battery.ERR_TransferAttempts() == m_AttemptsAtStart + 1, "successful native callback and exact donor-to-gunner ownership, one attempt, original 27 conserved")) return -1;
   if (!Check(m_Battery.SupplyState(now) == ERR_MortarSupplyState.READY && m_Battery.ERR_TransferAttempts() == m_AttemptsAtStart + 1, "repeated supply check reuses actual inventory without another move")) return -1;
   m_Battery.Cancel("native success subcase finished; no artillery activity requested");
   m_Step = 5; return 0;
  }
  if (m_Step == 6)
  {
   if (m_Battery.SupplyState(now) != ERR_MortarSupplyState.FAILED || m_Battery.OrderId != m_CancelOrder || m_Battery.ERR_TransferAttempts() != m_AttemptsAtStart + 2) { Check(false, "canceled order/generation remains failed with exactly two total move attempts"); return -1; }
   if (m_ObservedTransfer.ERR_CallbackState() == 0 || m_ObservedTransfer.Unresolved())
   {
    if (now >= m_StepDeadline) { Check(false, "accepted canceled operation reached definite native outcome; no ambiguous retry"); return -1; }
    return 0;
   }
   if (!Check(m_ObservedTransfer.ERR_CallbackState() == 1 && Has(m_Gunner, m_SecondShell) && Conserved(), "canceled accepted native move has definite physical outcome with exactly two attempts and original 27 conserved")) return -1;
   if (m_CallbackAtCancel == 0) Print("ERR SMOKE PASS: mortar transfer actual native completion observed after authorization cancellation");
   else Print("ERR MORTAR TRANSFER LIMIT: native callback completed synchronously before cancellation; late callback timing not exercised");
   m_Step = 7; return 0;
  }
  if (m_Step == 7)
  {
   // Return foreign shells first, leaving room for each original nine-round kit.
   IEntity misplaced;
   foreach (ERR_NativeMortarShellOwner entry : m_Original)
    if (Has(m_Gunner, entry.Shell) && entry.OriginalOwner != m_Gunner) { misplaced = entry.Shell; break; }
   if (!misplaced)
    foreach (ERR_NativeMortarShellOwner entry : m_Original) if (InStore(entry.Shell)) { misplaced = entry.Shell; break; }
   if (misplaced)
   {
    InventoryStorageManagerComponent recipient = Inventory(OriginalOwner(misplaced));
    BaseInventoryStorageComponent destination;
    if (recipient) destination = recipient.FindStorageForItem(misplaced, EStoragePurpose.PURPOSE_DEPOSIT);
    if (!Check(destination && BeginMove(misplaced, destination, now), "one borrowed shell return to its original crew owner accepted")) return -1;
    return 0;
   }
   foreach (ERR_NativeMortarShellOwner entry : m_Original)
    if (!Check(Has(entry.OriginalOwner, entry.Shell), "original shell identity returned to original crew inventory")) return -1;
   if (!Check(Conserved() && m_Battery.CountShells() == 27 && NoFire(), "all original ammunition restored; no minted/deleted shell or shot")) return -1;
   foreach (BaseInventoryStorageComponent storage : m_Stores)
   {
    array<IEntity> items = {}; storage.GetAll(items);
    if (!Check(items.IsEmpty(), "borrowed-ammunition fixture storage empty before deletion")) return -1;
   }
   Stop(); m_Complete = true; return 1;
  }
  return 0;
 }
}
#endif