import type { Horizon, LogLevel } from './common.js'
import type { BigNumberish } from 'ethers'

export type DeliveryMode = 'realtime' | 'redrive' | 'backfill'

export type BackfillRequest<T = Record<string, any>> = {
  jobId: string
  indexerId: string
  logLevel: LogLevel
  context: T
}

export type EvmIngestedBlock = {
  // Normalized Data from RPC nodes
  number: number
  hash: string
  parentHash: string
  nonce: string
  sha3Uncles?: string
  stateRoot?: string
  receiptsRoot?: string
  logsBloom?: string
  miner?: string
  extraData: string
  size: number
  gasLimit: string
  gasUsed: string
  baseFeePerGas: string
  timestamp: number
  transactions: string[]
  uncles?: string[]

  // Additional Flair-specific data
  chainId: number
  blockForkIndex: number
  ingestionReceivedAt: number
  delivery: DeliveryMode
}
export type IngestedBlock = EvmIngestedBlock // @deprecated

export type EvmIngestedTransaction = {
  // Normalized data from RPC nodes
  blockNumber: number
  blockHash: string
  hash: string
  to?: string
  from?: string
  nonce?: number
  gasLimit?: string
  gasPrice?: string
  maxFeePerGas?: string
  maxPriorityFeePerGas?: string
  data?: string
  value?: string
  type?: number
  accessList?: any[]
  status?: boolean
  revertReason?: string

  // Augmented data from RPC nodes
  blockTimestamp: number
  gasUsed?: BigNumberish
  effectiveGasPrice?: BigNumberish
  deployedContractAddress?: string
  events?: EvmInlineEvent[]
  traces?: EvmInlineTrace[]

  // Additional Flair-specific data
  chainId: number
  blockForkIndex: number
  indexerId?: string
  filterGroupId?: string
  createdAt?: number
  ingestionReceivedAt: number
}
export type IngestedTransaction = EvmIngestedTransaction // @deprecated

export type EvmIngestedEvent = {
  // Normalized Data from RPC nodes
  blockNumber: `0x${string}`
  blockHash: string
  address: string
  data?: string
  logIndex: number
  topics?: string[]
  transactionHash: string
  transactionIndex: number

  // Augmented data from RPC nodes
  blockTimestamp: number

  // Additional Flair-specific data
  chainId: number
  blockForkIndex: number
  localIndex: number
  ingestionReceivedAt: number
  receivingEndpoint?: string
  delivery: DeliveryMode
}
export type IngestedEvent = EvmIngestedEvent // @deprecated

export type EvmParsedCall<
  INPUT = Record<string, any> | any[],
  OUTPUT = Record<string, any> | any[],
> = {
  name: string
  sighash: string
  input: INPUT
  output?: OUTPUT
}

export type EvmInlineEvent<TArgs = Record<string, any>> = {
  address: string
  logIndex: number
  topics?: string[]
  data?: string
  eventName?: string
  args?: TArgs
}

export type EvmTraceType = 'call' | 'create' | 'suicide' | 'reward'

export type EvmTraceCallType = 'call' | 'create' | 'delegatecall' | 'staticcall'

export type EvmInlineTrace = {
  action: {
    from: string
    callType: EvmTraceCallType
    gas: string
    input: string
    to: string
    value: string
    parsed?: EvmParsedCall
  }
  result: {
    gasUsed: string
    output: string
  }
  subtraces: number
  traceAddress: number[]
  type: EvmTraceType
  parsed?: EvmParsedCall
}

export type EvmBlockReorg = {
  indexerId: string
  chainId: number
  forkIndex: number
  newBlock: EvmIngestedBlock
  detectedAt: number
}
export type BlockReorg = EvmBlockReorg // @deprecated

export type BlockHandlerInput<ContextType = Record<string, any>> = {
  block: EvmIngestedBlock
  horizon: Horizon
  backfill?: BackfillRequest<ContextType>
}

export type TransactionHandlerInput<ContextType = Record<string, any>> = {
  transaction: EvmIngestedTransaction
  horizon: Horizon
  backfill?: BackfillRequest<ContextType>
}

export type EventHandlerInput<
  ArgsType = Record<string, any>,
  ContextType = Record<string, any>,
> = {
  chainId: number
  blockNumber: number
  blockTimestamp: number
  txHash: string
  txIndex: number
  log: EvmIngestedEvent
  horizon: Horizon
  parsed?: {
    name: string
    topic: string
    args: ArgsType
  }
  abi?: Record<string, any>
  backfill?: BackfillRequest<ContextType>
}

export type ReorgHandlerInput<ContextType = Record<string, any>> = {
  reorg: EvmBlockReorg
  horizon: Horizon
  backfill?: BackfillRequest<ContextType>
}

export type BlockProcessorHandlerObject = {
  processBlock: <TArgs>(
    input: BlockHandlerInput<TArgs>,
  ) => Promise<boolean | undefined>
}

export type TransactionProcessorHandlerObject = {
  processTransaction: <TArgs>(
    input: TransactionHandlerInput<TArgs>,
  ) => Promise<boolean | undefined>
}

export type EventProcessorHandlerObject = {
  processEvent: <TArgs, TContext>(
    input: EventHandlerInput<TArgs, TContext>,
  ) => Promise<boolean | undefined>
}

export type ReorgProcessorHandlerObject = {
  processReorg: <TArgs>(
    input: ReorgHandlerInput<TArgs>,
  ) => Promise<boolean | undefined>
}

export type EnricherHandlerInput<
  TData = Record<string, any>,
  TParams = Record<string, any>,
> = {
  data?: TData
  parameters?: TParams
}

export type EnricherHandlerObject = {
  handleInput:
    | (<TData, TParams>(
        input: EnricherHandlerInput<TData, TParams>,
      ) => Promise<boolean | undefined>)
    | (<TData, TParams>(
        input: EnricherHandlerInput<TData, TParams>,
        callback: (result: undefined, error?: Error) => void,
      ) => void)
}