import type { Market, Order, Quotes, Orderbook, Position, Balance } from "@contextwtf/sdk"

// List and search
ctx.markets.list(params?: {
  status?: string, category?: string, creator?: string,
  query?: string, sortBy?: string, sort?: string,
  limit?: number, cursor?: string
}): Promise<{ markets: Market[], cursor?: string }>

ctx.markets.listAll(params?): Promise<Market[]>
ctx.markets.get(id: string): Promise<Market>

// Pricing and orderbook
ctx.markets.quotes(id: string): Promise<Quotes>
ctx.markets.orderbook(id: string, params?: {
  depth?: number, outcomeIndex?: number
}): Promise<Orderbook>

ctx.markets.simulate(id: string, params: {
  side: string, amount: number, amountType?: "usd" | "contracts"
}): Promise<SimulateResult>

ctx.markets.priceHistory(id: string, params?: {
  timeframe?: "1h" | "6h" | "1d" | "1w" | "1M" | "all"
}): Promise<PriceHistory>

// Oracle
ctx.markets.oracle(id: string): Promise<OracleData>
ctx.markets.oracleQuotes(id: string): Promise<OracleQuote[]>
ctx.markets.requestOracleQuote(id: string): Promise<OracleQuote>

// Activity
ctx.markets.activity(id: string, params?: {
  limit?: number, cursor?: string
}): Promise<ActivityResponse>

ctx.markets.globalActivity(params?: {
  limit?: number, cursor?: string
}): Promise<ActivityResponse>

// Create orders (requires signer)
ctx.orders.create(params: {
  marketId: string, outcome: "yes" | "no",
  side: "buy" | "sell", priceCents: number, size: number,
  expirySeconds?: number
}): Promise<Order>

ctx.orders.marketOrder(params: {
  marketId: string, outcome: "yes" | "no",
  amount: number, amountType?: "usd" | "contracts"
}): Promise<Order>

// Cancel orders
ctx.orders.cancel(nonce: string): Promise<void>
ctx.orders.cancelReplace(nonce: string, params: {
  priceCents: number, size: number
}): Promise<Order>

// Bulk operations
ctx.orders.bulkCreate(orders: CreateOrderParams[]): Promise<Order[]>
ctx.orders.bulkCancel(nonces: string[]): Promise<void>
ctx.orders.bulk(params: {
  creates?: CreateOrderParams[], cancels?: string[]
}): Promise<{ created: Order[], cancelled: string[] }>

// Query orders
ctx.orders.list(params?: {
  trader?: string, market?: string, status?: string,
  limit?: number, cursor?: string
}): Promise<{ orders: Order[], cursor?: string }>

ctx.orders.listAll(params?): Promise<Order[]>
ctx.orders.mine(params?: { market?: string }): Promise<Order[]>
ctx.orders.allMine(params?): Promise<Order[]>
ctx.orders.get(id: string): Promise<Order>
ctx.orders.recent(params?: {
  trader?: string, market?: string, status?: string,
  limit?: number, windowSeconds?: number
}): Promise<Order[]>

ctx.portfolio.get(params?: {
  address?: string, kind?: "all" | "active" | "won" | "lost" | "claimable",
  market?: string, cursor?: string, pageSize?: number
}): Promise<{ positions: Position[], cursor?: string }>

ctx.portfolio.claimable(params?: { address?: string }): Promise<ClaimableResponse>
ctx.portfolio.stats(params?: { address?: string }): Promise<PortfolioStats>
ctx.portfolio.balance(params?: { address?: string }): Promise<Balance>
ctx.portfolio.tokenBalance(address: string, token: string): Promise<TokenBalance>

ctx.account.status(): Promise<WalletStatus>
ctx.account.setup(): Promise<void>
ctx.account.mintTestUsdc(amount?: number): Promise<void>
ctx.account.deposit(amount: number): Promise<void>
ctx.account.withdraw(amount: number): Promise<void>
ctx.account.mintCompleteSets(marketId: string, amount: number): Promise<void>
ctx.account.burnCompleteSets(marketId: string, amount: number, params?: {
  creditInternal?: boolean
}): Promise<void>
ctx.account.relayOperatorApproval(): Promise<void>
ctx.account.relayDeposit(amount: number): Promise<void>

interface Market {
  id: string
  question: string
  shortQuestion: string
  status: "active" | "pending" | "resolved" | "closed"
  volume: string
  volume24h: string
  participantCount: number
  outcomePrices: OutcomePrice[]
  resolutionStatus: "none" | "pending" | "resolved"
  deadline: string
  metadata: MarketMetadata
}

interface Order {
  nonce: string            // hex, unique identifier
  marketId: string
  trader: string
  outcomeIndex: number
  side: 0 | 1              // 0 = Buy, 1 = Sell
  price: string            // numeric string (6 decimals)
  size: string
  type: "limit" | "market"
  status: "open" | "filled" | "cancelled" | "expired" | "voided"
  filledSize: string
  remainingSize: string
  percentFilled: number
  voidReason: "UNFILLED_MARKET_ORDER" | "UNDER_COLLATERALIZED" | "MISSING_OPERATOR_APPROVAL" | null
}

interface Quotes {
  marketId: string
  yes: { bid: number | null, ask: number | null, last: number | null }
  no: { bid: number | null, ask: number | null, last: number | null }
  spread: number | null
}

interface Orderbook {
  marketId: string
  bids: { price: number, size: number }[]
  asks: { price: number, size: number }[]
}

interface Position {
  tokenAddress: string
  balance: string
  outcomeIndex: number
  outcomeName: string
  marketId: string
  netInvestment: string
  currentValue: string
}

interface Balance {
  address: string
  usdc: { balance: string, settlementBalance: string, walletBalance: string }
}

interface WalletStatus {
  address: string
  ethBalance: string
  usdcAllowance: string
  isOperatorApproved: boolean
  needsApprovals: boolean
}