import { StewardClient } from "@stwd/sdk";

const client = new StewardClient({
  baseUrl: string;        // Steward API URL (e.g., "http://localhost:3200")
  apiKey?: string;        // Tenant API key (X-Steward-Key header)
  bearerToken?: string;   // Agent JWT (Authorization: Bearer header)
  tenantId?: string;      // Optional tenant ID header
});

const agent = await client.createWallet(
  agentId: string,
  name: string,
  platformId?: string
): Promise<AgentIdentity>;

const agent = await client.createWallet("my-agent", "My Agent");
// Returns: { id, name, tenantId, walletAddresses: { evm, solana }, createdAt }

const agents = await client.listAgents(): Promise<AgentIdentity[]>;

const page = await client.listAgentsPage({ limit: 25, offset: 0 });
// { agents: AgentIdentity[], limit: 25, offset: 0 }

const agent = await client.getAgent(agentId: string): Promise<AgentIdentity>;

const result = await client.createWalletBatch(
  agents: BatchAgentSpec[],
  policies?: PolicyRule[]
): Promise<BatchCreateResult>;

const result = await client.createWalletBatch(
  [
    { id: "agent-1", name: "Agent One" },
    { id: "agent-2", name: "Agent Two" },
  ],
  [{ id: "limit", type: "spending-limit", enabled: true, config: { maxPerDay: "1000000000000000000" } }]
);
// Returns: { created: AgentIdentity[], errors: { id, error }[] }

const result = await client.signTransaction(
  agentId: string,
  tx: SignTransactionInput
): Promise<SignTransactionResult>;

interface SignTransactionInput {
  to: string;          // Destination address
  value: string;       // Wei amount
  data?: string;       // Calldata
  chainId?: number;    // Chain ID (default: server's active chain)
  broadcast?: boolean; // Broadcast after signing (default: true)
}

// Result is one of:
type SignTransactionResult =
  | { txHash: string }              // Broadcast success
  | { signedTx: string }            // Sign-only (broadcast: false)
  | { status: "pending_approval"; results: PolicyResult[] } // Queued
  | {
      code: "external_broadcast_outcome_unknown";
      txId: string;
      txHash: string;
      reconciliationRequired: true;
    }; // Reconcile txHash before retrying

const result = await client.signTransaction("my-agent", {
  to: "0xDEX_ROUTER",
  value: "50000000000000000",
  chainId: 8453,
});

if ("txHash" in result) {
  console.log("TX hash:", result.txHash);
} else if ("signedTx" in result) {
  console.log("Signed TX:", result.signedTx);
} else if (result.code === "external_broadcast_outcome_unknown") {
  console.log("Reconcile before retrying:", result.txHash);
} else {
  console.log("Needs approval:", result.results);
}

const result = await client.signTypedData(
  agentId: string,
  input: SignTypedDataInput
): Promise<{ signature: string }>;

const result = await client.signSolanaTransaction(
  agentId: string,
  input: SignSolanaTransactionInput
): Promise<SignSolanaTransactionResult>;

interface SignSolanaTransactionInput {
  transaction: string; // Base64-encoded serialized transaction
  chainId?: number;    // 101 = mainnet, 102 = devnet
  broadcast?: boolean;
}

const result = await client.signBitcoinPsbt(
  agentId: string,
  input: SignBitcoinPsbtInput
): Promise<SignBitcoinPsbtResult>;

interface SignBitcoinPsbtInput {
  walletScope: string;  // e.g. "bitcoin:testnet:p2wpkh:0:0:0"
  psbtBase64: string;   // Base64-encoded PSBT
  finalize?: boolean;   // Return raw tx metadata when fully finalizable
  referenceId?: string; // Caller-stable tracking ID for audit/history lookup
}

interface SignBitcoinPsbtResult {
  transactionId: string; // Steward transaction record ID
  signedPsbtBase64: string;
  signedInputs: number;
  walletScope: string;
  walletAddress: string;
  addressType: "p2wpkh" | "p2tr";
  network: "mainnet" | "testnet";
  finalizedTxHex?: string;
  txId?: string;
  vsize?: number;
  feeSats?: string;
}

const referenceId = "withdrawal-123";

const result = await client.signBitcoinPsbt("my-agent", {
  walletScope: "bitcoin:testnet:p2wpkh:0:0:0",
  psbtBase64,
  finalize: true,
  referenceId,
});

console.log(result.transactionId);

if (result.finalizedTxHex) {
  // Steward does not broadcast. Before retrying a downstream broadcast, check
  // result.txId with your broadcaster or indexer.
}

const result = await client.signMessage(
  agentId: string,
  message: string
): Promise<{ signature: string }>;

const agentSession = await client.initializeEncryptedAgentKeyImport(
  "my-agent",
  "evm"
);

await client.submitEncryptedAgentKeyImport("my-agent", {
  importSessionId: agentSession.importSessionId,
  ephemeralPublicKey,
  iv,
  ciphertext,
  tag,
});

const userSession = await client.initializeEncryptedUserWalletKeyImport(
  "evm",
  { walletIndex: 2 }
);

await client.submitEncryptedUserWalletKeyImport({
  importSessionId: userSession.importSessionId,
  ephemeralPublicKey,
  iv,
  ciphertext,
  tag,
  walletIndex: userSession.aad.walletIndex,
});

const balance = await client.getBalance(
  agentId: string,
  chainId?: number
): Promise<AgentBalance>;

const addresses = await client.getAddresses(
  agentId: string
): Promise<GetAddressesResult>;

const history = await client.getHistory(
  agentId: string
): Promise<StewardHistoryEntry[]>;

const result = await client.rpcPassthrough(
  agentId: string,
  input: { method: string; params?: unknown[]; chainId: number }
): Promise<RpcResponse>;

await client.approveGlobalWalletConsent({
  appId: "tenant/client",
  origin: "https://app.example",
  scopes: ["eth_accounts", "eth_sendTransaction"],
  walletIndex: 2,
});

const scan = await client.scanGlobalWalletTransaction({
  appId: "tenant/client",
  origin: "https://app.example",
  walletIndex: 2,
  params: [{ from, to, value: "0x1", chainId: "0x2105" }],
});

const confirmation = await client.confirmGlobalWalletAction({
  appId: "tenant/client",
  origin: "https://app.example",
  method: "eth_sendTransaction",
  walletIndex: 2,
  params: [{ from, to, value: "0x1", chainId: "0x2105" }],
});

await client.globalWalletRpc({
  appId: "tenant/client",
  origin: "https://app.example",
  method: "eth_sendTransaction",
  walletIndex: 2,
  confirmationId: confirmation.confirmationId,
  params: [{ from, to, value: "0x1", chainId: "0x2105" }],
});

await client.createTenantAppClient("tenant-1", {
  id: "ios-prod",
  name: "iOS Production",
  environment: "production",
  enabled: true,
  allowedBundleIds: ["com.example.app"],
  allowedRedirectUrls: ["com.example.app://auth/callback"],
});

const clients = await client.listTenantAppClients("tenant-1");

const result = await client.bulkRemediateTenantWalletPolicyViolations(
  tenantId: string,
  wallets: Array<{ userId: string; accountId: string }>
): Promise<TenantWalletPolicyBulkRemediationResponse>;

const policies = await client.getPolicies(
  agentId: string
): Promise<PolicyRule[]>;

await client.setPolicies(
  agentId: string,
  policies: PolicyRule[]
): Promise<void>;

import { StewardApiError } from "@stwd/sdk";

try {
  await client.signTransaction("my-agent", { ... });
} catch (error) {
  if (error instanceof StewardApiError) {
    console.error(`HTTP ${error.status}: ${error.message}`);
    
    // For signing errors, data may contain policy results
    if (error.data?.results) {
      console.error("Policy results:", error.data.results);
    }
  }
}

class StewardApiError<TData = unknown> extends Error {
  readonly status: number;  // HTTP status code (0 for network errors)
  readonly data?: TData;    // Response data (may include policy results)
}