import "../_dnt.polyfills.js";
import { known } from "../rpc/mod.js"
import { is, OrthoRune, Run, Rune, RunicArgs, ValueRune } from "../rune/mod.js"
import { BlockHashRune } from "./BlockHashRune.js"
import { BlockRune } from "./BlockRune.js"
import { Chain } from "./ChainRune.js"
import { ExtrinsicEventsRune } from "./ExtrinsicsEventsRune.js"
import { PatternRune } from "./PatternRune.js"
import { SignedExtrinsicRune } from "./SignedExtrinsicRune.js"

export class ExtrinsicStatusRune<out C extends Chain, out U1, out U2>
  extends PatternRune<Run<known.TransactionStatus, U1>, C, U2, SignedExtrinsicRune<C, U2>>
{
  dbgStatus<X>(...prefix: RunicArgs<X, unknown[]>): ExtrinsicStatusRune<C, U1, U2> {
    return this
      .into(OrthoRune)
      .orthoMap((rune) => rune.dbg(...prefix))
      .into(ExtrinsicStatusRune, this.chain, this.parent)
  }

  transactionStatuses(isTerminal: (txStatus: known.TransactionStatus) => boolean) {
    return this
      .into(OrthoRune)
      .orthoMap((events) => events.into(ValueRune).filter(isTerminal))
      .flatSingular()
  }

  inBlock() {
    return this.transactionStatuses((status) =>
      known.TransactionStatus.isTerminal(status)
      || (typeof status !== "string" ? !!status.inBlock : false)
    )
      .map((status) =>
        typeof status !== "string" && status.inBlock ? status.inBlock : new NeverInBlockError()
      )
      .unhandle(is(NeverInBlockError))
      .into(BlockHashRune, this.chain)
  }

  finalized() {
    return this.transactionStatuses(known.TransactionStatus.isTerminal)
      .map((status) =>
        typeof status !== "string" && status.finalized
          ? status.finalized
          : new NeverFinalizedError()
      )
      .unhandle(is(NeverFinalizedError))
      .into(BlockHashRune, this.chain)
  }

  inBlockEvents() {
    return this.events(this.inBlock().block())
  }

  finalizedEvents() {
    return this.events(this.finalized().block())
  }

  private events<EU>(block: BlockRune<C, EU>) {
    const txI = Rune
      .tuple([block.into(ValueRune).access("block", "extrinsics"), this.parent.hex()])
      .map(([hexes, hex]) => {
        const i = hexes.indexOf("0x" + hex)
        return i === -1 ? undefined : i
      })
      .unhandle(is(undefined))
    return Rune
      .tuple([block.events(), txI])
      .unsafeAs<any>()
      .into(ValueRune)
      .map(([events, txI]: [any[], number]) =>
        // TODO: narrow
        events.filter((event: any) =>
          event.phase.type === "ApplyExtrinsic" && event.phase.value === txI
        )
      )
      .rehandle(is(undefined), () => Rune.constant([]))
      .unsafeAs<any>()
      .into(ExtrinsicEventsRune, this.chain)
  }
}

export class NeverInBlockError extends Error {}
export class NeverFinalizedError extends Error {}