import type { CachedTable } from "@snort/shared"
import type { UsersRelays, CachedMetadata, UsersFollows } from "./cache"
import type { CacheRelay } from "./cache-relay"
import type { RelaySettings } from "./connection"
import type { ConnectionPool } from "./connection-pool"
import type { TaggedNostrEvent, OkResponse, ReqFilter, NostrEvent } from "./nostr"
import type { RelayMetadataLoader } from "./outbox"
import type { ProfileLoaderService } from "./profile-cache"
import type { Optimizer } from "./query-optimizer"
import type { RequestBuilder } from "./request-builder"
import type { RequestRouter } from "./request-router"
import type { QueryEvents } from "./query"
import type { TraceTimeline } from "./trace-timeline"
import type EventEmitter from "eventemitter3"
import type { SocialGraph } from "nostr-social-graph"

export type QueryLike = {
  get progress(): number
  feed: {
    add: (evs: Array<TaggedNostrEvent>) => void
    clear: () => void
  }
  /**
   * Mark query for cancellation
   */
  cancel: () => void
  /**
   * Un-mark query for cancellation
   */
  uncancel: () => void
  /**
   * Start query request flow
   */
  start: () => void
  /**
   * Flush any buffered data
   */
  flush: () => void
  get snapshot(): Array<TaggedNostrEvent>
} & EventEmitter<QueryEvents>

export interface NostrSystemEvents {
  change: (state: SystemSnapshot) => void
  auth: (challenge: string, relay: string, cb: (ev: NostrEvent) => void) => void
}

/**
 * Configuration used for all sub-systems in SystemInterface impl
 */
export interface SystemConfig {
  /**
   * Users configured relays (via kind 3 or kind 10_002)
   */
  relays: CachedTable<UsersRelays>

  /**
   * Cache of user profiles, (kind 0)
   */
  profiles: CachedTable<CachedMetadata>

  /**
   * Cache of user ContactLists (kind 3)
   */
  contactLists: CachedTable<UsersFollows>

  /**
   * Optimized cache relay, usually `@snort/worker-relay`
   */
  cachingRelay?: CacheRelay

  /**
   * Optimized functions, usually `@snort/system-wasm`
   */
  optimizer: Optimizer

  /**
   * Check event sigs on receive from relays
   */
  checkSigs: boolean

  /**
   * Automatically handle outbox model
   *
   * 1. Fetch relay lists automatically for queried authors
   * 2. Write to inbox for all `p` tagged users in broadcasting events
   */
  automaticOutboxModel: boolean

  /**
   * Automatically populate SocialGraph from kind 3 events fetched.
   *
   * This is basically free because we always load relays (which includes kind 3 contact lists)
   * for users when fetching by author.
   */
  buildFollowGraph: boolean

  /**
   * Pick a fallback sync method when negentropy is not available
   */
  fallbackSync: "since" | "range-sync"

  /**
   * Internal social graph used for WoT filtering
   */
  socialGraphInstance: SocialGraph

  /**
   * Disable negentropy / range-sync modules
   */
  disableSyncModule: boolean
}

export interface SystemInterface {
  /**
   * Check event signatures (reccomended)
   */
  checkSigs: boolean

  /**
   * Do some initialization
   * @param follows A follower list to preload content for
   */
  Init(follows?: Array<string>): Promise<void>

  /**
   * Get an active query by ID
   * @param id Query ID
   */
  GetQuery(id: string): QueryLike | undefined

  /**
   * Open a new query to relays
   * @param req Request to send to relays
   */
  Query(req: RequestBuilder): QueryLike

  /**
   * Fetch data from nostr relays asynchronously
   * @param req Request to send to relays
   * @param cb A callback which will fire every 100ms when new data is received
   */
  Fetch(req: RequestBuilder, cb?: (evs: Array<TaggedNostrEvent>) => void): Promise<Array<TaggedNostrEvent>>

  /**
   * Wait for all active queries to reach EOSE.
   * Useful for SSR: render once to discover queries, call FetchAll(), then re-render.
   */
  FetchAll(): Promise<void>

  /**
   * Create a new permanent connection to a relay
   * @param address Relay URL
   * @param options Read/Write settings
   */
  ConnectToRelay(address: string, options: RelaySettings): Promise<void>

  /**
   * Disconnect permanent relay connection
   * @param address Relay URL
   */
  DisconnectRelay(address: string): void

  /**
   * Push an event into the system from external source
   */
  HandleEvent(subId: string, ev: TaggedNostrEvent): void

  /**
   * Send an event to all permanent connections
   * @param ev Event to broadcast
   * @param cb Callback to handle OkResponse as they arrive
   */
  BroadcastEvent(ev: NostrEvent, cb?: (rsp: OkResponse) => void): Promise<Array<OkResponse>>

  /**
   * Connect to a specific relay and send an event and wait for the response
   * @param relay Relay URL
   * @param ev Event to send
   */
  WriteOnceToRelay(relay: string, ev: NostrEvent): Promise<OkResponse>

  /**
   * Profile cache/loader
   */
  get profileLoader(): ProfileLoaderService

  /**
   * Query optimizer
   */
  get optimizer(): Optimizer

  /**
   * ContactList cache
   */
  get userFollowsCache(): CachedTable<UsersFollows>

  /**
   * Relay loader loads relay metadata for a set of profiles
   */
  get relayLoader(): RelayMetadataLoader

  /**
   * Main connection pool
   */
  get pool(): ConnectionPool

  /**
   * Local relay cache service
   */
  get cacheRelay(): CacheRelay | undefined

  /**
   * Request router instance
   */
  get requestRouter(): RequestRouter | undefined

  /**
   * Trace timeline for debugging and performance monitoring
   */
  get traceTimeline(): TraceTimeline | undefined

  /**
   * Get internal system config
   */
  get config(): SystemConfig

  /**
   * Hydrate a query with pre-loaded events (for SSR)
   */
  hydrateQuery(id: string, events: Array<TaggedNostrEvent>): void

  /**
   * Get hydration data for all queries (for SSR output)
   */
  getHydrationData(): Record<string, Array<TaggedNostrEvent>>
}

export interface SystemSnapshot {
  queries: Array<{
    id: string
    filters: Array<ReqFilter>
    subFilters: Array<ReqFilter>
  }>
}