"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);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  AntiFraudDataRudder: () => AntiFraudDataRudder
});
module.exports = __toCommonJS(index_exports);

// src/modules/anti-fraud/create-transaction.usecase.ts
var import_bankeiro_backend_commons = require("@bankeiro/bankeiro-backend-commons");
var import_bankeiro_backend_utils3 = require("@bankeiro/bankeiro-backend-utils");

// src/shared/mechanisms/services/antifraud.service.ts
var import_bankeiro_backend_utils2 = require("@bankeiro/bankeiro-backend-utils");
var import_axios2 = __toESM(require("axios"));

// src/shared/mechanisms/enums/antifraud.enum.ts
var AntiFraudTransactionStatusEnum = /* @__PURE__ */ (function(AntiFraudTransactionStatusEnum2) {
  AntiFraudTransactionStatusEnum2["APPROVED"] = "APPROVED";
  AntiFraudTransactionStatusEnum2["REJECTED"] = "REJECTED";
  return AntiFraudTransactionStatusEnum2;
})({});

// src/shared/mechanisms/instance/instance.ts
var import_bankeiro_backend_utils = require("@bankeiro/bankeiro-backend-utils");
var import_axios = __toESM(require("axios"));
var import_node_https = __toESM(require("https"));

// src/shared/mechanisms/instance/cache-token.instance.ts
function getFutureDate(currentDate, segundos) {
  const dataFutura = new Date(currentDate.getTime() + segundos * 1e3);
  return dataFutura;
}
__name(getFutureDate, "getFutureDate");
var GlobalToken = class GlobalToken2 {
  static {
    __name(this, "GlobalToken");
  }
  static _instance;
  token;
  tokenExpiresDate;
  constructor() {
  }
  static getInstance() {
    if (GlobalToken2._instance) {
      return GlobalToken2._instance;
    }
    GlobalToken2._instance = new GlobalToken2();
    return GlobalToken2._instance;
  }
  getCachedToken() {
    if (this.token == null || this.tokenExpiresDate == null) {
      return this.token;
    }
    const currentDate = /* @__PURE__ */ new Date();
    return this.tokenExpiresDate < currentDate ? null : this.token;
  }
  setCachedToken(token) {
    this.token = token.access_token;
    this.tokenExpiresDate = getFutureDate(/* @__PURE__ */ new Date(), token.expires_in);
  }
};
var cache_token_instance_default = GlobalToken;

// src/shared/mechanisms/instance/instance.ts
function attachLoggingInterceptors(client, channel) {
  client.interceptors.response.use((response) => {
    const logObj = {
      type: "success",
      status: response.status,
      method: response.config?.method,
      headers: response.config?.headers,
      url: response.config?.url,
      baseUrl: response.config?.baseURL,
      params: response.config?.params,
      req_body: response.config?.data,
      response: response.data
    };
    new import_bankeiro_backend_utils.BankeiroLoggerManager().log(channel, logObj);
    return response;
  }, (error) => {
    const errObj = {
      type: "error",
      status: error.response?.status,
      method: error.config?.method,
      headers: error.config?.headers ?? "Oculto pois podem existir dados sens\xEDveis",
      baseUrl: error.config?.baseURL,
      url: error.config?.url,
      params: "Oculto pois podem existir dados sens\xEDveis",
      req_body: "Oculto pois podem existir dados sens\xEDveis",
      response: error.response ? error.response.data : error.message
    };
    new import_bankeiro_backend_utils.BankeiroLoggerManager().log(channel, errObj);
    return Promise.reject(error);
  });
}
__name(attachLoggingInterceptors, "attachLoggingInterceptors");
var getAuthorizationToken = /* @__PURE__ */ __name(async (session) => {
  const globalToken = cache_token_instance_default.getInstance();
  const cached = globalToken.getCachedToken();
  if (cached) {
    return cached;
  }
  const authClient = import_axios.default.create({
    baseURL: session.tenant.antiFraud.dataRudder.baseurl,
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      "Cache-Control": "no-cache",
      "x-bankeiro-id": session?.accountId
    }
  });
  const formData = new URLSearchParams();
  formData.append("grant_type", "client_credentials");
  formData.append("client_id", session.tenant.antiFraud.dataRudder.clientId);
  formData.append("client_secret", session.tenant.antiFraud.dataRudder.clientSecret);
  attachLoggingInterceptors(authClient, "dataRudder-auth");
  const { data } = await authClient.post("/auth/login", formData.toString());
  globalToken.setCachedToken(data);
  return data.access_token;
}, "getAuthorizationToken");
var getInstance = /* @__PURE__ */ __name(async (session) => {
  const client = import_axios.default.create({
    baseURL: session.tenant.antiFraud.dataRudder.baseurl,
    headers: {
      "Content-Type": "application/json",
      "x-bankeiro-id": session?.accountId,
      Authorization: `Bearer ${await getAuthorizationToken(session)}`
    }
  });
  client.defaults.timeout = 1e4;
  attachLoggingInterceptors(client, "dataRudder-integration");
  return client;
}, "getInstance");

// src/shared/mechanisms/services/antifraud.service.ts
var AntiFraudService = class {
  static {
    __name(this, "AntiFraudService");
  }
  logger;
  constructor() {
    this.logger = new import_bankeiro_backend_utils2.BankeiroLoggerManager();
  }
  // @eslint-ignore
  async execute(params) {
    const session = params.session;
    const correlationId = this.getCorrelationId(session);
    this.logger.log("AntiFraudService > execute > received params", {
      correlationId,
      params: this.maskParams(params)
    });
    try {
      const client = await getInstance(session);
      const { data } = await client.post("/fraud/transactions", {
        params
      });
      this.logger.log("AntiFraudService > execute > antifraud result received", {
        correlationId,
        antifraudId: data.id,
        status: data.action,
        score: data.score
      });
      return {
        id: data.id,
        score: data.score,
        status: AntiFraudTransactionStatusEnum[data.action]
      };
    } catch (error) {
      this.logError("AntiFraudService::execute", error, correlationId);
      throw error;
    }
  }
  async feedback(params) {
    const session = params.session;
    const correlationId = this.getCorrelationId(session);
    this.logger.log("AntiFraudService > feedback > received params", {
      correlationId,
      params: {
        transactionId: params.transactionId
      }
    });
    try {
      const client = await getInstance(session);
      delete params.session;
      params.decisor_agent = "MANUAL";
      const { data } = await client.put(`/fraud/transactions/${params.transactionId}`, params);
      this.logger.log("AntiFraudService > feedback > antifraud feedback updated", {
        correlationId,
        transactionId: data.id
      });
      return data;
    } catch (error) {
      this.logError("AntiFraudService::feedback", error, correlationId);
      throw error;
    }
  }
  async get(transactionId, session) {
    const correlationId = this.getCorrelationId(session);
    this.logger.log("AntiFraudService > get > request received", {
      correlationId,
      transactionId
    });
    try {
      const client = await getInstance(session);
      const { data } = await client.get("/fraud/transactions/analysis", {
        params: {
          transactionId
        }
      });
      this.logger.log("AntiFraudService > get > antifraud result loaded", {
        correlationId,
        antifraudId: data.id,
        status: data.action,
        score: data.score
      });
      return {
        id: data.id,
        score: data.score,
        status: AntiFraudTransactionStatusEnum[data.action]
      };
    } catch (error) {
      this.logError("AntiFraudService::get", error, correlationId);
      throw error;
    }
  }
  maskParams(params) {
    if (!params) return params;
    return {
      ...params,
      device: params.device ? {
        vendor: params.device.manufacturer,
        category: params.device.model
      } : void 0,
      transaction: params.transaction ? {
        amount: params.transaction.amount
      } : void 0
    };
  }
  logError(context, error, correlationId) {
    if (import_axios2.default.isAxiosError(error)) {
      const axiosErr = error;
      this.logger.log(`${context}: Axios error`, {
        correlationId,
        message: axiosErr.message,
        status: axiosErr.response?.status,
        url: axiosErr.config?.url,
        method: axiosErr.config?.method
      });
    } else {
      this.logger.log(`${context}: Unexpected error`, {
        correlationId,
        error
      });
    }
  }
  getCorrelationId(session) {
    return session?.requestId ?? `antifraud-${Date.now()}`;
  }
};

// src/modules/anti-fraud/create-transaction.usecase.ts
var CreateTransactionFraudUseCase = class {
  static {
    __name(this, "CreateTransactionFraudUseCase");
  }
  logger;
  constructor() {
    this.logger = new import_bankeiro_backend_utils3.BankeiroLoggerManager();
  }
  async execute(params) {
    this.logger.log("CreateTransactionFraudUseCase > execute > params", params);
    const service = new AntiFraudService();
    const payload = {
      device: params.device,
      session: params.session,
      transaction: {
        id: params.transaction.id,
        amount_total: params.transaction.amount,
        datetime_request: params.transaction.transactionAt,
        datetime_schedule: params.transaction.transactionScheduleAt,
        channel: this._getChannel(params.transaction.type),
        type: this._getType(params.transaction.flow)
      }
    };
    return service.execute(payload);
  }
  _getChannel(type) {
    if (type === import_bankeiro_backend_commons.TransactionType.PIX) return "pix";
    if (type === import_bankeiro_backend_commons.TransactionType.TED) return "ted";
    if (type === import_bankeiro_backend_commons.TransactionType.BILLET) return "billet";
    return null;
  }
  _getType(flow) {
    if (flow === import_bankeiro_backend_commons.TransactionFlow.CASH_IN) return "cash-in";
    if (flow === import_bankeiro_backend_commons.TransactionFlow.CASH_OUT) return "cash-out";
    return null;
  }
};

// src/modules/anti-fraud/update-transaction.usecase.ts
var import_bankeiro_backend_utils4 = require("@bankeiro/bankeiro-backend-utils");
var UpdateTransactionFraudUseCase = class {
  static {
    __name(this, "UpdateTransactionFraudUseCase");
  }
  logger;
  constructor() {
    this.logger = new import_bankeiro_backend_utils4.BankeiroLoggerManager();
  }
  async execute(params) {
    this.logger.log("UpdateTransactionFraudUseCase > execute > params", params);
    const service = new AntiFraudService();
    return service.feedback(params);
  }
};

// src/modules/index.ts
var AntiFraud = class {
  static {
    __name(this, "AntiFraud");
  }
  analyze(params) {
    return new CreateTransactionFraudUseCase().execute(params);
  }
  feedback(params) {
    return new UpdateTransactionFraudUseCase().execute(params);
  }
};

// src/index.ts
var AntiFraudDataRudder = class AntiFraudDataRudder2 {
  static {
    __name(this, "AntiFraudDataRudder");
  }
  constructor() {
  }
  static antiFraud = new AntiFraud();
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AntiFraudDataRudder
});