import type { Payload, User, Where } from 'payload'

import path from 'path'
import { createLocalReq } from 'payload'
import { fileURLToPath } from 'url'

import type { NextRESTClient } from '../helpers/NextRESTClient.js'
import type {
  LocalizedPost,
  LocalizedSort,
  Nested,
  WithLocalizedRelationship,
} from './payload-types.js'

import { devUser } from '../credentials.js'

// eslint-disable-next-line payload/no-relative-monorepo-imports
import { copyDataFromLocaleHandler } from '../../packages/ui/src/utilities/copyDataFromLocale.js'
import { idToString } from '../helpers/idToString.js'
import { initPayloadInt } from '../helpers/initPayloadInt.js'
import { arrayCollectionSlug } from './collections/Array/index.js'
import { groupSlug } from './collections/Group/index.js'
import { nestedToArrayAndBlockCollectionSlug } from './collections/NestedToArrayAndBlock/index.js'
import { tabSlug } from './collections/Tab/index.js'
import {
  defaultLocale,
  defaultLocale as englishLocale,
  englishTitle,
  hungarianLocale,
  localizedDateFieldsSlug,
  localizedPostsSlug,
  localizedSortSlug,
  portugueseLocale,
  relationEnglishTitle,
  relationEnglishTitle2,
  relationshipLocalizedSlug,
  relationSpanishTitle,
  relationSpanishTitle2,
  spanishLocale,
  spanishTitle,
  withLocalizedRelSlug,
  withRequiredLocalizedFields,
} from './shared.js'

const collection = localizedPostsSlug
let payload: Payload
let restClient: NextRESTClient

const filename = fileURLToPath(import.meta.url)
const dirname = path.dirname(filename)

describe('Localization', () => {
  beforeAll(async () => {
    ;({ payload, restClient } = await initPayloadInt(dirname))
  })

  afterAll(async () => {
    if (typeof payload.db.destroy === 'function') {
      await payload.db.destroy()
    }
  })

  describe('Localization with fallback true', () => {
    let post1: LocalizedPost
    let postWithLocalizedData: LocalizedPost

    beforeAll(async () => {
      post1 = await payload.create({
        collection,
        data: {
          title: englishTitle,
        },
      })

      postWithLocalizedData = await payload.create({
        collection,
        data: {
          title: englishTitle,
        },
      })

      await payload.update({
        id: postWithLocalizedData.id,
        collection,
        data: {
          title: spanishTitle,
        },
        locale: spanishLocale,
      })
    })

    describe('Localized text', () => {
      it('create english', async () => {
        const allDocs = await payload.find({
          collection,
          where: {
            title: { equals: post1.title },
          },
        })
        expect(allDocs.docs).toContainEqual(expect.objectContaining(post1))
      })

      it('add spanish translation', async () => {
        const updated = await payload.update({
          id: post1.id,
          collection,
          data: {
            title: spanishTitle,
          },
          locale: spanishLocale,
        })

        expect(updated.title).toEqual(spanishTitle)

        const localized: any = await payload.findByID({
          id: post1.id,
          collection,
          locale: 'all',
        })

        expect(localized.title.en).toEqual(englishTitle)
        expect(localized.title.es).toEqual(spanishTitle)
      })

      it('should fallback to english translation when empty', async () => {
        await payload.update({
          id: post1.id,
          collection,
          data: {
            title: '',
          },
          locale: spanishLocale,
        })

        const retrievedInEnglish = await payload.findByID({
          id: post1.id,
          collection,
        })

        expect(retrievedInEnglish.title).toEqual(englishTitle)

        const localizedFallback: any = await payload.findByID({
          id: post1.id,
          collection,
          locale: 'all',
        })

        expect(localizedFallback.title.en).toEqual(englishTitle)
        expect(localizedFallback.title.es).toEqual('')
      })

      it('should fallback to spanish translation when empty and locale-specific fallback is provided', async () => {
        const localizedFallback: any = await payload.findByID({
          id: postWithLocalizedData.id,
          collection,
          locale: portugueseLocale,
        })

        expect(localizedFallback.title).toEqual(spanishTitle)
      })

      it('should respect fallback none', async () => {
        const localizedFallback: any = await payload.findByID({
          id: postWithLocalizedData.id,
          collection,
          locale: portugueseLocale,
          // @ts-expect-error - testing fallbackLocale 'none' for backwards compatibility though the correct type here is `false`
          fallbackLocale: 'none',
        })

        expect(localizedFallback.title).not.toBeDefined()
      })

      describe('fallback locales', () => {
        let englishData
        let spanishData
        let localizedDoc

        beforeAll(async () => {
          englishData = {
            localizedCheckbox: false,
          }
          spanishData = {
            localizedCheckbox: true,
            title: 'spanish title',
          }

          localizedDoc = await payload.create({
            collection: localizedPostsSlug,
            data: englishData,
            locale: englishLocale,
          })

          await payload.update({
            id: localizedDoc.id,
            collection: localizedPostsSlug,
            data: spanishData,
            locale: spanishLocale,
          })
          await payload.update({
            id: localizedDoc.id,
            collection: localizedPostsSlug,
            data: { localizedCheckbox: true },
            locale: portugueseLocale,
          })
        })

        it('should return localized fields using fallbackLocale specified in the requested locale config', async () => {
          const portugueseDoc = await payload.findByID({
            id: localizedDoc.id,
            collection: localizedPostsSlug,
            locale: portugueseLocale,
          })

          expect(portugueseDoc.title).toStrictEqual(spanishData.title)
          expect(portugueseDoc.localizedCheckbox).toStrictEqual(true)
        })
      })

      describe('querying', () => {
        let localizedPost: LocalizedPost
        beforeEach(async () => {
          const { id } = await payload.create({
            collection,
            data: {
              title: englishTitle,
            },
          })

          localizedPost = await payload.update({
            id,
            collection,
            data: {
              title: spanishTitle,
            },
            locale: spanishLocale,
          })
        })

        it('unspecified locale returns default', async () => {
          const localized = await payload.findByID({
            id: localizedPost.id,
            collection,
          })

          expect(localized.title).toEqual(englishTitle)
        })

        it('specific locale - same as default', async () => {
          const localized = await payload.findByID({
            id: localizedPost.id,
            collection,
            locale: defaultLocale,
          })

          expect(localized.title).toEqual(englishTitle)
        })

        it('specific locale - not default', async () => {
          const localized = await payload.findByID({
            id: localizedPost.id,
            collection,
            locale: spanishLocale,
          })

          expect(localized.title).toEqual(spanishTitle)
        })

        it('all locales', async () => {
          const localized: any = await payload.findByID({
            id: localizedPost.id,
            collection,
            locale: 'all',
          })

          expect(localized.title.en).toEqual(englishTitle)
          expect(localized.title.es).toEqual(spanishTitle)
        })

        it('rest all locales with all', async () => {
          const response = await restClient.GET(`/${collection}/${localizedPost.id}`, {
            query: {
              locale: 'all',
            },
          })

          expect(response.status).toBe(200)
          const localized = await response.json()

          expect(localized.title.en).toEqual(englishTitle)
          expect(localized.title.es).toEqual(spanishTitle)
        })

        it('rest all locales with asterisk', async () => {
          const response = await restClient.GET(`/${collection}/${localizedPost.id}`, {
            query: {
              locale: '*',
            },
          })

          expect(response.status).toBe(200)
          const localized = await response.json()

          expect(localized.title.en).toEqual(englishTitle)
          expect(localized.title.es).toEqual(spanishTitle)
        })

        it('by localized field value - default locale', async () => {
          const result = await payload.find({
            collection,
            where: {
              title: {
                equals: englishTitle,
              },
            },
          })

          expect(result.docs.map(({ id }) => id)).toContain(localizedPost.id)
        })

        it('by localized field value - alternate locale', async () => {
          const result = await payload.find({
            collection,
            locale: spanishLocale,
            where: {
              title: {
                equals: spanishTitle,
              },
            },
          })

          expect(result.docs.map(({ id }) => id)).toContain(localizedPost.id)
        })

        it('by localized field value - opposite locale???', async () => {
          const result = await payload.find({
            collection,
            locale: 'all',
            where: {
              'title.es': {
                equals: spanishTitle,
              },
            },
          })

          expect(result.docs.map(({ id }) => id)).toContain(localizedPost.id)
        })

        it('by localized field value with sorting', async () => {
          const doc_1 = await payload.create({ collection, data: { title: 'word_b' } })
          const doc_2 = await payload.create({ collection, data: { title: 'word_a' } })
          const doc_3 = await payload.create({ collection, data: { title: 'word_c' } })

          await payload.create({ collection, data: { title: 'others_c' } })

          const { docs } = await payload.find({
            collection,
            sort: 'title',
            where: {
              title: {
                like: 'word',
              },
            },
          })

          expect(docs).toHaveLength(3)
          expect(docs[0].id).toBe(doc_2.id)
          expect(docs[1].id).toBe(doc_1.id)
          expect(docs[2].id).toBe(doc_3.id)
        })

        if (['mongodb'].includes(process.env.PAYLOAD_DATABASE)) {
          describe('Localized sorting', () => {
            let localizedAccentPostOne: LocalizedPost
            let localizedAccentPostTwo: LocalizedPost
            beforeEach(async () => {
              localizedAccentPostOne = await payload.create({
                collection,
                data: {
                  title: 'non accent post',
                  localizedDescription: 'something',
                },
                locale: englishLocale,
              })

              localizedAccentPostTwo = await payload.create({
                collection,
                data: {
                  title: 'accent post',
                  localizedDescription: 'veterinarian',
                },
                locale: englishLocale,
              })

              await payload.update({
                id: localizedAccentPostOne.id,
                collection,
                data: {
                  title: 'non accent post',
                  localizedDescription: 'valami',
                },
                locale: hungarianLocale,
              })

              await payload.update({
                id: localizedAccentPostTwo.id,
                collection,
                data: {
                  title: 'accent post',
                  localizedDescription: 'állatorvos',
                },
                locale: hungarianLocale,
              })
            })

            it('should sort alphabetically even with accented letters', async () => {
              const sortByDescriptionQuery = await payload.find({
                collection,
                sort: 'description',
                where: {
                  title: {
                    like: 'accent',
                  },
                },
                locale: hungarianLocale,
              })

              expect(sortByDescriptionQuery.docs[0].id).toEqual(localizedAccentPostTwo.id)
            })
          })
        }
      })
    })

    describe('Localized date', () => {
      it('can create a localized date', async () => {
        const document = await payload.create({
          collection: localizedDateFieldsSlug,
          data: {
            localizedDate: new Date().toISOString(),
            date: new Date().toISOString(),
          },
        })
        expect(document.localizedDate).toBeTruthy()
      })

      it('data is typed as string', async () => {
        const document = await payload.create({
          collection: localizedDateFieldsSlug,
          data: {
            localizedDate: new Date().toISOString(),
            date: new Date().toISOString(),
          },
        })

        expect(typeof document.localizedDate).toBe('string')
        expect(typeof document.date).toBe('string')
      })
    })

    describe('Localized Sort Count', () => {
      const expectedTotalDocs = 5
      const posts: LocalizedSort[] = []
      beforeAll(async () => {
        for (let i = 1; i <= expectedTotalDocs; i++) {
          const post = await payload.create({
            collection: localizedSortSlug,
            data: {
              date: new Date().toISOString(),
              title: `EN ${i}`,
            },
            locale: englishLocale,
          })

          posts.push(post)

          await payload.update({
            id: post.id,
            collection: localizedSortSlug,
            data: {
              date: new Date().toISOString(),
              title: `ES ${i}`,
            },
            locale: spanishLocale,
          })
        }
      })

      it('should have correct totalDocs when unsorted', async () => {
        const simpleQuery = await payload.find({
          collection: localizedSortSlug,
        })
        const sortByIdQuery = await payload.find({
          collection: localizedSortSlug,
          sort: 'id',
        })

        expect(simpleQuery.totalDocs).toEqual(expectedTotalDocs)
        expect(sortByIdQuery.totalDocs).toEqual(expectedTotalDocs)
      })

      // https://github.com/payloadcms/payload/issues/4889
      it('should have correct totalDocs when sorted by localized fields', async () => {
        const sortByTitleQuery = await payload.find({
          collection: localizedSortSlug,
          sort: 'title',
        })
        const sortByDateQuery = await payload.find({
          collection: localizedSortSlug,
          sort: 'date',
        })

        console.log({ sortByTitleQuery })

        expect(sortByTitleQuery.totalDocs).toEqual(expectedTotalDocs)
        expect(sortByDateQuery.totalDocs).toEqual(expectedTotalDocs)
      })

      it('should return correct order when sorted by localized fields', async () => {
        const { docs: docsAsc } = await payload.find({
          collection: localizedSortSlug,
          sort: 'title',
        })
        docsAsc.forEach((doc, i) => {
          expect(posts[i].id).toBe(doc.id)
        })

        const { docs: docsDesc } = await payload.find({
          collection: localizedSortSlug,
          sort: '-title',
        })
        docsDesc.forEach((doc, i) => {
          expect(posts.at(posts.length - i - 1).id).toBe(doc.id)
        })

        // Test with words
        const randomWords = [
          'sunset',
          'whisper',
          'lighthouse',
          'harmony',
          'crystal',
          'thunder',
          'meadow',
          'voyage',
          'echo',
          'quicksand',
        ]

        const randomWordsSpanish = [
          'atardecer',
          'susurro',
          'faro',
          'armonía',
          'cristal',
          'trueno',
          'pradera',
          'viaje',
          'eco',
          'arenas movedizas',
        ]

        expect(randomWords).toHaveLength(randomWordsSpanish.length)

        const randomWordsPosts: (number | string)[] = []

        for (let i = 0; i < randomWords.length; i++) {
          const en = randomWords[i]
          const post = await payload.create({ collection: 'localized-sort', data: { title: en } })
          const es = randomWordsSpanish[i]
          await payload.update({
            collection: 'localized-sort',
            data: { title: es },
            id: post.id,
            locale: 'es',
          })

          randomWordsPosts.push(post.id)
        }

        const ascSortedWordsEn = randomWords.toSorted((a, b) => a.localeCompare(b))
        const descSortedWordsEn = randomWords.toSorted((a, b) => b.localeCompare(a))

        const q = { id: { in: randomWordsPosts } }

        const { docs: randomWordsEnAsc } = await payload.find({
          collection: localizedSortSlug,
          sort: 'title',
          where: q,
        })
        randomWordsEnAsc.forEach((doc, i) => {
          expect(ascSortedWordsEn[i]).toBe(doc.title)
        })

        const { docs: randomWordsEnDesc } = await payload.find({
          collection: localizedSortSlug,
          sort: '-title',
          where: q,
        })

        randomWordsEnDesc.forEach((doc, i) => {
          expect(descSortedWordsEn[i]).toBe(doc.title)
        })

        // Test sorting for Spanish locale
        const ascSortedWordsEs = randomWordsSpanish.toSorted((a, b) => a.localeCompare(b))
        const descSortedWordsEs = randomWordsSpanish.toSorted((a, b) => b.localeCompare(a))

        // Fetch sorted words in Spanish (ascending)
        const { docs: randomWordsEsAsc } = await payload.find({
          collection: localizedSortSlug,
          sort: 'title',
          where: q,
          locale: 'es',
        })

        randomWordsEsAsc.forEach((doc, i) => {
          expect(ascSortedWordsEs[i]).toBe(doc.title)
        })

        // Fetch sorted words in Spanish (descending)
        const { docs: randomWordsEsDesc } = await payload.find({
          collection: localizedSortSlug,
          sort: '-title',
          where: q,
          locale: 'es',
        })

        randomWordsEsDesc.forEach((doc, i) => {
          expect(descSortedWordsEs[i]).toBe(doc.title)
        })
      })
    })

    describe('Localized Relationship', () => {
      let localizedRelation: LocalizedPost
      let localizedRelation2: LocalizedPost
      let withRelationship: WithLocalizedRelationship

      beforeAll(async () => {
        localizedRelation = await createLocalizedPost({
          title: {
            [defaultLocale]: relationEnglishTitle,
            [spanishLocale]: relationSpanishTitle,
          },
        })
        localizedRelation2 = await createLocalizedPost({
          title: {
            [defaultLocale]: relationEnglishTitle2,
            [spanishLocale]: relationSpanishTitle2,
          },
        })

        withRelationship = await payload.create({
          collection: withLocalizedRelSlug,
          data: {
            localizedRelationHasManyField: [localizedRelation.id, localizedRelation2.id],
            localizedRelationMultiRelationTo: {
              relationTo: localizedPostsSlug,
              value: localizedRelation.id,
            },
            localizedRelationMultiRelationToHasMany: [
              { relationTo: localizedPostsSlug, value: localizedRelation.id },
              { relationTo: localizedPostsSlug, value: localizedRelation2.id },
            ],
            localizedRelationship: localizedRelation.id,
          },
        })
      })

      describe('regular relationship', () => {
        it('can query localized relationship', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationship.title': {
                equals: localizedRelation.title,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)
        })

        it('specific locale', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            locale: spanishLocale,
            where: {
              'localizedRelationship.title': {
                equals: relationSpanishTitle,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)
        })

        it('all locales', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            locale: 'all',
            where: {
              'localizedRelationship.title.es': {
                equals: relationSpanishTitle,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)
        })

        it('populates relationships with all locales', async () => {
          // the relationship fields themselves are localized on this collection
          const result: any = await payload.find({
            collection: relationshipLocalizedSlug,
            depth: 1,
            locale: 'all',
          })

          expect(result.docs[0].relationship.en.id).toBeDefined()
          expect(result.docs[0].relationshipHasMany.en[0].id).toBeDefined()
          expect(result.docs[0].relationMultiRelationTo.en.value.id).toBeDefined()
          expect(result.docs[0].relationMultiRelationToHasMany.en[0].value.id).toBeDefined()
          expect(result.docs[0].arrayField.en[0].nestedRelation.id).toBeDefined()
        })
      })

      describe('relationship - hasMany', () => {
        it('default locale', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationHasManyField.title': {
                equals: localizedRelation.title,
              },
            },
          })

          expect(result.docs.map(({ id }) => id)).toContain(withRelationship.id)

          // Second relationship
          const result2 = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationHasManyField.title': {
                equals: localizedRelation2.title,
              },
            },
          })

          expect(result2.docs.map(({ id }) => id)).toContain(withRelationship.id)
        })

        it('specific locale', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            locale: spanishLocale,
            where: {
              'localizedRelationHasManyField.title': {
                equals: relationSpanishTitle,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)

          // Second relationship
          const result2 = await payload.find({
            collection: withLocalizedRelSlug,
            locale: spanishLocale,
            where: {
              'localizedRelationHasManyField.title': {
                equals: relationSpanishTitle2,
              },
            },
          })

          expect(result2.docs[0].id).toEqual(withRelationship.id)
        })

        it('relationship population uses locale', async () => {
          const result = await payload.findByID({
            id: withRelationship.id,
            collection: withLocalizedRelSlug,
            depth: 1,
            locale: spanishLocale,
          })
          expect((result.localizedRelationship as LocalizedPost).title).toEqual(
            relationSpanishTitle,
          )
        })

        it('all locales', async () => {
          const queryRelation = (where: Where) => {
            return payload.find({
              collection: withLocalizedRelSlug,
              locale: 'all',
              where,
            })
          }

          const result = await queryRelation({
            'localizedRelationHasManyField.title.en': {
              equals: relationEnglishTitle,
            },
          })

          expect(result.docs.map(({ id }) => id)).toContain(withRelationship.id)

          // First relationship - spanish
          const result2 = await queryRelation({
            'localizedRelationHasManyField.title.es': {
              equals: relationSpanishTitle,
            },
          })

          expect(result2.docs.map(({ id }) => id)).toContain(withRelationship.id)

          // Second relationship - english
          const result3 = await queryRelation({
            'localizedRelationHasManyField.title.en': {
              equals: relationEnglishTitle2,
            },
          })

          expect(result3.docs.map(({ id }) => id)).toContain(withRelationship.id)

          // Second relationship - spanish
          const result4 = await queryRelation({
            'localizedRelationHasManyField.title.es': {
              equals: relationSpanishTitle2,
            },
          })

          expect(result4.docs[0].id).toEqual(withRelationship.id)
        })
      })

      describe('relationTo multi', () => {
        it('by id', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationMultiRelationTo.value': {
                equals: localizedRelation.id,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)

          // Second relationship
          const result2 = await payload.find({
            collection: withLocalizedRelSlug,
            locale: spanishLocale,
            where: {
              'localizedRelationMultiRelationTo.value': {
                equals: localizedRelation.id,
              },
            },
          })

          expect(result2.docs[0].id).toEqual(withRelationship.id)
        })
      })

      describe('relationTo multi hasMany', () => {
        it('by id', async () => {
          const result = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationMultiRelationToHasMany.value': {
                equals: localizedRelation.id,
              },
            },
          })

          expect(result.docs[0].id).toEqual(withRelationship.id)

          // First relationship - spanish locale
          const result2 = await payload.find({
            collection: withLocalizedRelSlug,
            locale: spanishLocale,
            where: {
              'localizedRelationMultiRelationToHasMany.value': {
                equals: localizedRelation.id,
              },
            },
          })

          expect(result2.docs[0].id).toEqual(withRelationship.id)

          // Second relationship
          const result3 = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationMultiRelationToHasMany.value': {
                equals: localizedRelation2.id,
              },
            },
          })

          expect(result3.docs[0].id).toEqual(withRelationship.id)

          // Second relationship - spanish locale
          const result4 = await payload.find({
            collection: withLocalizedRelSlug,
            where: {
              'localizedRelationMultiRelationToHasMany.value': {
                equals: localizedRelation2.id,
              },
            },
          })

          expect(result4.docs[0].id).toEqual(withRelationship.id)
        })
      })
    })

    describe('Localized - arrays with nested localized fields', () => {
      it('should allow moving rows and retain existing row locale data', async () => {
        const globalArray: any = await payload.findGlobal({
          slug: 'global-array',
        })

        const reversedArrayRows = [...globalArray.array].reverse()

        const updatedGlobal = await payload.updateGlobal({
          slug: 'global-array',
          data: {
            array: reversedArrayRows,
          },
          locale: 'all',
        })

        expect(updatedGlobal.array[0].text.en).toStrictEqual('test en 2')
        expect(updatedGlobal.array[0].text.es).toStrictEqual('test es 2')
      })
    })

    describe('Localized - required', () => {
      it('should update without passing all required fields', async () => {
        const newDoc = await payload.create({
          collection: withRequiredLocalizedFields,
          data: {
            nav: {
              layout: [
                {
                  blockType: 'text',
                  text: 'laiwejfilwaje',
                },
              ],
            },
            title: 'hello',
          },
        })

        await payload.update({
          id: newDoc.id,
          collection: withRequiredLocalizedFields,
          data: {
            nav: {
              layout: [
                {
                  blockType: 'number',
                  number: 12,
                },
              ],
            },
            title: 'en espanol, big bird',
          },
          locale: spanishLocale,
        })

        const updatedDoc = await payload.update({
          id: newDoc.id,
          collection: withRequiredLocalizedFields,
          data: {
            title: 'hello x2',
          },
        })

        expect(updatedDoc.nav.layout[0].blockType).toStrictEqual('text')

        const spanishDoc = await payload.findByID({
          id: newDoc.id,
          collection: withRequiredLocalizedFields,
          locale: spanishLocale,
        })

        expect(spanishDoc.nav.layout[0].blockType).toStrictEqual('number')
      })
    })

    describe('Localized - GraphQL', () => {
      let token
      let client

      it('should allow user to login and retrieve populated localized field', async () => {
        const query = `mutation {
        loginUser(email: "dev@payloadcms.com", password: "test") {
          token
          user {
            relation {
              title
            }
          }
        }
      }`

        const { data } = await restClient
          .GRAPHQL_POST({
            body: JSON.stringify({ query }),
            query: { locale: 'en' },
          })
          .then((res) => res.json())
        const result = data.loginUser

        expect(typeof result.token).toStrictEqual('string')
        expect(typeof result.user.relation.title).toStrictEqual('string')

        token = result.token
      })

      it('should allow retrieval of populated localized fields within meUser', async () => {
        const query = `query {
        meUser {
          user {
            id
            relation {
              title
            }
          }
        }
      }`

        const { data } = await restClient
          .GRAPHQL_POST({
            body: JSON.stringify({ query }),
            headers: {
              Authorization: `JWT ${token}`,
            },
            query: { locale: 'en' },
          })
          .then((res) => res.json())
        const result = data.meUser

        expect(typeof result.user.relation.title).toStrictEqual('string')
      })

      it('should create and update collections', async () => {
        const create = `mutation {
        createLocalizedPost(
          data: {
            title: "${englishTitle}"
          }
          locale: ${defaultLocale}
        ) {
          id
          title
        }
      }`

        const { data } = await restClient
          .GRAPHQL_POST({
            body: JSON.stringify({ query: create }),
            headers: {
              Authorization: `JWT ${token}`,
            },
            query: { locale: 'en' },
          })
          .then((res) => res.json())
        const createResult = data.createLocalizedPost

        const update = `mutation {
        updateLocalizedPost(
          id: ${payload.db.defaultIDType === 'number' ? createResult.id : `"${createResult.id}"`},
          data: {
            title: "${spanishTitle}"
          }
          locale: ${spanishLocale}
        ) {
          title
        }
      }`

        const { data: updateData } = await restClient
          .GRAPHQL_POST({
            body: JSON.stringify({ query: update }),
            headers: {
              Authorization: `JWT ${token}`,
            },
            query: { locale: 'en' },
          })
          .then((res) => res.json())
        const updateResult = updateData.updateLocalizedPost

        const result = await payload.findByID({
          id: createResult.id,
          collection: localizedPostsSlug,
          locale: 'all',
        })

        expect(createResult.title).toStrictEqual(englishTitle)
        expect(updateResult.title).toStrictEqual(spanishTitle)
        expect(result.title[defaultLocale]).toStrictEqual(englishTitle)
        expect(result.title[spanishLocale]).toStrictEqual(spanishTitle)
      })

      it('should query multiple locales', async () => {
        const englishDoc = await payload.create({
          collection: localizedPostsSlug,
          data: {
            title: englishTitle,
          },
          locale: defaultLocale,
        })
        const spanishDoc = await payload.create({
          collection: localizedPostsSlug,
          data: {
            title: spanishTitle,
          },
          locale: spanishLocale,
        })
        const query = `
      {
        es: LocalizedPost(id: ${idToString(spanishDoc.id, payload)}, locale: es) {
          title
        }
        en: LocalizedPost(id: ${idToString(englishDoc.id, payload)}, locale: en) {
          title
        }
      }
      `

        const { data: multipleLocaleData } = await restClient
          .GRAPHQL_POST({
            body: JSON.stringify({ query }),
            headers: {
              Authorization: `JWT ${token}`,
            },
            query: { locale: 'en' },
          })
          .then((res) => res.json())

        const { en, es } = multipleLocaleData

        expect(en.title).toStrictEqual(englishTitle)
        expect(es.title).toStrictEqual(spanishTitle)
      })
    })

    describe('Localized - Arrays', () => {
      let docID

      beforeAll(async () => {
        const englishDoc = await payload.create({
          collection: arrayCollectionSlug,
          data: {
            items: [
              {
                text: englishTitle,
              },
            ],
          },
        })

        docID = englishDoc.id
      })

      it('should use default locale as fallback', async () => {
        const spanishDoc = await payload.findByID({
          id: docID,
          collection: arrayCollectionSlug,
          locale: spanishLocale,
        })

        expect(spanishDoc.items[0].text).toStrictEqual(englishTitle)
      })

      it('should use empty array as value', async () => {
        const updatedSpanishDoc = await payload.update({
          id: docID,
          collection: arrayCollectionSlug,
          data: {
            items: [],
          },
          fallbackLocale: 'none',
          locale: spanishLocale,
        })

        expect(updatedSpanishDoc.items).toStrictEqual([])
      })

      it('should use fallback value if setting null', async () => {
        await payload.update({
          id: docID,
          collection: arrayCollectionSlug,
          data: {
            items: [],
          },
          locale: spanishLocale,
        })

        const updatedSpanishDoc = await payload.update({
          id: docID,
          collection: arrayCollectionSlug,
          data: {
            items: null,
          },
          locale: spanishLocale,
        })

        // should return the value of the fallback locale
        expect(updatedSpanishDoc.items[0].text).toStrictEqual(englishTitle)
      })
    })

    describe('Localized - Field Paths', () => {
      it('should allow querying by non-localized field names ending in a locale', async () => {
        await payload.update({
          id: post1.id,
          collection,
          data: {
            children: post1.id,
            group: {
              children: 'something',
            },
          },
        })

        const { docs: relationshipDocs } = await restClient
          .GET(`/${collection}`, {
            query: {
              where: {
                children: {
                  in: post1.id,
                },
              },
            },
          })
          .then((res) => res.json())

        expect(relationshipDocs.map(({ id }) => id)).toContain(post1.id)

        const { docs: nestedFieldDocs } = await restClient
          .GET(`/${collection}`, {
            query: {
              where: {
                'group.children': {
                  contains: 'some',
                },
              },
            },
          })
          .then((res) => res.json())

        expect(nestedFieldDocs.map(({ id }) => id)).toContain(post1.id)
      })
    })

    describe('Nested To Array And Block', () => {
      it('should be equal to the created document', async () => {
        const { id, blocks } = await payload.create({
          collection: nestedToArrayAndBlockCollectionSlug,
          data: {
            blocks: [
              {
                array: [
                  {
                    text: 'english',
                    textNotLocalized: 'test',
                  },
                ],
                blockType: 'block',
              },
            ],
          },
          locale: defaultLocale,
        })

        await payload.update({
          id,
          collection: nestedToArrayAndBlockCollectionSlug,
          data: {
            blocks: (blocks as { array: { text: string }[] }[]).map((block) => ({
              ...block,
              array: block.array.map((item) => ({ ...item, text: 'spanish' })),
            })),
          },
          locale: spanishLocale,
        })

        const docDefaultLocale = await payload.findByID({
          id,
          collection: nestedToArrayAndBlockCollectionSlug,
          locale: defaultLocale,
        })

        const docSpanishLocale = await payload.findByID({
          id,
          collection: nestedToArrayAndBlockCollectionSlug,
          locale: spanishLocale,
        })

        const rowDefault = docDefaultLocale.blocks[0].array[0]
        const rowSpanish = docSpanishLocale.blocks[0].array[0]

        expect(rowDefault.text).toEqual('english')
        expect(rowDefault.textNotLocalized).toEqual('test')
        expect(rowSpanish.text).toEqual('spanish')
        expect(rowSpanish.textNotLocalized).toEqual('test')
      })
    })

    describe('Duplicate Collection', () => {
      it('should duplicate localized document', async () => {
        const localizedPost = await payload.create({
          collection: localizedPostsSlug,
          data: {
            localizedCheckbox: true,
            title: englishTitle,
          },
          locale: defaultLocale,
        })

        const id = localizedPost.id.toString()

        await payload.update({
          id,
          collection: localizedPostsSlug,
          data: {
            localizedCheckbox: false,
            title: spanishTitle,
          },
          locale: spanishLocale,
        })

        const result = await payload.duplicate({
          id,
          collection: localizedPostsSlug,
          locale: defaultLocale,
        })

        const allLocales = await payload.findByID({
          id: result.id,
          collection: localizedPostsSlug,
          locale: 'all',
        })

        // check fields
        expect(result.title).toStrictEqual(englishTitle)

        expect(allLocales.title.es).toStrictEqual(spanishTitle)

        expect(allLocales.localizedCheckbox.en).toBeTruthy()
        expect(allLocales.localizedCheckbox.es).toBeFalsy()
      })

      it('should duplicate with localized blocks', async () => {
        // This test covers a few things:
        // 1. make sure we can duplicate localized blocks
        //    - in relational DBs, we need to create new block / array IDs
        //    - and this needs to be done recursively for all block / array fields
        // 2. make sure localized arrays / blocks work inside of localized groups / tabs
        //    - this is covered with myTab.group.nestedArray2
        // 3. the field schema for `nav` is within an unnamed tab, which tests that we
        //    properly recursively loop through all field structures / types

        const englishText = 'english'
        const spanishText = 'spanish'
        const doc = await payload.create({
          collection: withRequiredLocalizedFields,
          data: {
            nav: {
              layout: [
                {
                  blockType: 'text',
                  text: englishText,
                  nestedArray: [
                    {
                      text: 'hello',
                      l2: [
                        {
                          l3: [
                            {
                              l4: [
                                {
                                  superNestedText: 'hello',
                                },
                              ],
                            },
                          ],
                        },
                      ],
                    },
                    {
                      text: 'goodbye',
                      l2: [
                        {
                          l3: [
                            {
                              l4: [
                                {
                                  superNestedText: 'goodbye',
                                },
                              ],
                            },
                          ],
                        },
                      ],
                    },
                  ],
                },
              ],
            },
            myTab: {
              text: 'hello',
              group: {
                nestedText: 'hello',
                nestedArray2: [
                  {
                    nestedText: 'hello',
                  },
                  {
                    nestedText: 'goodbye',
                  },
                ],
              },
            },
            title: 'hello',
          },
          locale: defaultLocale,
        })

        await payload.update({
          id: doc.id,
          collection: withRequiredLocalizedFields,
          data: {
            nav: {
              layout: [
                {
                  blockType: 'text',
                  text: spanishText,
                  nestedArray: [
                    {
                      text: 'hola',
                      l2: [
                        {
                          l3: [
                            {
                              l4: [
                                {
                                  superNestedText: 'hola',
                                },
                              ],
                            },
                          ],
                        },
                      ],
                    },
                    {
                      text: 'adios',
                      l2: [
                        {
                          l3: [
                            {
                              l4: [
                                {
                                  superNestedText: 'adios',
                                },
                              ],
                            },
                          ],
                        },
                      ],
                    },
                  ],
                },
              ],
            },
            title: 'hello',
            myTab: {
              text: 'hola',
              group: {
                nestedText: 'hola',
                nestedArray2: [
                  {
                    nestedText: 'hola',
                  },
                  {
                    nestedText: 'adios',
                  },
                ],
              },
            },
          },
          locale: spanishLocale,
        })

        const result = await payload.duplicate({
          id: doc.id,
          collection: withRequiredLocalizedFields,
          locale: defaultLocale,
        })

        const allLocales = await payload.findByID({
          id: result.id,
          collection: withRequiredLocalizedFields,
          locale: 'all',
        })

        // check fields
        expect(result.nav.layout[0].text).toStrictEqual(englishText)

        expect(allLocales.nav.layout.en[0].text).toStrictEqual(englishText)
        expect(allLocales.nav.layout.es[0].text).toStrictEqual(spanishText)

        expect(allLocales.myTab.group.en.nestedText).toStrictEqual('hello')
        expect(allLocales.myTab.group.en.nestedArray2[0].nestedText).toStrictEqual('hello')
        expect(allLocales.myTab.group.en.nestedArray2[1].nestedText).toStrictEqual('goodbye')

        expect(allLocales.myTab.group.es.nestedText).toStrictEqual('hola')
        expect(allLocales.myTab.group.es.nestedArray2[0].nestedText).toStrictEqual('hola')
        expect(allLocales.myTab.group.es.nestedArray2[1].nestedText).toStrictEqual('adios')
      })
    })

    describe('Localized group and tabs', () => {
      it('should properly create/update/read localized group field', async () => {
        const result = await payload.create({
          collection: groupSlug,
          data: {
            groupLocalized: {
              title: 'hello en',
            },
          },
          locale: englishLocale,
        })

        expect(result.groupLocalized?.title).toBe('hello en')

        await payload.update({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            groupLocalized: {
              title: 'hello es',
            },
          },
        })

        const docEn = await payload.findByID({
          collection: groupSlug,
          locale: englishLocale,
          id: result.id,
        })
        const docEs = await payload.findByID({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.groupLocalized.title).toBe('hello en')
        expect(docEs.groupLocalized.title).toBe('hello es')
      })

      it('should properly create/update/read localized field inside of group', async () => {
        const result = await payload.create({
          collection: groupSlug,
          locale: englishLocale,
          data: {
            group: {
              title: 'hello en',
            },
          },
        })

        expect(result.group.title).toBe('hello en')

        await payload.update({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            group: {
              title: 'hello es',
            },
          },
        })

        const docEn = await payload.findByID({
          collection: groupSlug,
          locale: englishLocale,
          id: result.id,
        })
        const docEs = await payload.findByID({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.group.title).toBe('hello en')
        expect(docEs.group.title).toBe('hello es')
      })

      it('should properly create/update/read deep localized field inside of group', async () => {
        const result = await payload.create({
          collection: groupSlug,
          locale: englishLocale,
          data: {
            deep: {
              blocks: [
                {
                  blockType: 'first',
                  title: 'hello en',
                },
              ],
              array: [{ title: 'hello en' }],
            },
          },
        })

        expect(result.deep.array[0].title).toBe('hello en')

        await payload.update({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            deep: {
              blocks: [
                {
                  blockType: 'first',
                  title: 'hello es',
                  id: result.deep.blocks[0].id,
                },
              ],
              array: [
                {
                  id: result.deep.array[0].id,
                  title: 'hello es',
                },
              ],
            },
          },
        })

        const docEn = await payload.findByID({
          collection: groupSlug,
          locale: englishLocale,
          id: result.id,
        })
        const docEs = await payload.findByID({
          collection: groupSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.deep.array[0].title).toBe('hello en')
        expect(docEn.deep.blocks[0].title).toBe('hello en')
        expect(docEs.deep.array[0].title).toBe('hello es')
        expect(docEs.deep.blocks[0].title).toBe('hello es')
      })

      it('should create/updated/read localized group with row field', async () => {
        const doc = await payload.create({
          collection: 'groups',
          data: {
            groupLocalizedRow: {
              text: 'hello world',
            },
          },
          locale: 'en',
        })

        expect(doc.groupLocalizedRow.text).toBe('hello world')

        const docES = await payload.update({
          collection: 'groups',
          data: {
            groupLocalizedRow: {
              text: 'hola world or something',
            },
          },
          locale: 'es',
          id: doc.id,
        })

        expect(docES.groupLocalizedRow.text).toBe('hola world or something')

        // check if docES didnt break EN
        const docEN = await payload.findByID({ collection: 'groups', id: doc.id, locale: 'en' })
        expect(docEN.groupLocalizedRow.text).toBe('hello world')

        const all = await payload.findByID({ collection: 'groups', id: doc.id, locale: 'all' })

        expect(all.groupLocalizedRow.en.text).toBe('hello world')
        expect(all.groupLocalizedRow.es.text).toBe('hola world or something')
      })

      it('should not crash on empty localized tab', async () => {
        const result = await payload.create({
          collection: tabSlug,
          locale: englishLocale,
          data: {
            tabLocalized: {},
          },
        })

        expect(result).toBeTruthy()
      })

      it('should properly create/update/read array field inside localized tab field', async () => {
        const result = await payload.create({
          collection: tabSlug,
          locale: englishLocale,
          data: {
            tabLocalized: {
              title: 'hello en',
            },
          },
        })

        expect(result.tabLocalized?.title).toBe('hello en')

        await payload.update({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            tabLocalized: {
              title: 'hello es',
            },
          },
        })

        const docEn = await payload.findByID({
          collection: tabSlug,
          locale: englishLocale,
          id: result.id,
        })

        const docEs = await payload.findByID({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.tabLocalized.title).toBe('hello en')
        expect(docEs.tabLocalized.title).toBe('hello es')
      })

      it('should properly create/update/read localized tab field', async () => {
        const result = await payload.create({
          collection: tabSlug,
          locale: englishLocale,
          data: {
            tabLocalized: {
              array: [
                {
                  title: 'hello en',
                },
              ],
            },
          },
        })

        expect(result.tabLocalized.array[0].title).toBe('hello en')

        await payload.update({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            tabLocalized: {
              array: [{ title: 'hello es' }],
            },
          },
        })

        const docEn = await payload.findByID({
          collection: tabSlug,
          locale: englishLocale,
          id: result.id,
        })

        const docEs = await payload.findByID({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.tabLocalized.array[0].title).toBe('hello en')
        expect(docEs.tabLocalized.array[0].title).toBe('hello es')
      })

      it('should properly create/update/read localized field inside of tab', async () => {
        const result = await payload.create({
          collection: tabSlug,
          locale: englishLocale,
          data: {
            tab: {
              title: 'hello en',
            },
          },
        })

        expect(result.tab.title).toBe('hello en')

        await payload.update({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            tab: {
              title: 'hello es',
            },
          },
        })

        const docEn = await payload.findByID({
          collection: tabSlug,
          locale: englishLocale,
          id: result.id,
        })
        const docEs = await payload.findByID({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.tab.title).toBe('hello en')
        expect(docEs.tab.title).toBe('hello es')
      })

      it('should properly create/update/read deep localized field inside of tab', async () => {
        const result = await payload.create({
          collection: tabSlug,
          locale: englishLocale,
          data: {
            deep: {
              blocks: [
                {
                  blockType: 'first',
                  title: 'hello en',
                },
              ],
              array: [{ title: 'hello en' }],
            },
          },
        })

        expect(result.deep.array[0].title).toBe('hello en')

        await payload.update({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
          data: {
            deep: {
              blocks: [
                {
                  blockType: 'first',
                  title: 'hello es',
                  id: result.deep.blocks[0].id,
                },
              ],
              array: [
                {
                  id: result.deep.array[0].id,
                  title: 'hello es',
                },
              ],
            },
          },
        })

        const docEn = await payload.findByID({
          collection: tabSlug,
          locale: englishLocale,
          id: result.id,
        })
        const docEs = await payload.findByID({
          collection: tabSlug,
          locale: spanishLocale,
          id: result.id,
        })

        expect(docEn.deep.array[0].title).toBe('hello en')
        expect(docEn.deep.blocks[0].title).toBe('hello en')
        expect(docEs.deep.array[0].title).toBe('hello es')
        expect(docEs.deep.blocks[0].title).toBe('hello es')
      })
    })

    // Nested localized fields do no longer have their localized property stripped in
    // this monorepo, as this is handled at runtime.
    describe('nested localized field sanitization', () => {
      it('ensure nested localized fields keep localized property in monorepo', () => {
        const collection = payload.collections['localized-within-localized'].config

        expect(collection.fields[0].tabs[0].fields[0].localized).toBeDefined()
        expect(collection.fields[1].fields[0].localized).toBeDefined()
        expect(collection.fields[2].blocks[0].fields[0].localized).toBeDefined()
        expect(collection.fields[3].fields[0].localized).toBeDefined()
      })
    })

    describe('nested blocks', () => {
      let id
      it('should allow creating nested blocks per locale', async () => {
        const doc = await payload.create({
          collection: 'blocks-fields',
          data: {
            content: [
              {
                blockType: 'blockInsideBlock',
                array: [
                  {
                    link: {
                      label: 'English 1',
                    },
                  },
                  {
                    link: {
                      label: 'English 2',
                    },
                  },
                ],
                content: [
                  {
                    blockType: 'textBlock',
                    text: 'hello',
                  },
                ],
              },
            ],
          },
        })

        id = doc.id

        const retrievedInEN = await payload.findByID({
          collection: 'blocks-fields',
          id,
        })

        await payload.update({
          collection: 'blocks-fields',
          id,
          locale: 'es',
          data: {
            content: [
              {
                blockType: 'blockInsideBlock',
                array: [
                  {
                    link: {
                      label: 'Spanish 1',
                    },
                  },
                  {
                    link: {
                      label: 'Spanish 2',
                    },
                  },
                ],
                content: [
                  {
                    blockType: 'textBlock',
                    text: 'hola',
                  },
                ],
              },
            ],
          },
        })

        const retrieved = await payload.findByID({
          collection: 'blocks-fields',
          id,
          locale: 'all',
        })

        expect(retrieved.content.en[0].content).toHaveLength(1)
        expect(retrieved.content.es[0].content).toHaveLength(1)

        expect(retrieved.content.en[0].array[0].link.label).toStrictEqual('English 1')
        expect(retrieved.content.en[0].array[1].link.label).toStrictEqual('English 2')

        expect(retrieved.content.es[0].array[0].link.label).toStrictEqual('Spanish 1')
        expect(retrieved.content.es[0].array[1].link.label).toStrictEqual('Spanish 2')
      })
    })

    describe('nested arrays', () => {
      it('should not duplicate block rows for blocks within localized array fields', async () => {
        const randomDoc = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[0]

        const randomDoc2 = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[1]

        const blocksWithinArrayEN = [
          {
            blockName: '1',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc.id,
            myGroup: {
              text: 'hello in english 1',
            },
          },
          {
            blockName: '2',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc.id,
            myGroup: {
              text: 'hello in english 2',
            },
          },
          {
            blockName: '3',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc.id,
            myGroup: {
              text: 'hello in english 3',
            },
          },
        ]

        const blocksWithinArrayES = [
          {
            blockName: '1',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc2.id,
            myGroup: {
              text: 'hello in spanish 1',
            },
          },
          {
            blockName: '2',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc2.id,
            myGroup: {
              text: 'hello in spanish 2',
            },
          },
          {
            blockName: '3',
            blockType: 'someBlock',
            relationWithinBlock: randomDoc2.id,
            myGroup: {
              text: 'hello in spanish 3',
            },
          },
        ]

        const createdEnDoc = await payload.create({
          collection: 'nested-arrays',
          locale: 'en',
          depth: 0,
          data: {
            arrayWithBlocks: [
              {
                blocksWithinArray: blocksWithinArrayEN as any,
              },
            ],
          },
        })

        const updatedEsDoc = await payload.update({
          collection: 'nested-arrays',
          id: createdEnDoc.id,
          depth: 0,
          locale: 'es',
          data: {
            arrayWithBlocks: [
              {
                blocksWithinArray: blocksWithinArrayES as any,
              },
            ],
          },
        })

        const esArrayBlocks = updatedEsDoc.arrayWithBlocks[0].blocksWithinArray
        // recursively remove any id field within esArrayRow
        const removeId = (obj) => {
          if (obj instanceof Object) {
            delete obj.id
            Object.values(obj).forEach(removeId)
          }
        }
        removeId(esArrayBlocks)
        removeId(createdEnDoc.arrayWithBlocks[0].blocksWithinArray)

        expect(esArrayBlocks).toEqual(blocksWithinArrayES)
        expect(createdEnDoc.arrayWithBlocks[0].blocksWithinArray).toEqual(blocksWithinArrayEN)

        // pull enDoc again and make sure the update of esDoc did not mess with the data of enDoc
        const enDoc2 = await payload.findByID({
          id: createdEnDoc.id,
          collection: 'nested-arrays',
          locale: 'en',
          depth: 0,
        })
        removeId(enDoc2.arrayWithBlocks[0].blocksWithinArray)
        expect(enDoc2.arrayWithBlocks[0].blocksWithinArray).toEqual(blocksWithinArrayEN)
      })

      it('should update localized relation within unLocalized array', async () => {
        const randomTextDoc = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[0]
        const randomTextDoc2 = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[1]

        const createdEnDoc = await payload.create({
          collection: 'nested-arrays',
          locale: 'en',
          depth: 0,
          data: {
            arrayWithLocalizedRelation: [
              {
                localizedRelation: randomTextDoc.id,
              },
            ],
          },
        })

        const updatedEsDoc = await payload.update({
          collection: 'nested-arrays',
          id: createdEnDoc.id,
          depth: 0,
          locale: 'es',
          data: {
            arrayWithLocalizedRelation: [
              {
                id: createdEnDoc.arrayWithLocalizedRelation[0].id,
                localizedRelation: randomTextDoc2.id,
              },
            ],
          },
        })

        expect(updatedEsDoc.arrayWithLocalizedRelation).toHaveLength(1)
        expect(updatedEsDoc.arrayWithLocalizedRelation[0].localizedRelation).toBe(randomTextDoc2.id)

        expect(createdEnDoc.arrayWithLocalizedRelation).toHaveLength(1)
        expect(createdEnDoc.arrayWithLocalizedRelation[0].localizedRelation).toBe(randomTextDoc.id)

        // pull enDoc again and make sure the update of esDoc did not mess with the data of enDoc
        const enDoc2 = await payload.findByID({
          id: createdEnDoc.id,
          collection: 'nested-arrays',
          locale: 'en',
          depth: 0,
        })
        expect(enDoc2.arrayWithLocalizedRelation).toHaveLength(1)
        expect(enDoc2.arrayWithLocalizedRelation[0].localizedRelation).toBe(randomTextDoc.id)
      })
    })

    describe('nested fields', () => {
      it('should allow for fields which could contain new tables within localized arrays to be stored', async () => {
        const randomDoc = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[0]
        const randomDoc2 = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[1]

        const newDoc = await payload.create({
          collection: 'nested-field-tables',
          data: {
            array: [
              {
                relation: {
                  value: randomDoc.id,
                  relationTo: 'localized-posts',
                },
                hasManyRelation: [randomDoc.id, randomDoc2.id],
                hasManyPolyRelation: [
                  {
                    relationTo: 'localized-posts',
                    value: randomDoc.id,
                  },
                  {
                    relationTo: 'localized-posts',
                    value: randomDoc2.id,
                  },
                ],
                number: [1, 2],
                text: ['hello', 'goodbye'],
                select: ['one'],
              },
            ],
          },
        })

        await payload.update({
          collection: 'nested-field-tables',
          id: newDoc.id,
          locale: 'es',
          data: {
            array: [
              {
                relation: {
                  value: randomDoc2.id,
                  relationTo: 'localized-posts',
                },
                hasManyRelation: [randomDoc2.id, randomDoc.id],
                hasManyPolyRelation: [
                  {
                    relationTo: 'localized-posts',
                    value: randomDoc2.id,
                  },
                  {
                    relationTo: 'localized-posts',
                    value: randomDoc.id,
                  },
                ],
                select: ['two', 'three'],
                text: ['hola', 'adios'],
                number: [3, 4],
              },
            ],
          },
        })

        const retrieved = await payload.findByID({
          collection: 'nested-field-tables',
          id: newDoc.id,
          depth: 0,
          locale: 'all',
        })

        expect(retrieved.array.en[0].relation.value).toStrictEqual(randomDoc.id)
        expect(retrieved.array.es[0].relation.value).toStrictEqual(randomDoc2.id)

        expect(retrieved.array.en[0].hasManyRelation).toEqual([randomDoc.id, randomDoc2.id])
        expect(retrieved.array.es[0].hasManyRelation).toEqual([randomDoc2.id, randomDoc.id])

        expect(retrieved.array.en[0].hasManyPolyRelation).toEqual([
          { value: randomDoc.id, relationTo: 'localized-posts' },
          { value: randomDoc2.id, relationTo: 'localized-posts' },
        ])
        expect(retrieved.array.es[0].hasManyPolyRelation).toEqual([
          { value: randomDoc2.id, relationTo: 'localized-posts' },
          { value: randomDoc.id, relationTo: 'localized-posts' },
        ])

        expect(retrieved.array.en[0].number).toEqual([1, 2])
        expect(retrieved.array.es[0].number).toEqual([3, 4])

        expect(retrieved.array.en[0].select).toEqual(['one'])
        expect(retrieved.array.es[0].select).toEqual(['two', 'three'])

        expect(retrieved.array.en[0].text).toEqual(['hello', 'goodbye'])
        expect(retrieved.array.es[0].text).toEqual(['hola', 'adios'])
      })

      it('should allow for relationship in new tables within blocks inside of localized blocks to be stored', async () => {
        const randomDoc = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[0]
        const randomDoc2 = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[1]

        const docEn = await payload.create({
          collection: 'nested-field-tables',
          depth: 0,
          data: {
            blocks: [
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
            ],
          },
        })

        expect(docEn.blocks[0].nestedBlocks[0].relation.value).toBe(randomDoc.id)
        expect(docEn.blocks[1].nestedBlocks[0].relation.value).toBe(randomDoc.id)
        expect(docEn.blocks[2].nestedBlocks[0].relation.value).toBe(randomDoc.id)

        const docEs = await payload.update({
          id: docEn.id,
          depth: 0,
          locale: 'es',
          collection: 'nested-field-tables',
          data: {
            blocks: [
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                nestedBlocks: [
                  {
                    blockType: 'content',
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
            ],
          },
        })

        expect(docEs.blocks[0].nestedBlocks[0].relation.value).toBe(randomDoc2.id)
        expect(docEs.blocks[1].nestedBlocks[0].relation.value).toBe(randomDoc2.id)
        expect(docEs.blocks[2].nestedBlocks[0].relation.value).toBe(randomDoc2.id)

        const docAll = await payload.findByID({
          collection: 'nested-field-tables',
          id: docEn.id,
          locale: 'all',
          depth: 0,
        })

        expect(docAll.blocks.en[0].nestedBlocks[0].relation.value).toBe(randomDoc.id)
        expect(docAll.blocks.en[1].nestedBlocks[0].relation.value).toBe(randomDoc.id)
        expect(docAll.blocks.en[2].nestedBlocks[0].relation.value).toBe(randomDoc.id)

        expect(docAll.blocks.es[0].nestedBlocks[0].relation.value).toBe(randomDoc2.id)
        expect(docAll.blocks.es[1].nestedBlocks[0].relation.value).toBe(randomDoc2.id)
        expect(docAll.blocks.es[2].nestedBlocks[0].relation.value).toBe(randomDoc2.id)
      })

      it('should allow for relationship in new tables within arrays inside of localized blocks to be stored', async () => {
        const randomDoc = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[0]
        const randomDoc2 = (
          await payload.find({
            collection: 'localized-posts',
            depth: 0,
          })
        ).docs[1]

        const docEn = await payload.create({
          collection: 'nested-field-tables',
          depth: 0,
          data: {
            blocks: [
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc.id,
                    },
                  },
                ],
              },
            ],
          },
        })

        expect(docEn.blocks[0].array[0].relation.value).toBe(randomDoc.id)
        expect(docEn.blocks[1].array[0].relation.value).toBe(randomDoc.id)
        expect(docEn.blocks[2].array[0].relation.value).toBe(randomDoc.id)

        const docEs = await payload.update({
          id: docEn.id,
          depth: 0,
          locale: 'es',
          collection: 'nested-field-tables',
          data: {
            blocks: [
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
              {
                blockType: 'block',
                array: [
                  {
                    relation: {
                      relationTo: 'localized-posts',
                      value: randomDoc2.id,
                    },
                  },
                ],
              },
            ],
          },
        })

        expect(docEs.blocks[0].array[0].relation.value).toBe(randomDoc2.id)
        expect(docEs.blocks[1].array[0].relation.value).toBe(randomDoc2.id)
        expect(docEs.blocks[2].array[0].relation.value).toBe(randomDoc2.id)

        const docAll = await payload.findByID({
          collection: 'nested-field-tables',
          id: docEn.id,
          locale: 'all',
          depth: 0,
        })

        expect(docAll.blocks.en[0].array[0].relation.value).toBe(randomDoc.id)
        expect(docAll.blocks.en[1].array[0].relation.value).toBe(randomDoc.id)
        expect(docAll.blocks.en[2].array[0].relation.value).toBe(randomDoc.id)

        expect(docAll.blocks.es[0].array[0].relation.value).toBe(randomDoc2.id)
        expect(docAll.blocks.es[1].array[0].relation.value).toBe(randomDoc2.id)
        expect(docAll.blocks.es[2].array[0].relation.value).toBe(randomDoc2.id)
      })
    })

    describe('localized with unique', () => {
      it('localized with unique should work for each locale', async () => {
        await payload.create({
          collection: 'localized-posts',
          locale: 'ar',
          data: {
            unique: 'text',
          },
        })

        await payload.create({
          collection: 'localized-posts',
          locale: 'en',
          data: {
            unique: 'text',
          },
        })

        await payload.create({
          collection: 'localized-posts',
          locale: 'es',
          data: {
            unique: 'text',
          },
        })

        await expect(
          payload.create({
            collection: 'localized-posts',
            locale: 'en',
            data: {
              unique: 'text',
            },
          }),
        ).rejects.toBeTruthy()
      })
    })

    describe('Copying To Locale', () => {
      let user: User

      beforeAll(async () => {
        user = (
          await payload.find({
            collection: 'users',
            where: {
              email: {
                equals: devUser.email,
              },
            },
          })
        ).docs[0] as unknown as User

        user['collection'] = 'users'
      })

      it('should copy to locale', async () => {
        const doc = await payload.create({
          collection: 'localized-posts',
          data: {
            title: 'Hello',
            group: {
              children: 'Children',
            },
            unique: 'unique-field',
            localizedCheckbox: true,
          },
        })

        const req = await createLocalReq({ user }, payload)

        const res = (await copyDataFromLocaleHandler({
          fromLocale: 'en',
          req,
          toLocale: 'es',
          docID: doc.id,
          collectionSlug: 'localized-posts',
        })) as LocalizedPost

        expect(res.title).toBe('Hello')
        expect(res.group.children).toBe('Children')
        expect(res.unique).toBe('unique-field')
        expect(res.localizedCheckbox).toBe(true)
      })

      it('should copy localized nested to arrays', async () => {
        const doc = await payload.create({
          collection: 'nested',
          locale: 'en',
          data: {
            topLevelArray: [
              {
                localizedText: 'some-localized-text',
                notLocalizedText: 'some-not-localized-text',
              },
            ],
          },
        })

        const req = await createLocalReq({ user }, payload)

        const res = (await copyDataFromLocaleHandler({
          fromLocale: 'en',
          req,
          toLocale: 'es',
          docID: doc.id,
          collectionSlug: 'nested',
        })) as Nested

        expect(res.topLevelArray[0].localizedText).toBe('some-localized-text')
        expect(res.topLevelArray[0].notLocalizedText).toBe('some-not-localized-text')
      })

      it('should copy localized arrays', async () => {
        const doc = await payload.create({
          collection: 'nested',
          locale: 'en',
          data: {
            topLevelArrayLocalized: [
              {
                text: 'some-text',
              },
            ],
          },
        })

        const req = await createLocalReq({ user }, payload)

        const res = (await copyDataFromLocaleHandler({
          fromLocale: 'en',
          req,
          toLocale: 'es',
          docID: doc.id,
          collectionSlug: 'nested',
        })) as Nested

        expect(res.topLevelArrayLocalized[0].text).toBe('some-text')
      })
    })
  })

  describe('Localization with fallback false', () => {
    let post1: LocalizedPost
    let postWithLocalizedData: LocalizedPost

    beforeAll(async () => {
      if (payload.config.localization) {
        payload.config.localization.fallback = false
      }

      post1 = await payload.create({
        collection,
        data: {
          title: englishTitle,
        },
      })

      postWithLocalizedData = await payload.create({
        collection,
        data: {
          title: englishTitle,
        },
      })

      await payload.update({
        id: postWithLocalizedData.id,
        collection,
        data: {
          title: spanishTitle,
        },
        locale: spanishLocale,
      })
    })

    describe('fallback locale', () => {
      it('create english', async () => {
        const allDocs = await payload.find({
          collection,
          where: {
            title: { equals: post1.title },
          },
        })
        expect(allDocs.docs).toContainEqual(expect.objectContaining(post1))
      })

      it('add spanish translation', async () => {
        const updated = await payload.update({
          id: post1.id,
          collection,
          data: {
            title: spanishTitle,
          },
          locale: spanishLocale,
        })

        expect(updated.title).toEqual(spanishTitle)

        const localized: any = await payload.findByID({
          id: post1.id,
          collection,
          locale: 'all',
        })

        expect(localized.title.en).toEqual(englishTitle)
        expect(localized.title.es).toEqual(spanishTitle)
      })

      it('should not fallback to english', async () => {
        const retrievedDoc = await payload.findByID({
          id: post1.id,
          collection,
          locale: portugueseLocale,
        })

        expect(retrievedDoc.title).not.toBeDefined()
      })

      it('should fallback to english with explicit fallbackLocale', async () => {
        const fallbackDoc = await payload.findByID({
          id: post1.id,
          collection,
          locale: portugueseLocale,
          fallbackLocale: englishLocale,
        })

        expect(fallbackDoc.title).toBe(englishTitle)
      })

      it('should not fallback to spanish translation and no explicit fallback is provided', async () => {
        const localizedFallback: any = await payload.findByID({
          id: postWithLocalizedData.id,
          collection,
          locale: portugueseLocale,
        })

        expect(localizedFallback.title).not.toBeDefined()
      })

      it('should respect fallback none', async () => {
        const localizedFallback: any = await payload.findByID({
          id: postWithLocalizedData.id,
          collection,
          locale: portugueseLocale,
          fallbackLocale: false,
        })

        expect(localizedFallback.title).not.toBeDefined()
      })
    })
  })
})

async function createLocalizedPost(data: {
  title: {
    [defaultLocale]: string
    [spanishLocale]: string
  }
}): Promise<LocalizedPost> {
  const localizedRelation: any = await payload.create({
    collection,
    data: {
      title: data.title.en,
    },
  })

  await payload.update({
    id: localizedRelation.id,
    collection,
    data: {
      title: data.title.es,
    },
    locale: spanishLocale,
  })

  return localizedRelation
}