import directus from '~/lib/directus'
import all from '~/public/data.json'

function sluggify(str = '') {
  return (
    str
      .toLocaleLowerCase()
      .normalize('NFKC')
      .trim()
      //
      .split('.')
      .join(' ')
      .split('(')
      .join('')
      .split(')')
      .join('')
      .split('|')
      .join(' ')
      .trim()
      .split(',')
      .join('')
      .split(' ')
      .join('-')
      .split('-/-')
      .join('-')
      .split(' &amp')
      .join('')
      .split('&')
      .join('and')
      .split('/')
      .join('-')
      .replace(/\-\-+/, '-')
      .trim()
  )
}

function sanitize(str = '') {
  return (
    str
      //
      .split(' &amp')
      .join('')
      .split(' / ')
      .join('/')
      .split('/')
      .join(' / ')
      .trim()
  )
}

async function importCategories() {
  all.results.map((one) => {
    one.raw.marketplaceexhibitorcategory?.map(async (cat) => {
      const name = sanitize(cat)
      const slug = sluggify(name)
      try {
        await directus.items('categories').createOne({
          slug,
          name,
        })
      } catch (error) {}
    })
  })
}

async function importSubcategories() {
  all.results.map((one) => {
    one.raw.marketplaceexhibitorsubcategory?.map(async (cat) => {
      const name = sanitize(cat)
      const slug = sluggify(name)
      try {
        await directus.items('categories').createOne({
          slug,
          name,
        })
      } catch (error) {}
    })
  })
}

async function importCategoryStructure() {
  const { data: categories } = await directus.items('categories').readByQuery({ limit: -1 })

  all.results.map((one) => {
    one.raw.marketplaceexhibitorcategorysubcategory?.map(async (cat) => {
      const [parentTitle, catTitle] = cat.split('|')
      const catSlug = sluggify(catTitle)
      const parentSlug = sluggify(parentTitle)
      if (parentSlug) {
        try {
          const category = categories.find((c) => catSlug === c.slug)
          const parent = categories.find((c) => parentSlug === c.slug)
          await directus.items('categories').updateOne(category.id, {
            parent_id: parent.id,
          })
        } catch (error) {}
      }
    })
  })
}

async function importVendors() {
  const { data: categories } = await directus.items('categories').readByQuery({ limit: -1 })

  return Promise.all(
    all.results.map(async (one) => {
      const name = sanitize(one.raw.name)
      let slug = sluggify(name)
      const {
        data: [existingVendor],
      } = await directus.items('vendors').readByQuery({
        fields: ['slug'],
        limit: -1,
        filter: {
          slug: {
            _eq: slug,
          },
        },
      })
      let i = 1
      while (existingVendor?.slug === slug) {
        slug = sluggify(name) + '-' + i++
      }

      const categoryIds = new Set(
        one.raw.marketplaceexhibitorcategory
          ?.map((t) => sluggify(sanitize(t)))
          .map((s) => categories.filter((t) => !t.parent_id).find((t) => s === t.slug)?.id)
          .filter((s) => !!s)
      )

      const vendor = {
        slug,
        name,
        status: 'published',
        description: one.raw?.description,
        address_line_1: one.raw?.addressline1,
        address_line_2: one.raw?.addressline2,
        city: one.raw?.city,
        state: one.raw?.state,
        country: one.raw?.country,
        website: one.raw?.website,
      }
      try {
        const res = await directus.items('vendors').createOne(vendor)
        categoryIds.forEach(async (cid) => {
          await directus.items('vendors_categories').createOne({ vendors_id: res.id, categories_id: cid })
        })
      } catch (error) {}
    })
  )
}

export default async function Home() {
  // importCategories()
  // importSubcategories()
  // importCategoryStructure()
  // importVendors()

  return (
    <main>
      <h1>Import {new Date().toISOString()}</h1>
      {/* <pre>{JSON.stringify(res, null, 2)} </pre> */}
    </main>
  )
}