import { createChart } from 'polynode-charts'

const chart = createChart(container, options?)

interface ChartOptions {
  width?: number            // fixed width (px)
  height?: number           // fixed height (px)
  autoSize?: boolean        // auto-resize to container (default: true)
  layout?: LayoutOptions
  grid?: GridOptions
  crosshair?: CrosshairOptions
  timeScale?: TimeScaleOptions
  rightPriceScale?: PriceScaleOptions
}

interface LayoutOptions {
  background?: string    // default: '#080d16'
  textColor?: string     // default: '#556'
  fontFamily?: string    // default: '"SF Mono", "Fira Code", monospace'
  fontSize?: number      // default: 10
}

interface GridOptions {
  vertLines?: { color?: string; visible?: boolean }
  horzLines?: { color?: string; visible?: boolean }
}

interface PriceScaleOptions {
  mode?: 'normal' | 'probability'  // 'probability' clamps axis to 0-100%
  autoScale?: boolean
  scaleMargins?: { top?: number; bottom?: number }
}

chart.addCandleSeries(opts?: CandleSeriesOptions): CandleSeries
chart.addLineSeries(opts?: LineSeriesOptions): LineSeries
chart.addAreaSeries(opts?: AreaSeriesOptions): AreaSeries
chart.addVolumeSeries(opts?: VolumeSeriesOptions): VolumeSeries
chart.removeSeries(series): void

chart.timeScale(): TimeScale

// Subscribe to crosshair movement — returns unsubscribe function
const unsub = chart.subscribeCrosshairMove((params) => {
  console.log(params.time, params.point)
})
unsub()  // stop listening

// Subscribe to chart clicks
const unsub2 = chart.subscribeClick((params) => {
  console.log('Clicked at time:', params.time)
})

interface CrosshairMoveParams {
  time: number | null
  point: { x: number; y: number } | null
  seriesData: Map<string, OhlcData | LineData>
}

interface ClickParams {
  time: number | null
  point: { x: number; y: number }
}

chart.getContainer(): HTMLElement  // returns the chart's parent DOM element

chart.resize(width, height): void  // manual resize
chart.remove(): void               // cleanup everything

series.setData(data[]): void      // replace all data
series.update(item): void          // append or update last point
series.setMaxLength(n): void       // cap buffer size (drops oldest)

const series = chart.addCandleSeries({
  upColor: '#22c55e',
  downColor: '#ef4444',
  wickUpColor: '#22c55e',    // optional, defaults to upColor
  wickDownColor: '#ef4444',  // optional, defaults to downColor
  borderVisible: true,
})

interface OhlcData {
  time: number   // epoch milliseconds
  open: number
  high: number
  low: number
  close: number
  volume?: number
}

const series = chart.addLineSeries({
  color: '#f7931a',
  lineWidth: 2,
  smooth: true,        // bezier curve interpolation
  showDot: true,       // pulsing dot at last point
  dotColor: '#f7931a',
})

interface LineData {
  time: number   // epoch milliseconds
  value: number
}

series.setLive(true)   // phantom point + smooth lerp
series.isLive()        // check live state

series.setPriceLine(72822.50, {
  color: '#3b82f6',
  dash: [6, 4],
  label: 'PRICE TO BEAT',
  labelColor: '#fff',
})

series.clearPriceLine()
series.getPriceLine()  // returns PriceLineConfig | null

const series = chart.addAreaSeries({
  color: '#6ea8fe',          // line color
  topColor: '#6ea8fe33',     // gradient top
  bottomColor: '#6ea8fe00',  // gradient bottom (transparent)
  lineWidth: 2,
  smooth: true,
})

const series = chart.addVolumeSeries({
  upColor: 'rgba(34, 197, 94, 0.4)',
  downColor: 'rgba(239, 68, 68, 0.4)',
  opacity: 0.4,
})

interface VolumeData {
  time: number
  value: number
  color?: string  // override per-bar color
}

const ts = chart.timeScale()

import { createOrderbook } from 'polynode-charts'

const ob = createOrderbook('#orderbook', {
  colorBid: '#22c55e',
  colorAsk: '#ef4444',
  depthFillOpacity: 0.08,
  labelCount: 8,
})

ob.update({
  bids: [{ price: 0.54, size: 1200 }, { price: 0.53, size: 800 }],
  asks: [{ price: 0.55, size: 900 }, { price: 0.56, size: 1500 }],
})

interface OrderbookOptions {
  colorBid?: string          // default: '#22c55e'
  colorAsk?: string          // default: '#ef4444'
  depthFillOpacity?: number  // default: 0.08
  labelCount?: number        // price labels on axis
  background?: string
  textColor?: string
}

interface BookData {
  bids: PriceLevel[]
  asks: PriceLevel[]
}

interface PriceLevel {
  price: number
  size: number
}

import { createChart, createShortFormOverlay } from 'polynode-charts'

const chart = createChart('#btc', { layout: { background: '#0c1220' } })
const series = chart.addLineSeries({ color: '#f7931a', showDot: true })
series.setLive(true)
chart.timeScale().goLive()

// One line: buttons + discovery + price line + odds + countdown
const overlay = createShortFormOverlay(chart, series, { coin: 'btc' })

interface ShortFormOverlayOptions {
  coin: ShortFormCoin                   // 'btc' | 'eth' | 'sol' | 'xrp' | 'doge' | 'hype'
  intervals?: ShortFormInterval[]       // default: ['5m', '15m', '1h']
  defaultInterval?: ShortFormInterval   // if set, auto-starts on creation
  onRotation?: (event: RotationEvent) => void  // callback on each poll/rotation
}

interface MarketInfo {
  token_id: string
  question: string        // the market question (e.g. "US x Iran ceasefire by April 7?")
  slug: string
  image: string
  last_price: number
  volume_24h: number
  outcomes: string[]      // e.g. ['Yes', 'No']
  outcome: string         // which outcome THIS token is ('Yes' or 'No')
  condition_id?: string
  neg_risk?: boolean      // true for multi-outcome events (elections, championships)
}