import {
  marketPolicy,
  aonPolicy,
  gttLimitPolicy,
  OrderSide,
  fetchServerTime,
  fetchSystemStatus,
  subscribeOrderUpdates,
  subscribeFills,
  // order submission
  proveAndBuildOrder,
  buildOrder,
  buildCancel,
  nodeValidInputProver,
  placeOrder,
  TradingClient,
  DarknyxApiError,
  deriveOrderId,
} from "@darknyx/sdk";
import { createVerifiedTransport } from "@darknyx/sdk/transport-node";

// Abridged: build `verifierDependencies` with the DCAP verifier used by the
// reference daemon. Obtain the compose and signer-set pins independently from
// the reviewed release and finalized VaultConfig.
const transport = await createVerifiedTransport({
  baseUrl: GATEWAY,
  deps: verifierDependencies,
  expectedComposeHash,
  expectedSignerSetSha256,
  createWebSocket,
});

class DarknyxClient {
  private token: string | null = null;

  constructor(
    private gateway: string,
    private fetchImpl: typeof fetch,
  ) {
    this.gateway = gateway.replace(/\/$/, "");
  }

  // ── Auth ──────────────────────────────────────────────────────────────
  async login(apiKey: string, apiSecret: string, passphrase: string) {
    const r = await this.fetchImpl(`${this.gateway}/auth/token`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ api_key: apiKey, api_secret: apiSecret, passphrase }),
    });
    if (!r.ok) throw new Error(`auth ${r.status}: ${await r.text()}`);
    const body = await r.json();
    this.token = body.access_token;
    return body; // { access_token, token_type, expires_in, account_id }
  }

  private auth() {
    if (!this.token) throw new Error("call login() first");
    return { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" };
  }

  // ── Reference data + health ──────────────────────────────────────────
  getInstruments() {
    return this.fetchImpl(`${this.gateway}/instruments`).then((r) => r.json());
  }
  systemStatus() {
    return fetchSystemStatus(this.gateway, { fetchImpl: this.fetchImpl });
  }
  serverTime() {
    return fetchServerTime(this.gateway, { fetchImpl: this.fetchImpl });
  }

  // ── Orders ───────────────────────────────────────────────────────────
  // `order` is a fully-built, signed wire body, produced by the SDK's
  // order-builder from your keys + a spendable note (it fills the note
  // commitment, VALID_INPUT proof, viewing key, session, and signature).
  placeOrder(order: object) {
    return this.fetchImpl(`${this.gateway}/orders`, {
      method: "POST",
      headers: this.auth(),
      body: JSON.stringify(order),
    }).then((r) => r.json());
  }

  cancelOrder(orderId: string, cancel: object) {
    return this.fetchImpl(`${this.gateway}/orders/${orderId}`, {
      method: "DELETE",
      headers: this.auth(),
      body: JSON.stringify(cancel),
    }).then((r) => r.json());
  }

  modifyOrder(orderId: string, modify: object) {
    return this.fetchImpl(`${this.gateway}/orders/${orderId}`, {
      method: "PUT",
      headers: this.auth(),
      body: JSON.stringify(modify),
    }).then((r) => r.json());
  }

  getOrder(orderId: string) {
    return this.fetchImpl(`${this.gateway}/orders/${orderId}`, { headers: this.auth() }).then((r) => r.json());
  }

  settlementStatus(batchId: number) {
    return this.fetchImpl(`${this.gateway}/settlement/status/${batchId}`, { headers: this.auth() }).then((r) => r.json());
  }
}

// A resting bid, good for the next 10 minutes (GTT).
const { slot, unix_ms } = await client.serverTime();
const gttPolicy = gttLimitPolicy({
  priceLimit: 150_000_000n,
  serverSlot: slot,
  serverUnixMs: unix_ms,
  expiryUnixMs: Date.now() + 10 * 60 * 1000,
});

// A market bid: IOC capped at the worst price you'll pay.
const market = marketPolicy({ side: OrderSide.Bid, priceCap: 155_000_000n });

// An all-or-none resting bid.
const aon = aonPolicy({ amount: 10_000_000n, priceLimit: 150_000_000n });

// `proveAndBuildOrder` does the whole flow: fetch the note's inclusion witness
// from /tree/inclusion, generate the VALID_INPUT proof, then assemble + sign the
// wire body (note commitment, proof, viewing key, session, trading signature). The
// prover is pluggable: `nodeValidInputProver` runs the compiled circuit via
// snarkjs in Node.
const order = await proveAndBuildOrder({
  baseUrl: GATEWAY,
  token: client["token"]!,
  fetchImpl: transport.fetch,
  prover: nodeValidInputProver({ wasmPath, zkeyPath }),
  tokenMint,
  masterSeed,
  spendingKey,
  ownerCommitment,
  tradingKey: trading.publicKey,
  sign: (digest) => nacl.sign.detached(digest, trading.secretKey),
  note,                         // { commitment, innerHash, amount }
  symbol: "SOL-USDC",
  side: OrderSide.Bid,
  policy: gttPolicy,
  amount: 10_000_000n,
  orderId: deriveOrderId(masterSeed, 0),
  sessionId: Uint8Array.from(Buffer.from(info.boot_session_id, "hex")),
});

// Submit over REST...
const res = await placeOrder(
  { baseUrl: GATEWAY, token: client["token"]!, fetchImpl: transport.fetch },
  order,
);
console.log("placed", res.order_id, res.status);

// Per-account order lifecycle: reservation, confirmed fills, failure, cancel, expiry.
const orders = subscribeOrderUpdates({
  gatewayWsUrl: WSS,
  token: client["token"]!,
  webSocketFactory: transport.webSocketFactory,
  onUpdate: (u) => {
    if (u.kind === "partially_filled") console.log("partial", u.filled_quantity, "resting", u.new_amount);
    if (u.kind === "fully_filled") console.log("filled", u.order_id);
  },
  onResync: () => console.warn("orders stream lagged, reconcile via GET /orders/:id"),
});

// Per-account fills: verified change-note memos (the SDK checks each memo's
// consumed-input derivation + commitment binding before handing it to you).
const fills = subscribeFills({
  gatewayWsUrl: WSS,
  token: client["token"]!,
  webSocketFactory: transport.webSocketFactory,
  masterSeed,
  ownerCommitment,
  store: noteStore,
  onFill: (rec) => console.log("change note stored", rec.commitment),
  onResync: () => console.warn("fills stream lagged, backfill then reopen"),
});

const trader = new TradingClient({
  gatewayWsUrl: WSS,
  token: client["token"]!,
  webSocketFactory: transport.webSocketFactory,
  cancelOnDisconnect: true,
});
await trader.connect();

try {
  const res = await trader.place(order);          // resolves with the acceptance
  console.log("accepted", res.order_id);
} catch (e) {
  if (e instanceof DarknyxApiError) console.error(e.code, e.message); // numeric code
}

// Cancel + modify use the same socket; build the bodies with buildCancel / buildOrder.
const cancel = await buildCancel({
  orderId,
  tradingKey: trading.publicKey,
  cancelNonce: 1n,
  sessionId: Uint8Array.from(Buffer.from(info.boot_session_id, "hex")),
  sign,
});
await trader.cancel(hex(orderId), cancel);

const client = new DarknyxClient(GATEWAY, transport.fetch);
await client.login(API_KEY, API_SECRET, PASSPHRASE);

const status = await client.systemStatus();
const markets = await client.getInstruments();
const market = markets.find((m) => m.symbol === "SOL-USDC");
if (!status.settle_enabled || !market?.trading_enabled) {
  throw new Error("SOL-USDC is not ready, back off");
}
console.log(markets.map((m) => m.symbol));

// build + place an order (see above), then watch its lifecycle on the streams.