devtools.ts

import { loadValue } from '@logux/client'

import { busyDuring } from './busy.ts'
import { HTTPStatusError } from './errors.ts'
import { getFeed, getFeedLatestPosts, getFeeds } from './feed.ts'
import { loadFilters } from './filter.ts'
import { createDownloadTask } from './lib/download.ts'
import { loaders } from './loader/index.ts'
import {
  addPost,
  deletePost,
  getPost,
  getPosts,
  processOriginPost
} from './post.ts'
import { proxyDebug } from './request.ts'
import { router } from './router.ts'

/**
 * Create test feeds and posts for new client.
 */
export async function fillFeedsWithPosts(): Promise<void> {
  await busyDuring(async () => {
    let task = createDownloadTask()
    let feeds = await loadValue(getFeeds())
    await Promise.all(
      feeds.list.map(async feed => {
        let old = await loadValue(getPosts({ feedId: feed.id }))
        for (let post of old.list) {
          await deletePost(post.id)
        }
        let posts = await getFeedLatestPosts(feed, task).next()
        let filters = await loadFilters({ feedId: feed.id })
        for (let origin of posts) {
          let reading = filters(origin) ?? feed.reading
          if (reading !== 'delete') {
            await addPost(processOriginPost(origin, feed.id, reading))
          }
        }
      })
    )
  })
}

/**
 * Show post data in browser DevTools on opening post in popup.
 */
export function enablePostDebug(): void {
  router.subscribe(async page => {
    for (let popup of page.popups) {
      if (popup.popup === 'post') {
        let id: string | undefined
        if (popup.param.startsWith('id:')) {
          id = popup.param.slice(3)
        } else if (popup.param.startsWith('read:')) {
          id = popup.param.slice(5)
        }
        if (id) {
          let post = await loadValue(getPost(id))
          if (!post) return
          let feed = await loadValue(getFeed(post.feedId))
          let source = await loaders[feed!.loader].getPostSource(
            feed!,
            post.originId
          )
          console.log(post)
          console.log(source)
        }
      }
    }
  })
}

function decodeHeader(value: null | string): string {
  return value ? value.replaceAll('\\n', '\n') : ''
}

/**
 * Create a channel to print response's headers from the proxy.
 */
export function enableProxyDebug(): void {
  proxyDebug.set(headers => {
    console.log(
      `Proxy request:\n${decodeHeader(headers.get('x-slowreader-request'))}`
    )
    console.log(
      `Proxy response: \n${decodeHeader(headers.get('x-slowreader-response'))}`
    )
  })
}

export function printWarning(e: unknown): {
  details: unknown[]
  title: string
} {
  let title = e instanceof Error ? e.message : String(e)
  let details: unknown[] = []
  if (e instanceof Error) {
    details.push(e)
    if (e instanceof HTTPStatusError) details.push(e.response)
  }
  return { details, title }
}