"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var mocks_exports = {};
__export(mocks_exports, {
  MockRequestMessageWithExpectation: () => MockRequestMessageWithExpectation,
  MockRequestMessageWithoutExpectation: () => MockRequestMessageWithoutExpectation,
  MockResponseMessage: () => MockResponseMessage,
  createEmptyMockDriver: () => createEmptyMockDriver,
  createTestEndpoint: () => createTestEndpoint,
  createTestNode: () => createTestNode,
  mockDriverDummyCallbackId: () => mockDriverDummyCallbackId
});
module.exports = __toCommonJS(mocks_exports);
var import_tslib = require("tslib");
var import_cc = require("@zwave-js/cc");
var import_config = require("@zwave-js/config");
var import_core = require("@zwave-js/core");
var import_serial = require("@zwave-js/serial");
var import_serialapi = require("@zwave-js/serial/serialapi");
var import_sinon = __toESM(require("sinon"), 1);
var nodeUtils = __toESM(require("../node/utils.js"), 1);
const MockRequestMessageWithExpectation_FunctionType = 250;
const MockRequestMessageWithoutExpectation_FunctionType = 251;
const MockResponseMessage_FunctionType = 255;
let MockRequestMessageWithExpectation = (() => {
  let _classDecorators = [(0, import_serial.messageTypes)(import_serial.MessageType.Request, MockRequestMessageWithExpectation_FunctionType), (0, import_serial.expectedResponse)(MockResponseMessage_FunctionType), (0, import_serial.priority)(import_core.MessagePriority.Normal)];
  let _classDescriptor;
  let _classExtraInitializers = [];
  let _classThis;
  let _classSuper = import_serial.Message;
  var MockRequestMessageWithExpectation2 = class extends _classSuper {
    static {
      __name(this, "MockRequestMessageWithExpectation");
    }
    static {
      _classThis = this;
    }
    static {
      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
      (0, import_tslib.__esDecorate)(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
      MockRequestMessageWithExpectation2 = _classThis = _classDescriptor.value;
      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
      (0, import_tslib.__runInitializers)(_classThis, _classExtraInitializers);
    }
  };
  return MockRequestMessageWithExpectation2 = _classThis;
})();
let MockRequestMessageWithoutExpectation = (() => {
  let _classDecorators = [(0, import_serial.messageTypes)(import_serial.MessageType.Request, MockRequestMessageWithoutExpectation_FunctionType), (0, import_serial.priority)(import_core.MessagePriority.Normal)];
  let _classDescriptor;
  let _classExtraInitializers = [];
  let _classThis;
  let _classSuper = import_serial.Message;
  var MockRequestMessageWithoutExpectation2 = class extends _classSuper {
    static {
      __name(this, "MockRequestMessageWithoutExpectation");
    }
    static {
      _classThis = this;
    }
    static {
      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
      (0, import_tslib.__esDecorate)(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
      MockRequestMessageWithoutExpectation2 = _classThis = _classDescriptor.value;
      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
      (0, import_tslib.__runInitializers)(_classThis, _classExtraInitializers);
    }
  };
  return MockRequestMessageWithoutExpectation2 = _classThis;
})();
let MockResponseMessage = (() => {
  let _classDecorators = [(0, import_serial.messageTypes)(import_serial.MessageType.Response, MockResponseMessage_FunctionType)];
  let _classDescriptor;
  let _classExtraInitializers = [];
  let _classThis;
  let _classSuper = import_serial.Message;
  var MockResponseMessage2 = class extends _classSuper {
    static {
      __name(this, "MockResponseMessage");
    }
    static {
      _classThis = this;
    }
    static {
      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
      (0, import_tslib.__esDecorate)(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
      MockResponseMessage2 = _classThis = _classDescriptor.value;
      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
      (0, import_tslib.__runInitializers)(_classThis, _classExtraInitializers);
    }
  };
  return MockResponseMessage2 = _classThis;
})();
const mockDriverDummyCallbackId = 254;
function createEmptyMockDriver() {
  const ret = {
    sendMessage: import_sinon.default.stub().callsFake(() => Promise.resolve()),
    sendCommand: import_sinon.default.stub(),
    getSupportedCCVersion: import_sinon.default.stub(),
    getSafeCCVersion: import_sinon.default.stub(),
    isCCSecure: import_sinon.default.stub().callsFake(() => false),
    getNextCallbackId: import_sinon.default.stub().callsFake(() => mockDriverDummyCallbackId),
    controller: {
      nodes: /* @__PURE__ */ new Map(),
      ownNodeId: 1
    },
    get nodes() {
      return ret.controller.nodes;
    },
    get ownNodeId() {
      return ret.controller.ownNodeId;
    },
    valueDB: /* @__PURE__ */ new Map(),
    getValueDB: /* @__PURE__ */ __name((nodeId) => {
      return ret.controller.nodes.get(nodeId).valueDB;
    }, "getValueDB"),
    metadataDB: /* @__PURE__ */ new Map(),
    networkCache: /* @__PURE__ */ new Map(),
    cacheGet: import_sinon.default.stub().callsFake((cacheKey, options) => {
      let _ret = ret.networkCache.get(cacheKey);
      if (_ret !== void 0 && typeof options?.reviver === "function") {
        try {
          _ret = options.reviver(_ret);
        } catch {
        }
      }
      return _ret;
    }),
    cacheSet: import_sinon.default.stub().callsFake((cacheKey, value, options) => {
      if (value !== void 0 && typeof options?.serializer === "function") {
        value = options.serializer(value);
      }
      if (value === void 0) {
        ret.networkCache.delete(cacheKey);
      } else {
        ret.networkCache.set(cacheKey, value);
      }
    }),
    options: {
      timeouts: {
        ack: 1e3,
        byte: 150,
        response: 1600,
        report: 1600,
        nonce: 5e3,
        sendDataCallback: 65e3
      },
      attempts: {
        sendData: 3,
        controller: 3
      }
    },
    driverLog: new Proxy({}, {
      get() {
        return () => {
        };
      }
    }),
    controllerLog: new Proxy({}, {
      get() {
        return () => {
        };
      }
    }),
    configManager: new import_config.ConfigManager(),
    getLogConfig: /* @__PURE__ */ __name(() => {
      return {
        enabled: false,
        level: "info"
      };
    }, "getLogConfig")
  };
  ret.sendCommand.callsFake(async (command, options) => {
    const msg = new import_serialapi.SendDataRequest({ command });
    const resp = await ret.sendMessage(msg, options);
    return resp?.command;
  });
  ret.getSupportedCCVersion.callsFake((ccId, nodeId, endpointIndex = 0) => {
    if (ret.controller?.nodes instanceof Map && ret.controller.nodes.has(nodeId)) {
      const node = ret.controller.nodes.get(nodeId);
      const ccVersion = node.getEndpoint(endpointIndex).getCCVersion(ccId);
      return ccVersion;
    }
    return 0;
  });
  ret.getSafeCCVersion.callsFake((ccId, nodeId, endpointIndex = 0) => {
    return ret.getSupportedCCVersion(ccId, nodeId, endpointIndex) || (0, import_cc.getImplementedVersion)(ccId);
  });
  return ret;
}
__name(createEmptyMockDriver, "createEmptyMockDriver");
function createTestNode(host, options) {
  const endpointCache = /* @__PURE__ */ new Map();
  const securityClasses = /* @__PURE__ */ new Map();
  const ret = {
    id: options.id,
    ...createTestEndpoint(host, {
      nodeId: options.id,
      index: 0,
      commandClasses: options.commandClasses
    }),
    isListening: options.isListening ?? true,
    isFrequentListening: options.isFrequentListening ?? false,
    get canSleep() {
      if (ret.isListening == void 0)
        return void 0;
      if (ret.isFrequentListening == void 0)
        return void 0;
      return !ret.isListening && !ret.isFrequentListening;
    },
    setEndpoint: /* @__PURE__ */ __name((endpoint) => {
      endpointCache.set(endpoint.index, createTestEndpoint(host, {
        nodeId: options.id,
        index: endpoint.index,
        commandClasses: endpoint.commandClasses
      }));
    }, "setEndpoint"),
    getEndpoint: /* @__PURE__ */ __name(((index) => {
      if (index === 0)
        return ret;
      if (!endpointCache.has(index)) {
        if (!options.endpoints?.[index]) {
          return void 0;
        }
        ret.setEndpoint({
          nodeId: options.id,
          index,
          commandClasses: options.endpoints[index].commandClasses
        });
      }
      return endpointCache.get(index);
    }), "getEndpoint"),
    getEndpointOrThrow(index) {
      const ep = ret.getEndpoint(index);
      if (!ep) {
        throw new import_core.ZWaveError(`Endpoint ${index} does not exist on Node ${ret.id}`, import_core.ZWaveErrorCodes.Controller_EndpointNotFound);
      }
      return ep;
    },
    // These are copied from Node.ts
    getHighestSecurityClass() {
      if (securityClasses.size === 0)
        return void 0;
      let missingSome = false;
      for (const secClass of import_core.securityClassOrder) {
        if (securityClasses.get(secClass) === true)
          return secClass;
        if (!securityClasses.has(secClass)) {
          missingSome = true;
        }
      }
      return missingSome ? void 0 : import_core.SecurityClass.None;
    },
    hasSecurityClass(securityClass) {
      return securityClasses.get(securityClass);
    },
    setSecurityClass(securityClass, granted) {
      securityClasses.set(securityClass, granted);
    },
    get isSecure() {
      const securityClass = ret.getHighestSecurityClass();
      if (securityClass == void 0)
        return import_core.NOT_KNOWN;
      if (securityClass === import_core.SecurityClass.None)
        return false;
      return true;
    }
  };
  endpointCache.set(0, ret);
  if (options.endpoints) {
    nodeUtils.setIndividualEndpointCount(host, ret.id, Object.keys(options.endpoints).length);
    nodeUtils.setEndpointIndizes(host, ret.id, Object.keys(options.endpoints).map((index) => parseInt(index, 10)));
    nodeUtils.setAggregatedEndpointCount(host, ret.id, 0);
    nodeUtils.setMultiChannelInterviewComplete(host, ret.id, true);
  }
  return ret;
}
__name(createTestNode, "createTestNode");
function createTestEndpoint(host, options) {
  const ret = {
    virtual: false,
    nodeId: options.nodeId,
    index: options.index,
    supportsCC: /* @__PURE__ */ __name((cc) => {
      const ccInfo = options.commandClasses?.[cc];
      if (!ccInfo)
        return false;
      return ccInfo.isSupported ?? true;
    }, "supportsCC"),
    controlsCC: /* @__PURE__ */ __name((cc) => {
      const ccInfo = options.commandClasses?.[cc];
      if (!ccInfo)
        return false;
      return ccInfo.isControlled ?? false;
    }, "controlsCC"),
    isCCSecure: /* @__PURE__ */ __name((cc) => {
      const ccInfo = options.commandClasses?.[cc];
      if (!ccInfo)
        return false;
      return ccInfo.secure ?? false;
    }, "isCCSecure"),
    getCCVersion: /* @__PURE__ */ __name((cc) => {
      const ccInfo = options.commandClasses?.[cc];
      const defaultVersion = ccInfo?.isSupported ? (0, import_cc.getImplementedVersion)(cc) : 0;
      return ccInfo?.version ?? host.getNode(options.nodeId)?.getCCVersion(cc) ?? defaultVersion;
    }, "getCCVersion")
  };
  return ret;
}
__name(createTestEndpoint, "createTestEndpoint");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  MockRequestMessageWithExpectation,
  MockRequestMessageWithoutExpectation,
  MockResponseMessage,
  createEmptyMockDriver,
  createTestEndpoint,
  createTestNode,
  mockDriverDummyCallbackId
});
//# sourceMappingURL=mocks.js.map
