// SPDX-License-Identifier: MIT
pragma solidity >=0.8.24;

/* Autogenerated file. Do not edit manually. */

import { InventorySystem } from "../../systems/inventory/InventorySystem.sol";
import { CreateInventoryItemParams, InventoryItemParams } from "../../systems/inventory/types.sol";
import { revertWithBytes } from "@latticexyz/world/src/revertWithBytes.sol";
import { IWorldCall } from "@latticexyz/world/src/IWorldKernel.sol";
import { SystemCall } from "@latticexyz/world/src/SystemCall.sol";
import { Systems } from "@latticexyz/world/src/codegen/tables/Systems.sol";
import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";

type InventorySystemType is bytes32;

// equivalent to WorldResourceIdLib.encode({ typeId: RESOURCE_SYSTEM, namespace: "evefrontier", name: "InventorySystem" }))
InventorySystemType constant inventorySystem = InventorySystemType.wrap(
  0x737965766566726f6e74696572000000496e76656e746f727953797374656d00
);

struct CallWrapper {
  ResourceId systemId;
  address from;
}

struct RootCallWrapper {
  ResourceId systemId;
  address from;
}

/**
 * @title InventorySystemLib
 * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
 * @dev This library is automatically generated from the corresponding system contract. Do not edit manually.
 */
library InventorySystemLib {
  error InventorySystemLib_CallingFromRootSystem();
  error Inventory_InvalidCapacity(string message);
  error Inventory_InsufficientCapacity(string message, uint256 maxCapacity, uint256 usedCapacity);
  error Inventory_InvalidTenantId(uint256 itemObjectId, bytes32 tenantId);
  error Inventory_InvalidItemObjectId(uint256 itemObjectId);
  error Inventory_InvalidItemDepositQuantity(uint256 itemObjectId, uint256 quantity);
  error Inventory_NonExistentEntityRecord(string message, uint256 smartObjectId);

  function setCapacity(InventorySystemType self, uint256 smartObjectId, uint256 capacity) internal {
    return CallWrapper(self.toResourceId(), address(0)).setCapacity(smartObjectId, capacity);
  }

  function setEphemeralCapacity(InventorySystemType self, uint256 smartObjectId, uint256 ephemeralCapacity) internal {
    return CallWrapper(self.toResourceId(), address(0)).setEphemeralCapacity(smartObjectId, ephemeralCapacity);
  }

  function createAndDepositInventory(
    InventorySystemType self,
    uint256 smartObjectId,
    CreateInventoryItemParams[] memory items
  ) internal {
    return CallWrapper(self.toResourceId(), address(0)).createAndDepositInventory(smartObjectId, items);
  }

  function depositInventory(
    InventorySystemType self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    return CallWrapper(self.toResourceId(), address(0)).depositInventory(smartObjectId, items);
  }

  function withdrawInventory(
    InventorySystemType self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    return CallWrapper(self.toResourceId(), address(0)).withdrawInventory(smartObjectId, items);
  }

  function setCapacity(CallWrapper memory self, uint256 smartObjectId, uint256 capacity) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert InventorySystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(_setCapacity_uint256_uint256.setCapacity, (smartObjectId, capacity));
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function setEphemeralCapacity(CallWrapper memory self, uint256 smartObjectId, uint256 ephemeralCapacity) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert InventorySystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _setEphemeralCapacity_uint256_uint256.setEphemeralCapacity,
      (smartObjectId, ephemeralCapacity)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function createAndDepositInventory(
    CallWrapper memory self,
    uint256 smartObjectId,
    CreateInventoryItemParams[] memory items
  ) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert InventorySystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _createAndDepositInventory_uint256_CreateInventoryItemParamsArray.createAndDepositInventory,
      (smartObjectId, items)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function depositInventory(
    CallWrapper memory self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert InventorySystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _depositInventory_uint256_InventoryItemParamsArray.depositInventory,
      (smartObjectId, items)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function withdrawInventory(
    CallWrapper memory self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert InventorySystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _withdrawInventory_uint256_InventoryItemParamsArray.withdrawInventory,
      (smartObjectId, items)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function setCapacity(RootCallWrapper memory self, uint256 smartObjectId, uint256 capacity) internal {
    bytes memory systemCall = abi.encodeCall(_setCapacity_uint256_uint256.setCapacity, (smartObjectId, capacity));
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function setEphemeralCapacity(
    RootCallWrapper memory self,
    uint256 smartObjectId,
    uint256 ephemeralCapacity
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _setEphemeralCapacity_uint256_uint256.setEphemeralCapacity,
      (smartObjectId, ephemeralCapacity)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function createAndDepositInventory(
    RootCallWrapper memory self,
    uint256 smartObjectId,
    CreateInventoryItemParams[] memory items
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _createAndDepositInventory_uint256_CreateInventoryItemParamsArray.createAndDepositInventory,
      (smartObjectId, items)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function depositInventory(
    RootCallWrapper memory self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _depositInventory_uint256_InventoryItemParamsArray.depositInventory,
      (smartObjectId, items)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function withdrawInventory(
    RootCallWrapper memory self,
    uint256 smartObjectId,
    InventoryItemParams[] memory items
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _withdrawInventory_uint256_InventoryItemParamsArray.withdrawInventory,
      (smartObjectId, items)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function callFrom(InventorySystemType self, address from) internal pure returns (CallWrapper memory) {
    return CallWrapper(self.toResourceId(), from);
  }

  function callAsRoot(InventorySystemType self) internal view returns (RootCallWrapper memory) {
    return RootCallWrapper(self.toResourceId(), msg.sender);
  }

  function callAsRootFrom(InventorySystemType self, address from) internal pure returns (RootCallWrapper memory) {
    return RootCallWrapper(self.toResourceId(), from);
  }

  function toResourceId(InventorySystemType self) internal pure returns (ResourceId) {
    return ResourceId.wrap(InventorySystemType.unwrap(self));
  }

  function fromResourceId(ResourceId resourceId) internal pure returns (InventorySystemType) {
    return InventorySystemType.wrap(resourceId.unwrap());
  }

  function getAddress(InventorySystemType self) internal view returns (address) {
    return Systems.getSystem(self.toResourceId());
  }

  function _world() private view returns (IWorldCall) {
    return IWorldCall(StoreSwitch.getStoreAddress());
  }
}

/**
 * System Function Interfaces
 *
 * We generate an interface for each system function, which is then used for encoding system calls.
 * This is necessary to handle function overloading correctly (which abi.encodeCall cannot).
 *
 * Each interface is uniquely named based on the function name and parameters to prevent collisions.
 */

interface _setCapacity_uint256_uint256 {
  function setCapacity(uint256 smartObjectId, uint256 capacity) external;
}

interface _setEphemeralCapacity_uint256_uint256 {
  function setEphemeralCapacity(uint256 smartObjectId, uint256 ephemeralCapacity) external;
}

interface _createAndDepositInventory_uint256_CreateInventoryItemParamsArray {
  function createAndDepositInventory(uint256 smartObjectId, CreateInventoryItemParams[] memory items) external;
}

interface _depositInventory_uint256_InventoryItemParamsArray {
  function depositInventory(uint256 smartObjectId, InventoryItemParams[] memory items) external;
}

interface _withdrawInventory_uint256_InventoryItemParamsArray {
  function withdrawInventory(uint256 smartObjectId, InventoryItemParams[] memory items) external;
}

using InventorySystemLib for InventorySystemType global;
using InventorySystemLib for CallWrapper global;
using InventorySystemLib for RootCallWrapper global;