import { defineNuxtModule, createResolver, useLogger, addComponent } from '@nuxt/kit'
import { readPackageJSON } from 'pkg-types'
import { pascalCase, kebabCase } from 'scule'
import { joinURL } from 'ufo'
import defu from 'defu'

export default defineNuxtModule<ToolkitOptions>({
  meta: { name: '@acme/toolkit', configKey: 'toolkit' },
  defaults: { prefix: 'Acme', apiBase: '/api' },
  async setup(options, nuxt) {
    const resolver = createResolver(import.meta.url)
    const logger = useLogger('toolkit')                       // consola

    const { version } = await readPackageJSON('nuxt', { url: nuxt.options.rootDir })
    logger.info(`host Nuxt ${version}`)                        // pkg-types

    nuxt.options.runtimeConfig.public.toolkit = defu(          // defu
      nuxt.options.runtimeConfig.public.toolkit,
      { endpoint: joinURL(options.apiBase, 'v1') },            // ufo
    )

    for (const name of ['button', 'data-table']) {
      addComponent({
        name: options.prefix + pascalCase(name),               // scule
        filePath: resolver.resolve(`./runtime/components/${kebabCase(name)}.vue`),
      })
    }
  },
})

import { genImport, genObjectFromRaw, genString } from 'knitwork'
import { relative } from 'pathe'
import { pascalCase } from 'scule'

export function routeRegistryTemplate(routes: { name: string, file: string }[], buildDir: string) {
  return [
    ...routes.map(r => genImport(`./${relative(buildDir, r.file)}`, pascalCase(r.name))),
    `export const registry = ${genObjectFromRaw(
      Object.fromEntries(routes.map(r => [genString(r.name), pascalCase(r.name)])),
    )}`,
  ].join('\n')
}

import { destr } from 'destr'
import { withQuery } from 'ufo'
import { hash } from 'ohash'
import type { Ref } from 'vue'
import { useRuntimeConfig, useAsyncData } from '#imports'

export function useToolkitSearch(query: Ref<string>) {
  const { endpoint, flags } = useRuntimeConfig().public.toolkit
  // env-provided values arrive as strings; destr coerces without throwing
  const { fuzzy } = destr<{ fuzzy?: boolean }>(flags) ?? {}
  // ohash gives a stable key, so two components asking the same question
  // share one request and one payload entry
  return useAsyncData(
    `toolkit:search:${hash({ endpoint, fuzzy })}`,
    () => $fetch<SearchHit[]>(withQuery(endpoint, { q: query.value, fuzzy })),
    { watch: [query] },
  )
}