import { startSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, addBreadcrumb, SPAN_STATUS_ERROR } from '@sentry/core';
import { ensureInstrumented } from '../../instrument.js';

const patchedStatement = /* @__PURE__ */ new WeakSet();
function instrumentD1PreparedStatementQueries(statement, query) {
  if (patchedStatement.has(statement)) {
    return statement;
  }
  statement.first = new Proxy(statement.first, {
    apply(target, thisArg, args) {
      return startSpan(createStartSpanOptions(query, "first"), async () => {
        const res = await Reflect.apply(target, thisArg, args);
        createD1Breadcrumb(query, "first");
        return res;
      });
    }
  });
  statement.run = new Proxy(statement.run, {
    apply(target, thisArg, args) {
      return startSpan(createStartSpanOptions(query, "run"), async (span) => {
        const d1Response = await Reflect.apply(target, thisArg, args);
        applyD1ReturnObjectToSpan(span, d1Response);
        createD1Breadcrumb(query, "run", d1Response);
        return d1Response;
      });
    }
  });
  statement.all = new Proxy(statement.all, {
    apply(target, thisArg, args) {
      return startSpan(createStartSpanOptions(query, "all"), async (span) => {
        const d1Result = await Reflect.apply(target, thisArg, args);
        applyD1ReturnObjectToSpan(span, d1Result);
        createD1Breadcrumb(query, "all", d1Result);
        return d1Result;
      });
    }
  });
  statement.raw = new Proxy(statement.raw, {
    apply(target, thisArg, args) {
      return startSpan(createStartSpanOptions(query, "raw"), async () => {
        const res = await Reflect.apply(target, thisArg, args);
        createD1Breadcrumb(query, "raw");
        return res;
      });
    }
  });
  patchedStatement.add(statement);
  return statement;
}
function instrumentD1PreparedStatement(statement, query) {
  statement.bind = new Proxy(statement.bind, {
    apply(target, thisArg, args) {
      return instrumentD1PreparedStatementQueries(Reflect.apply(target, thisArg, args), query);
    }
  });
  return instrumentD1PreparedStatementQueries(statement, query);
}
function applyD1ReturnObjectToSpan(span, d1Result) {
  if (!d1Result.success) {
    span.setStatus({ code: SPAN_STATUS_ERROR });
  }
  span.setAttributes(getAttributesFromD1Response(d1Result));
}
function getAttributesFromD1Response(d1Result) {
  return {
    "cloudflare.d1.duration": d1Result.meta.duration,
    "cloudflare.d1.rows_read": d1Result.meta.rows_read,
    "cloudflare.d1.rows_written": d1Result.meta.rows_written
  };
}
function createD1Breadcrumb(query, type, d1Result) {
  addBreadcrumb({
    category: "query",
    message: query,
    data: {
      ...d1Result ? getAttributesFromD1Response(d1Result) : {},
      "db.operation.name": type
    }
  });
}
function createStartSpanOptions(query, type) {
  return {
    op: "db.query",
    name: query,
    attributes: {
      "db.system.name": "cloudflare-d1",
      "db.operation.name": type,
      "db.query.text": query,
      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.db.cloudflare.d1"
    }
  };
}
function instrumentPrepare(prepare) {
  return new Proxy(prepare, {
    apply(target, thisArg, args) {
      const [query] = args;
      return instrumentD1PreparedStatement(Reflect.apply(target, thisArg, args), query);
    }
  });
}
function instrumentBatch(batch) {
  return new Proxy(batch, {
    apply(target, thisArg, args) {
      const statements = args[0];
      const queryText = statements.map((statement) => statement.statement ?? "").filter(Boolean).join("\n");
      return startSpan(
        {
          op: "db.query",
          name: "D1 batch",
          attributes: {
            "db.system.name": "cloudflare-d1",
            "db.operation.name": "batch",
            "db.query.text": queryText || void 0,
            "db.operation.batch.size": statements.length,
            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.db.cloudflare.d1"
          }
        },
        async () => {
          const res = await Reflect.apply(target, thisArg, args);
          createD1Breadcrumb("D1 batch", "batch");
          return res;
        }
      );
    }
  });
}
function instrumentD1Session(session) {
  session.prepare = instrumentPrepare(session.prepare);
  session.batch = instrumentBatch(session.batch);
  return session;
}
function _instrumentD1(db) {
  db.prepare = instrumentPrepare(db.prepare);
  db.batch = instrumentBatch(db.batch);
  db.exec = new Proxy(db.exec, {
    apply(target, thisArg, args) {
      const [query] = args;
      return startSpan(createStartSpanOptions(query, "exec"), async () => {
        const res = await Reflect.apply(target, thisArg, args);
        createD1Breadcrumb(query, "exec");
        return res;
      });
    }
  });
  if ("withSession" in db && typeof db.withSession === "function") {
    db.withSession = new Proxy(db.withSession, {
      apply(target, thisArg, args) {
        return instrumentD1Session(Reflect.apply(target, thisArg, args));
      }
    });
  }
  return db;
}
function instrumentD1(db) {
  return ensureInstrumented(db, _instrumentD1);
}
function instrumentD1WithSentry(db) {
  return instrumentD1(db);
}

export { instrumentD1, instrumentD1WithSentry };
//# sourceMappingURL=instrumentD1.js.map