import type { Event } from 'nostr-tools'
import { extractTagsFromEvent } from '../nostrTagSystem'
import { parsePresentationEvent } from '../articlePublisherHelpersPresentation'
import {
  parseArticleFromEvent,
  parsePurchaseFromEvent,
  parseReviewFromEvent,
  parseReviewTipFromEvent,
  parseSeriesFromEvent,
  parseSponsoringFromEvent,
} from '../nostrEventParsing'
import {
  logTargetEventAttempt,
  logTargetEventCached,
  logTargetEventDebug,
  logTargetEventNotCached,
  logTargetEventParsed,
  logTargetEventSkipped,
} from './debug'

type ExtractedTags = ReturnType<typeof extractTagsFromEvent>

type WriteObjectToCache = typeof import('../helpers/writeObjectHelper').writeObjectToCache

export async function cachePlatformEvent(event: Event): Promise<void> {
  const tags = extractTagsFromEvent(event)
  const { writeObjectToCache } = await import('../helpers/writeObjectHelper')

  logTargetEventDebug({ event, tags })
  if (tags.hidden) {
    logTargetEventSkipped({ event, tags })
    return
  }

  if (await tryCacheAuthorEvent({ event, tags, writeObjectToCache })) {
    return
  }
  if (await tryCacheSeriesEvent({ event, tags, writeObjectToCache })) {
    return
  }
  if (await tryCachePublicationEvent({ event, tags, writeObjectToCache })) {
    return
  }
  if (await tryCacheReviewEvent({ event, tags, writeObjectToCache })) {
    return
  }
  await tryCacheZapReceiptEvent({ event, writeObjectToCache })
}

async function tryCacheAuthorEvent(params: {
  event: Event
  tags: ExtractedTags
  writeObjectToCache: WriteObjectToCache
}): Promise<boolean> {
  if (params.tags.type !== 'author') {
    return false
  }

  logTargetEventAttempt({ event: params.event, message: 'Attempting to parse target event as author presentation' })
  const parsed = await parsePresentationEvent(params.event)
  logTargetEventParsed({ event: params.event, parsed })

  if (!parsed?.hash) {
    logTargetEventNotCached({ event: params.event, parsed })
    return true
  }

  await params.writeObjectToCache({
    objectType: 'author',
    hash: parsed.hash,
    event: params.event,
    parsed,
    version: params.tags.version,
    hidden: params.tags.hidden,
    index: parsed.index,
  })
  logTargetEventCached({ event: params.event, hash: parsed.hash })
  return true
}

async function tryCacheSeriesEvent(params: {
  event: Event
  tags: ExtractedTags
  writeObjectToCache: WriteObjectToCache
}): Promise<boolean> {
  if (params.tags.type !== 'series') {
    return false
  }
  const parsed = await parseSeriesFromEvent(params.event)
  if (!parsed?.hash) {
    return true
  }
  await params.writeObjectToCache({
    objectType: 'series',
    hash: parsed.hash,
    event: params.event,
    parsed,
    version: params.tags.version,
    hidden: params.tags.hidden,
    index: parsed.index,
  })
  return true
}

async function tryCachePublicationEvent(params: {
  event: Event
  tags: ExtractedTags
  writeObjectToCache: WriteObjectToCache
}): Promise<boolean> {
  if (params.tags.type !== 'publication') {
    return false
  }
  const parsed = await parseArticleFromEvent(params.event)
  if (!parsed?.hash) {
    return true
  }
  await params.writeObjectToCache({
    objectType: 'publication',
    hash: parsed.hash,
    event: params.event,
    parsed,
    version: params.tags.version,
    hidden: params.tags.hidden,
    index: parsed.index,
  })
  return true
}

async function tryCacheReviewEvent(params: {
  event: Event
  tags: ExtractedTags
  writeObjectToCache: WriteObjectToCache
}): Promise<boolean> {
  if (params.tags.type !== 'quote') {
    return false
  }
  const parsed = await parseReviewFromEvent(params.event)
  if (!parsed?.hash) {
    return true
  }
  await params.writeObjectToCache({
    objectType: 'review',
    hash: parsed.hash,
    event: params.event,
    parsed,
    version: params.tags.version,
    hidden: params.tags.hidden,
    index: parsed.index,
  })
  return true
}

async function tryCacheZapReceiptEvent(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
  if (params.event.kind !== 9735) {
    return false
  }

  if (await tryCacheSponsoringZapReceipt(params)) {
    return true
  }
  if (await tryCachePurchaseZapReceipt(params)) {
    return true
  }
  if (await tryCacheReviewTipZapReceipt(params)) {
    return true
  }
  return true
}

async function tryCacheSponsoringZapReceipt(params: {
  event: Event
  writeObjectToCache: WriteObjectToCache
}): Promise<boolean> {
  const sponsoring = await parseSponsoringFromEvent(params.event)
  if (!sponsoring?.hash) {
    return false
  }
  await params.writeObjectToCache({
    objectType: 'sponsoring',
    hash: sponsoring.hash,
    event: params.event,
    parsed: sponsoring,
    index: sponsoring.index,
  })
  return true
}

async function tryCachePurchaseZapReceipt(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
  const purchase = await parsePurchaseFromEvent(params.event)
  if (!purchase?.hash) {
    return false
  }
  await params.writeObjectToCache({
    objectType: 'purchase',
    hash: purchase.hash,
    event: params.event,
    parsed: purchase,
    index: purchase.index,
  })
  return true
}

async function tryCacheReviewTipZapReceipt(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
  const reviewTip = await parseReviewTipFromEvent(params.event)
  if (!reviewTip?.hash) {
    return false
  }
  await params.writeObjectToCache({
    objectType: 'review_tip',
    hash: reviewTip.hash,
    event: params.event,
    parsed: reviewTip,
    index: reviewTip.index,
  })
  return true
}