/**
 * Core Types for @dotdo/tanstack
 *
 * TanStack DB integration types for local-first sync with PostgreSQL/PGLite.
 */

/**
 * Base record type for collection items
 */
export interface BaseRecord {
  id: string | number
}

/**
 * Collection configuration options
 */
export interface CollectionOptions<T extends BaseRecord> {
  /** Unique identifier for this collection */
  id: string
  /** Optional schema name */
  schema?: string
  /** Table name in PostgreSQL */
  table: string
  /** Primary key field name */
  primaryKey?: keyof T
  /** Timestamps configuration */
  timestamps?: {
    createdAt?: string
    updatedAt?: string
  }
}

/**
 * Query collection options - fetches data via TanStack Query
 */
export interface QueryCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
  /** Query function for fetching data */
  queryFn: () => Promise<T[]>
  /** Stale time in milliseconds */
  staleTime?: number
  /** Cache time in milliseconds */
  cacheTime?: number
  /** Refetch interval in milliseconds */
  refetchInterval?: number
}

/**
 * Sync collection options - maintains real-time sync
 */
export interface SyncCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
  /** Sync endpoint URL */
  syncUrl: string
  /** Shape parameters for Electric-style sync */
  shapeParams?: Record<string, string>
  /** Polling interval for sync in milliseconds */
  pollInterval?: number
  /** Enable debug logging for mutation lifecycle (default: false) */
  debug?: boolean
}

/**
 * Live query options for reactive queries
 */
export interface LiveQueryOptions<T extends BaseRecord, R = T[]> {
  /** Collection ID to query */
  collectionId: string
  /** WHERE clause conditions */
  where?: Partial<T> | ((item: T) => boolean)
  /** ORDER BY configuration */
  orderBy?: {
    field: keyof T
    direction: 'asc' | 'desc'
  }
  /** LIMIT clause */
  limit?: number
  /** OFFSET clause */
  offset?: number
  /** Transform function for results */
  select?: (items: T[]) => R
}

/**
 * Mutation options for transactional writes
 */
export interface MutationOptions<T extends BaseRecord> {
  /** Collection ID to mutate */
  collectionId: string
  /** Whether to apply optimistically */
  optimistic?: boolean
  /** Rollback on error */
  rollbackOnError?: boolean
  /** Custom conflict resolution */
  onConflict?: ConflictResolver<T>
}

/**
 * Optimistic update state
 */
export interface OptimisticState<T extends BaseRecord> {
  /** Pending mutations not yet confirmed */
  pending: PendingMutation<T>[]
  /** Applied changes awaiting server confirmation */
  applied: AppliedMutation<T>[]
}

/**
 * Pending mutation waiting to be sent
 */
export interface PendingMutation<T extends BaseRecord> {
  id: string
  type: 'insert' | 'update' | 'delete'
  collectionId: string
  data: Partial<T>
  timestamp: number
}

/**
 * Applied mutation awaiting confirmation
 */
export interface AppliedMutation<T extends BaseRecord> {
  id: string
  type: 'insert' | 'update' | 'delete'
  collectionId: string
  recordId: string | number
  data: Partial<T>
  previousData?: T
  timestamp: number
  txId?: string
}

/**
 * Conflict types that can occur during sync
 */
export type ConflictType =
  | 'update-update' // Both local and remote updated same record
  | 'update-delete' // Local updated, remote deleted
  | 'delete-update' // Local deleted, remote updated
  | 'insert-insert' // Both inserted record with same key

/**
 * Conflict information for resolution
 */
export interface Conflict<T extends BaseRecord> {
  type: ConflictType
  collectionId: string
  recordId: string | number
  localValue?: Partial<T>
  remoteValue?: Partial<T>
  baseValue?: T
  localTimestamp: number
  remoteTimestamp: number
}

/**
 * Conflict resolution strategy
 */
export type ConflictStrategy =
  | 'local-wins'
  | 'remote-wins'
  | 'latest-wins'
  | 'merge'
  | 'manual'

/**
 * Conflict resolver function
 */
export type ConflictResolver<T extends BaseRecord> = (
  conflict: Conflict<T>
) => Promise<T | null> | T | null

/**
 * Sync state for a collection
 */
export interface SyncState {
  /** Whether sync is currently active */
  connected: boolean
  /** Last successful sync timestamp */
  lastSyncAt?: number
  /** Last sync error if any */
  lastError?: Error
  /** Number of pending changes */
  pendingCount: number
  /** Whether initial sync is complete */
  initialized: boolean
}

/**
 * PGLite collection options for local database
 */
export interface PGLiteCollectionOptions<T extends BaseRecord> extends CollectionOptions<T> {
  /** PGLite instance or factory */
  pglite: PGLiteInterface | (() => Promise<PGLiteInterface>)
  /** Whether to create table if not exists */
  autoCreateTable?: boolean
  /** Table schema definition for auto-create */
  tableSchema?: string
}

/**
 * Minimal PGLite interface for type safety
 */
export interface PGLiteInterface {
  query<R = unknown>(sql: string, params?: unknown[]): Promise<{ rows: R[] }>
  exec(sql: string): Promise<void>
  close(): Promise<void>
}

/**
 * Collection instance with methods
 */
export interface Collection<T extends BaseRecord> {
  /** Collection ID */
  readonly id: string
  /** Get all items */
  getAll(): T[]
  /** Get item by ID */
  get(id: string | number): T | undefined
  /** Insert a new item */
  insert(data: Omit<T, 'id'> & { id?: T['id'] }): Promise<T>
  /** Update an existing item */
  update(id: string | number, data: Partial<T>): Promise<T>
  /** Delete an item */
  delete(id: string | number): Promise<void>
  /** Subscribe to changes */
  subscribe(callback: (items: T[]) => void): () => void
  /** Get current sync state */
  getSyncState(): SyncState
}

/**
 * TanStack DB Store interface
 */
export interface TanStackStore {
  /** Get a collection by ID */
  getCollection<T extends BaseRecord>(id: string): Collection<T> | undefined
  /** Register a new collection */
  registerCollection<T extends BaseRecord>(
    options: QueryCollectionOptions<T> | SyncCollectionOptions<T> | PGLiteCollectionOptions<T>
  ): Collection<T>
  /** Get all registered collection IDs */
  getCollectionIds(): string[]
  /** Dispose of all resources */
  dispose(): Promise<void>
}