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

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

import { NetworkNodeSystem } from "../../systems/network/NetworkNodeSystem.sol";
import { CreateAndAnchorParams } from "../../systems/deployable/types.sol";
import { FuelParams } from "../../systems/fuel/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 NetworkNodeSystemType is bytes32;

// equivalent to WorldResourceIdLib.encode({ typeId: RESOURCE_SYSTEM, namespace: "evefrontier", name: "NetworkNodeSyste" }))
NetworkNodeSystemType constant networkNodeSystem = NetworkNodeSystemType.wrap(
  0x737965766566726f6e746965720000004e6574776f726b4e6f64655379737465
);

struct CallWrapper {
  ResourceId systemId;
  address from;
}

struct RootCallWrapper {
  ResourceId systemId;
  address from;
}

/**
 * @title NetworkNodeSystemLib
 * @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 NetworkNodeSystemLib {
  error NetworkNodeSystemLib_CallingFromRootSystem();
  error NetworkNode_AlreadyExists(uint256 smartObjectId);
  error NetworkNode_DoesNotExist(uint256 smartObjectId);
  error NetworkNode_InsufficientEnergy(uint256 networkNodeId, uint256 required, uint256 available);
  error NetworkNode_NotOnline(uint256 networkNodeId);
  error NetworkNode_AssemblyNotConnected(uint256 networkNodeId, uint256 assemblyId);
  error NetworkNode_AssemblyAlreadyConnected(uint256 networkNodeId, uint256 assemblyId);
  error NetworkNode_NotConfigured(uint256 smartObjectId);
  error NetworkNode_InvalidAssemblyType(uint256 networkNodeId, uint256 assemblyId);

  function createAndAnchorNetworkNode(
    NetworkNodeSystemType self,
    CreateAndAnchorParams memory params,
    FuelParams memory fuelParams,
    uint256 maxEnergyCapacity,
    uint256 currentProduction
  ) internal {
    return
      CallWrapper(self.toResourceId(), address(0)).createAndAnchorNetworkNode(
        params,
        fuelParams,
        maxEnergyCapacity,
        currentProduction
      );
  }

  function connectAssembly(NetworkNodeSystemType self, uint256 networkNodeId, uint256 assemblyId) internal {
    return CallWrapper(self.toResourceId(), address(0)).connectAssembly(networkNodeId, assemblyId);
  }

  function connectAssemblies(NetworkNodeSystemType self, uint256 networkNodeId, uint256[] memory assemblyIds) internal {
    return CallWrapper(self.toResourceId(), address(0)).connectAssemblies(networkNodeId, assemblyIds);
  }

  function disconnectAssembly(NetworkNodeSystemType self, uint256 networkNodeId, uint256 assemblyId) internal {
    return CallWrapper(self.toResourceId(), address(0)).disconnectAssembly(networkNodeId, assemblyId);
  }

  function disconnectNetworkNode(NetworkNodeSystemType self, uint256 networkNodeId) internal {
    return CallWrapper(self.toResourceId(), address(0)).disconnectNetworkNode(networkNodeId);
  }

  function reserveAssemblyEnergy(NetworkNodeSystemType self, uint256 networkNodeId, uint256 assemblyId) internal {
    return CallWrapper(self.toResourceId(), address(0)).reserveAssemblyEnergy(networkNodeId, assemblyId);
  }

  function reserveNetworkNodeEnergy(NetworkNodeSystemType self, uint256 networkNodeId) internal {
    return CallWrapper(self.toResourceId(), address(0)).reserveNetworkNodeEnergy(networkNodeId);
  }

  function releaseAssemblyEnergy(NetworkNodeSystemType self, uint256 networkNodeId, uint256 assemblyId) internal {
    return CallWrapper(self.toResourceId(), address(0)).releaseAssemblyEnergy(networkNodeId, assemblyId);
  }

  function releaseNetworkNodeEnergy(NetworkNodeSystemType self, uint256 networkNodeId) internal {
    return CallWrapper(self.toResourceId(), address(0)).releaseNetworkNodeEnergy(networkNodeId);
  }

  function updateEnergyHistory(NetworkNodeSystemType self, uint256 networkNodeId) internal {
    return CallWrapper(self.toResourceId(), address(0)).updateEnergyHistory(networkNodeId);
  }

  function getNetworkNodeClassId(NetworkNodeSystemType self) internal view returns (uint256) {
    return CallWrapper(self.toResourceId(), address(0)).getNetworkNodeClassId();
  }

  function createAndAnchorNetworkNode(
    CallWrapper memory self,
    CreateAndAnchorParams memory params,
    FuelParams memory fuelParams,
    uint256 maxEnergyCapacity,
    uint256 currentProduction
  ) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _createAndAnchorNetworkNode_CreateAndAnchorParams_FuelParams_uint256_uint256.createAndAnchorNetworkNode,
      (params, fuelParams, maxEnergyCapacity, currentProduction)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function connectAssembly(CallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _connectAssembly_uint256_uint256.connectAssembly,
      (networkNodeId, assemblyId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function connectAssemblies(CallWrapper memory self, uint256 networkNodeId, uint256[] memory assemblyIds) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _connectAssemblies_uint256_uint256Array.connectAssemblies,
      (networkNodeId, assemblyIds)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function disconnectAssembly(CallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _disconnectAssembly_uint256_uint256.disconnectAssembly,
      (networkNodeId, assemblyId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

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

    bytes memory systemCall = abi.encodeCall(_disconnectNetworkNode_uint256.disconnectNetworkNode, (networkNodeId));
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function reserveAssemblyEnergy(CallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _reserveAssemblyEnergy_uint256_uint256.reserveAssemblyEnergy,
      (networkNodeId, assemblyId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

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

    bytes memory systemCall = abi.encodeCall(
      _reserveNetworkNodeEnergy_uint256.reserveNetworkNodeEnergy,
      (networkNodeId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function releaseAssemblyEnergy(CallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(
      _releaseAssemblyEnergy_uint256_uint256.releaseAssemblyEnergy,
      (networkNodeId, assemblyId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

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

    bytes memory systemCall = abi.encodeCall(
      _releaseNetworkNodeEnergy_uint256.releaseNetworkNodeEnergy,
      (networkNodeId)
    );
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

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

    bytes memory systemCall = abi.encodeCall(_updateEnergyHistory_uint256.updateEnergyHistory, (networkNodeId));
    self.from == address(0)
      ? _world().call(self.systemId, systemCall)
      : _world().callFrom(self.from, self.systemId, systemCall);
  }

  function getNetworkNodeClassId(CallWrapper memory self) internal view returns (uint256) {
    // if the contract calling this function is a root system, it should use `callAsRoot`
    if (address(_world()) == address(this)) revert NetworkNodeSystemLib_CallingFromRootSystem();

    bytes memory systemCall = abi.encodeCall(_getNetworkNodeClassId.getNetworkNodeClassId, ());
    bytes memory worldCall = self.from == address(0)
      ? abi.encodeCall(IWorldCall.call, (self.systemId, systemCall))
      : abi.encodeCall(IWorldCall.callFrom, (self.from, self.systemId, systemCall));
    (bool success, bytes memory returnData) = address(_world()).staticcall(worldCall);
    if (!success) revertWithBytes(returnData);

    bytes memory result = abi.decode(returnData, (bytes));
    return abi.decode(result, (uint256));
  }

  function createAndAnchorNetworkNode(
    RootCallWrapper memory self,
    CreateAndAnchorParams memory params,
    FuelParams memory fuelParams,
    uint256 maxEnergyCapacity,
    uint256 currentProduction
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _createAndAnchorNetworkNode_CreateAndAnchorParams_FuelParams_uint256_uint256.createAndAnchorNetworkNode,
      (params, fuelParams, maxEnergyCapacity, currentProduction)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function connectAssembly(RootCallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    bytes memory systemCall = abi.encodeCall(
      _connectAssembly_uint256_uint256.connectAssembly,
      (networkNodeId, assemblyId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function connectAssemblies(
    RootCallWrapper memory self,
    uint256 networkNodeId,
    uint256[] memory assemblyIds
  ) internal {
    bytes memory systemCall = abi.encodeCall(
      _connectAssemblies_uint256_uint256Array.connectAssemblies,
      (networkNodeId, assemblyIds)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function disconnectAssembly(RootCallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    bytes memory systemCall = abi.encodeCall(
      _disconnectAssembly_uint256_uint256.disconnectAssembly,
      (networkNodeId, assemblyId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function disconnectNetworkNode(RootCallWrapper memory self, uint256 networkNodeId) internal {
    bytes memory systemCall = abi.encodeCall(_disconnectNetworkNode_uint256.disconnectNetworkNode, (networkNodeId));
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function reserveAssemblyEnergy(RootCallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    bytes memory systemCall = abi.encodeCall(
      _reserveAssemblyEnergy_uint256_uint256.reserveAssemblyEnergy,
      (networkNodeId, assemblyId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function reserveNetworkNodeEnergy(RootCallWrapper memory self, uint256 networkNodeId) internal {
    bytes memory systemCall = abi.encodeCall(
      _reserveNetworkNodeEnergy_uint256.reserveNetworkNodeEnergy,
      (networkNodeId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function releaseAssemblyEnergy(RootCallWrapper memory self, uint256 networkNodeId, uint256 assemblyId) internal {
    bytes memory systemCall = abi.encodeCall(
      _releaseAssemblyEnergy_uint256_uint256.releaseAssemblyEnergy,
      (networkNodeId, assemblyId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function releaseNetworkNodeEnergy(RootCallWrapper memory self, uint256 networkNodeId) internal {
    bytes memory systemCall = abi.encodeCall(
      _releaseNetworkNodeEnergy_uint256.releaseNetworkNodeEnergy,
      (networkNodeId)
    );
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function updateEnergyHistory(RootCallWrapper memory self, uint256 networkNodeId) internal {
    bytes memory systemCall = abi.encodeCall(_updateEnergyHistory_uint256.updateEnergyHistory, (networkNodeId));
    SystemCall.callWithHooksOrRevert(self.from, self.systemId, systemCall, msg.value);
  }

  function getNetworkNodeClassId(RootCallWrapper memory self) internal view returns (uint256) {
    bytes memory systemCall = abi.encodeCall(_getNetworkNodeClassId.getNetworkNodeClassId, ());

    bytes memory result = SystemCall.staticcallOrRevert(self.from, self.systemId, systemCall);
    return abi.decode(result, (uint256));
  }

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

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

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

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

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

  function getAddress(NetworkNodeSystemType 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 _createAndAnchorNetworkNode_CreateAndAnchorParams_FuelParams_uint256_uint256 {
  function createAndAnchorNetworkNode(
    CreateAndAnchorParams memory params,
    FuelParams memory fuelParams,
    uint256 maxEnergyCapacity,
    uint256 currentProduction
  ) external;
}

interface _connectAssembly_uint256_uint256 {
  function connectAssembly(uint256 networkNodeId, uint256 assemblyId) external;
}

interface _connectAssemblies_uint256_uint256Array {
  function connectAssemblies(uint256 networkNodeId, uint256[] memory assemblyIds) external;
}

interface _disconnectAssembly_uint256_uint256 {
  function disconnectAssembly(uint256 networkNodeId, uint256 assemblyId) external;
}

interface _disconnectNetworkNode_uint256 {
  function disconnectNetworkNode(uint256 networkNodeId) external;
}

interface _reserveAssemblyEnergy_uint256_uint256 {
  function reserveAssemblyEnergy(uint256 networkNodeId, uint256 assemblyId) external;
}

interface _reserveNetworkNodeEnergy_uint256 {
  function reserveNetworkNodeEnergy(uint256 networkNodeId) external;
}

interface _releaseAssemblyEnergy_uint256_uint256 {
  function releaseAssemblyEnergy(uint256 networkNodeId, uint256 assemblyId) external;
}

interface _releaseNetworkNodeEnergy_uint256 {
  function releaseNetworkNodeEnergy(uint256 networkNodeId) external;
}

interface _updateEnergyHistory_uint256 {
  function updateEnergyHistory(uint256 networkNodeId) external;
}

interface _getNetworkNodeClassId {
  function getNetworkNodeClassId() external;
}

using NetworkNodeSystemLib for NetworkNodeSystemType global;
using NetworkNodeSystemLib for CallWrapper global;
using NetworkNodeSystemLib for RootCallWrapper global;