import type { Event } from 'nostr-tools'
import type { Article, Page, Purchase, Review, ReviewTip, Series, Sponsoring } from '@/types/nostr'
import { extractTagsFromEvent } from './nostrTagSystem'
import { buildObjectId, parseObjectId } from './urlGenerator'
import { generateHashId } from './hashIdGenerator'
import { extractPurchaseFromEvent, extractReviewTipFromEvent, extractSponsoringFromEvent } from './metadataExtractor'

/**
 * Parse article metadata from Nostr event
 * Uses new tag system: #publication, #sciencefiction|research, #id_<id>, #paywall, #payment
 */
export async function parseArticleFromEvent(event: Event): Promise<Article | null> {
  try {
    const tags = extractTagsFromEvent(event)
    // Check if it's a publication type
    if (tags.type !== 'publication') {
      return null
    }
    const { previewContent } = getPreviewContent(event.content, tags.preview)
    return buildArticle(event, tags, previewContent)
  } catch (e) {
    console.error('Error parsing article:', e)
    return null
  }
}

export async function parseSeriesFromEvent(event: Event): Promise<Series | null> {
  try {
    const tags = extractTagsFromEvent(event)
    const input = readSeriesInput({ tags, eventContent: event.content })
    if (!input) {
      return null
    }
    const category = mapNostrCategoryToLegacy(tags.category) ?? 'science-fiction'

    const { hash, version, index } = await resolveObjectIdParts({
      ...(input.idTag ? { idTag: input.idTag } : {}),
      defaultVersion: input.defaultVersion,
      defaultIndex: 0,
      generateHash: async (): Promise<string> => generateHashId({
        type: 'series',
        pubkey: event.pubkey,
        title: input.title,
        description: input.description,
        category: input.categoryTag,
        coverUrl: input.coverUrl,
      }),
    })

    return buildSeriesFromParsed({
      event,
      input,
      hash,
      version,
      index,
      category,
    })
  } catch (e) {
    console.error('Error parsing series:', e)
    return null
  }
}

export async function parseReviewFromEvent(event: Event): Promise<Review | null> {
  try {
    const tags = extractTagsFromEvent(event)
    const input = readReviewInput(tags)
    if (!input) {
      return null
    }

    const { hash, version, index } = await resolveObjectIdParts({
      ...(input.idTag ? { idTag: input.idTag } : {}),
      defaultVersion: input.defaultVersion,
      defaultIndex: 0,
      generateHash: async (): Promise<string> => generateHashId({
        type: 'quote',
        pubkey: event.pubkey,
        articleId: input.articleId,
        reviewerPubkey: input.reviewerPubkey,
        content: event.content,
        title: input.title ?? '',
      }),
    })

    const rewardInfo = readRewardInfo(event.tags)
    const text = readTextTag(event.tags)
    return buildReviewFromParsed({ event, input, hash, version, index, rewardInfo, text })
  } catch (e) {
    console.error('Error parsing review:', e)
    return null
  }
}

function buildSeriesFromParsed(params: {
  event: Event
  input: { title: string; description: string; preview: string; coverUrl: string }
  hash: string
  version: number
  index: number
  category: Series['category']
}): Series {
  const id = buildObjectId(params.hash, params.index, params.version)
  const series: Series = {
    id,
    hash: params.hash,
    version: params.version,
    index: params.index,
    pubkey: params.event.pubkey,
    title: params.input.title,
    description: params.input.description,
    preview: params.input.preview,
    thumbnailUrl: params.input.coverUrl,
    category: params.category,
    ...(params.input.coverUrl ? { coverUrl: params.input.coverUrl } : {}),
  }
  series.kindType = 'series'
  return series
}

function buildReviewFromParsed(params: {
  event: Event
  input: { articleId: string; reviewerPubkey: string; title: string | undefined; description: string }
  hash: string
  version: number
  index: number
  rewardInfo: { rewarded: boolean; rewardAmount: number | undefined }
  text: string | undefined
}): Review {
  const id = buildObjectId(params.hash, params.index, params.version)
  const review: Review = {
    id,
    hash: params.hash,
    version: params.version,
    index: params.index,
    articleId: params.input.articleId,
    authorPubkey: params.event.pubkey,
    reviewerPubkey: params.input.reviewerPubkey,
    content: params.event.content,
    description: params.input.description,
    createdAt: params.event.created_at,
    ...(params.input.title ? { title: params.input.title } : {}),
    ...(params.text ? { text: params.text } : {}),
    ...(params.rewardInfo.rewarded ? { rewarded: true } : {}),
    ...(params.rewardInfo.rewardAmount !== undefined ? { rewardAmount: params.rewardInfo.rewardAmount } : {}),
  }
  review.kindType = 'review'
  return review
}

function readSeriesInput(params: { tags: ReturnType<typeof extractTagsFromEvent>; eventContent: string }): {
  idTag: string | undefined
  defaultVersion: number
  title: string
  description: string
  preview: string
  coverUrl: string
  categoryTag: string
} | null {
  if (params.tags.type !== 'series' || !params.tags.title || !params.tags.description) {
    return null
  }

  return {
    idTag: params.tags.id,
    defaultVersion: params.tags.version ?? 0,
    title: params.tags.title,
    description: params.tags.description,
    preview: params.tags.preview ?? params.eventContent.substring(0, 200),
    coverUrl: params.tags.coverUrl ?? '',
    categoryTag: params.tags.category ?? 'sciencefiction',
  }
}

function readReviewInput(tags: ReturnType<typeof extractTagsFromEvent>): {
  idTag: string | undefined
  defaultVersion: number
  articleId: string
  reviewerPubkey: string
  title: string | undefined
  description: string
} | null {
  if (tags.type !== 'quote' || !tags.articleId || !tags.reviewerPubkey) {
    return null
  }
  return {
    idTag: tags.id,
    defaultVersion: tags.version ?? 0,
    articleId: tags.articleId,
    reviewerPubkey: tags.reviewerPubkey,
    title: tags.title,
    description: tags.description ?? '',
  }
}

function readRewardInfo(eventTags: string[][]): { rewarded: boolean; rewardAmount: number | undefined } {
  const rewarded = eventTags.some((tag) => tag[0] === 'rewarded' && tag[1] === 'true')
  const rewardAmountTag = eventTags.find((tag) => tag[0] === 'reward_amount')?.[1]
  const rewardAmountRaw = rewardAmountTag ? parseInt(rewardAmountTag, 10) : NaN
  const rewardAmount = Number.isNaN(rewardAmountRaw) ? undefined : rewardAmountRaw
  return { rewarded, rewardAmount }
}

function readTextTag(eventTags: string[][]): string | undefined {
  return eventTags.find((tag) => tag[0] === 'text')?.[1]
}


function getPreviewContent(content: string, previewTag?: string): { previewContent: string } {
  const lines = content.split('\n')
  const previewContent = previewTag ?? lines[0] ?? content.substring(0, 200)
  return { previewContent }
}

function mapNostrCategoryToLegacy(
  category: string | undefined
): 'science-fiction' | 'scientific-research' | undefined {
  if (category === 'sciencefiction') {
    return 'science-fiction'
  }
  if (category === 'research') {
    return 'scientific-research'
  }
  return undefined
}

interface ObjectIdParts {
  hash: string
  version: number
  index: number
}

function parseObjectIdPartsFromTag(params: { idTag: string; defaultVersion: number; defaultIndex: number }): ObjectIdParts {
  const parsed = parseObjectId(params.idTag)
  const hash = parsed.hash ?? params.idTag
  const version = parsed.version ?? params.defaultVersion
  const index = parsed.index ?? params.defaultIndex
  return { hash, version, index }
}

async function resolveObjectIdParts(params: {
  idTag?: string
  defaultVersion: number
  defaultIndex: number
  generateHash: () => Promise<string>
}): Promise<ObjectIdParts> {
  if (params.idTag) {
    return parseObjectIdPartsFromTag({
      idTag: params.idTag,
      defaultVersion: params.defaultVersion,
      defaultIndex: params.defaultIndex,
    })
  }

  const hash = await params.generateHash()
  return { hash, version: params.defaultVersion, index: params.defaultIndex }
}

function resolveThumbnailUrl(tags: ReturnType<typeof extractTagsFromEvent>): string {
  if (typeof tags.bannerUrl === 'string') {
    return tags.bannerUrl
  }
  if (typeof tags.pictureUrl === 'string') {
    return tags.pictureUrl
  }
  return ''
}

function parsePagesFromEventJsonTag(event: Event): Page[] | undefined {
  const jsonTag = event.tags.find((tag) => tag[0] === 'json')?.[1]
  if (!jsonTag) {
    return undefined
  }

  try {
    const parsed: unknown = JSON.parse(jsonTag)
    if (typeof parsed !== 'object' || parsed === null) {
      return undefined
    }
    const metadata = parsed as { pages?: unknown }
    if (!Array.isArray(metadata.pages)) {
      return undefined
    }
    return metadata.pages as Page[]
  } catch {
    return undefined
  }
}

function buildArticlePaymentFields(tags: ReturnType<typeof extractTagsFromEvent>): Partial<Article> {
  const result: Partial<Article> = {}
  if (tags.invoice) {
    result.invoice = tags.invoice
  }
  if (tags.paymentHash) {
    result.paymentHash = tags.paymentHash
  }
  return result
}

function buildArticleClassificationFields(params: {
  tags: ReturnType<typeof extractTagsFromEvent>
  category: 'science-fiction' | 'scientific-research' | undefined
  isPresentation: boolean
}): Partial<Article> {
  const result: Partial<Article> = {}
  if (params.category) {
    result.category = params.category
  }
  if (params.isPresentation) {
    result.isPresentation = true
  }
  if (params.tags.type === 'publication' || params.tags.type === 'author') {
    result.kindType = 'article'
  }
  return result
}

function buildArticleOptionalMetaFields(params: {
  tags: ReturnType<typeof extractTagsFromEvent>
  pages: Page[] | undefined
}): Partial<Article> {
  const result: Partial<Article> = {}
  if (params.tags.mainnetAddress) {
    result.mainnetAddress = params.tags.mainnetAddress
  }
  if (params.tags.totalSponsoring) {
    result.totalSponsoring = params.tags.totalSponsoring
  }
  if (params.tags.seriesId) {
    result.seriesId = params.tags.seriesId
  }
  if (params.tags.bannerUrl) {
    result.bannerUrl = params.tags.bannerUrl
  }
  if (params.pages && params.pages.length > 0) {
    result.pages = params.pages
  }
  return result
}

async function buildArticle(event: Event, tags: ReturnType<typeof extractTagsFromEvent>, preview: string): Promise<Article> {
  const category = mapNostrCategoryToLegacy(tags.category)
  const isPresentation = tags.type === 'author'

  const { hash, version, index } = await resolveObjectIdParts({
    ...(tags.id ? { idTag: tags.id } : {}),
    defaultVersion: tags.version ?? 0,
    defaultIndex: 0,
    generateHash: async (): Promise<string> => generateHashId({
      type: isPresentation ? 'author' : 'publication',
      pubkey: event.pubkey,
      title: tags.title ?? 'Untitled',
      preview,
      category: tags.category ?? 'sciencefiction',
      seriesId: tags.seriesId ?? '',
      bannerUrl: tags.bannerUrl ?? '',
      zapAmount: tags.zapAmount ?? 800,
    }),
  })

  const id = buildObjectId(hash, index, version)

  const pages = parsePagesFromEventJsonTag(event)

  return {
    id,
    hash,
    version,
    index,
    pubkey: event.pubkey,
    title: tags.title ?? 'Untitled',
    preview,
    content: '',
    description: tags.description ?? '', // Required field with default
    contentDescription: tags.description ?? '', // Required field with default (can be improved later)
    createdAt: event.created_at,
    zapAmount: tags.zapAmount ?? 800,
    paid: false,
    thumbnailUrl: resolveThumbnailUrl(tags), // Required field with default
    ...buildArticlePaymentFields(tags),
    ...buildArticleClassificationFields({ tags, category, isPresentation }),
    ...buildArticleOptionalMetaFields({ tags, pages }),
  }
}

/**
 * Parse purchase from zap receipt event (kind 9735)
 */
export async function parsePurchaseFromEvent(event: Event): Promise<Purchase | null> {
  try {
    const extracted = await extractPurchaseFromEvent(event)
    if (!extracted) {
      return null
    }

    // Extract hash, version, index from id
    const parsed = parseObjectId(extracted.id)
    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
    const hash = parsedHash ?? extracted.id
    const version = parsedVersion ?? 0
    const index = parsedIndex ?? 0
    const id = buildObjectId(hash, index, version)

    return {
      id,
      hash,
      version,
      index,
      payerPubkey: extracted.payerPubkey,
      articleId: extracted.articleId,
      authorPubkey: extracted.authorPubkey,
      amount: extracted.amount,
      paymentHash: extracted.paymentHash,
      createdAt: event.created_at,
      kindType: 'purchase',
    }
  } catch (e) {
    console.error('Error parsing purchase:', e)
    return null
  }
}

/**
 * Parse sponsoring from zap receipt event (kind 9735)
 */
export async function parseSponsoringFromEvent(event: Event): Promise<Sponsoring | null> {
  try {
    const extracted = await extractSponsoringFromEvent(event)
    if (!extracted) {
      return null
    }

    // Extract hash, version, index from id
    const parsed = parseObjectId(extracted.id)
    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
    const hash = parsedHash ?? extracted.id
    const version = parsedVersion ?? 0
    const index = parsedIndex ?? 0
    const id = buildObjectId(hash, index, version)

    // Extract text from tags if present
    const textTag = event.tags.find((tag) => tag[0] === 'text')?.[1]

    return {
      id,
      hash,
      version,
      index,
      payerPubkey: extracted.payerPubkey,
      authorPubkey: extracted.authorPubkey,
      amount: extracted.amount,
      paymentHash: extracted.paymentHash,
      createdAt: event.created_at,
      ...(extracted.seriesId ? { seriesId: extracted.seriesId } : {}),
      ...(extracted.articleId ? { articleId: extracted.articleId } : {}),
      ...(textTag ? { text: textTag } : {}),
      kindType: 'sponsoring',
    }
  } catch (e) {
    console.error('Error parsing sponsoring:', e)
    return null
  }
}

/**
 * Parse review tip from zap receipt event (kind 9735)
 */
export async function parseReviewTipFromEvent(event: Event): Promise<ReviewTip | null> {
  try {
    const extracted = await extractReviewTipFromEvent(event)
    if (!extracted) {
      return null
    }

    // Extract hash, version, index from id
    const parsed = parseObjectId(extracted.id)
    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
    const hash = parsedHash ?? extracted.id
    const version = parsedVersion ?? 0
    const index = parsedIndex ?? 0
    const id = buildObjectId(hash, index, version)

    // Extract text from tags if present
    const textTag = event.tags.find((tag) => tag[0] === 'text')?.[1]

    return {
      id,
      hash,
      version,
      index,
      payerPubkey: extracted.payerPubkey,
      articleId: extracted.articleId,
      reviewId: extracted.reviewId,
      reviewerPubkey: extracted.reviewerPubkey,
      authorPubkey: extracted.authorPubkey,
      amount: extracted.amount,
      paymentHash: extracted.paymentHash,
      createdAt: event.created_at,
      ...(textTag ? { text: textTag } : {}),
      kindType: 'review_tip',
    }
  } catch (e) {
    console.error('Error parsing review tip:', e)
    return null
  }
}