/* eslint-disable camelcase */
import {
  createDirectus, rest, authentication, withToken, createItem,
  readUser, createContentVersion, readContentVersions, saveToContentVersion,
  readContentVersion, readItems, updateItem, deleteItem,
  compareContentVersion
} from '@directus/sdk'
import {signOut} from 'next-auth/react'
import {hasRestrictedChar} from './format.js'

const apiUrl = process.env.DIRECTUS_API_URL || process.env.NEXT_PUBLIC_DIRECTUS_API_URL

export const directusClient = createDirectus(apiUrl)
  .with(authentication('cookie', {credentials: 'include', autoRefresh: true}))
  .with(rest())

export async function handleUserStatus(accessToken, userId) {
  const {status} = await directusClient.request(
    withToken(
      accessToken,
      readUser(userId, {
        fields: 'status'
      })
    )
  )

  if (status !== 'active') {
    signOut()
    throw new Error('Déconnexion')
  }
}

export async function handleSubmit({
  userId,
  accessToken,
  content,
  collection,
  requestObject,
  setError,
  setSuccess,
  setIsErrorAlertOpen,
  setIsSuccessAlertOpen,
  countdownRef,
}) {
  try {
    if (hasRestrictedChar(content)) {
      setError('Le texte ne doit pas contenir certains caractères spéciaux : <, >, ", .')
      setIsErrorAlertOpen(true)
      return
    }

    await handleUserStatus(accessToken, userId)

    await directusClient.request(
      withToken(
        accessToken,
        createItem(collection, requestObject)
      )
    )

    setSuccess('Envoyé avec succès. En attente de validation.')
    setIsSuccessAlertOpen(true)
  } catch (error) {
    if (error?.errors[0]?.message === 'Token expired.') {
      countdownRef.current.startCountdown()
    } else {
      console.log(error?.errors[0]?.message)
      setError(error?.errors[0]?.message)
      setIsErrorAlertOpen(true)
    }
  }
}

export async function getVersion({
  accessToken,
  userId,
  versionId
}) {
  await handleUserStatus(accessToken, userId)

  const version = await directusClient.request(
    withToken(
      accessToken,
      readContentVersion(versionId)
    )
  )

  return version
}

export async function compareVersion({
  accessToken,
  userId,
  versionId,
  countdownRef,
  setError,
  setIsErrorAlertOpen
}) {
  try {
    await handleUserStatus(accessToken, userId)

    const result = await directusClient.request(
      withToken(
        accessToken,
        compareContentVersion(versionId)
      )
    )

    return result
  } catch (error) {
    console.log('error', error)

    if (error?.errors[0]?.message === 'Token expired.') {
      countdownRef.current.startCountdown()
    } else {
      console.log(error?.errors[0]?.message)
      setError(error?.errors[0]?.message)
      setIsErrorAlertOpen(true)
    }
  }
}

export async function listVersions({
  accessToken,
  userId,
  countdownRef,
  setError,
  setIsErrorAlertOpen
}) {
  try {
    await handleUserStatus(accessToken, userId)

    const versions = await directusClient.request(
      withToken(
        accessToken,
        readContentVersions({
          sort: '-date_created'
        })
      )
    )

    return versions
  } catch (error) {
    console.log('error', error)

    if (error?.errors[0]?.message === 'Token expired.') {
      countdownRef.current.startCountdown()
    } else {
      console.log(error?.errors[0]?.message)
      setError(error?.errors[0]?.message)
      setIsErrorAlertOpen(true)
    }
  }
}

export async function createVersion({
  accessToken,
  userId,
  collection,
  id,
  content,
  countdownRef,
  setSuccess,
  setError,
  setIsErrorAlertOpen,
  setIsSuccessAlertOpen
}) {
  try {
    if (hasRestrictedChar(content)) {
      throw new Error('Le texte ne doit pas contenir certains caractères spéciaux : <, >, ", .')
    }

    await handleUserStatus(accessToken, userId)

    const versions = await directusClient.request(
      withToken(
        accessToken,
        readContentVersions({
          filter: {
            collection: {
              _eq: collection
            }
          }
        })
      )
    )

    const versionsCount = versions.length + 1

    const date = Date.now()
    const name = `v${versionsCount}-${date}`
    const key = `${id}-${date}`

    await directusClient.request(
      withToken(
        accessToken,
        createContentVersion({
          key,
          name,
          item: id,
          collection,
        })
      )
    )

    const contentVersion = await directusClient.request(
      withToken(
        accessToken,
        readContentVersions({
          filter: {
            user_created: {
              _eq: userId
            },
            key: {
              _eq: key
            }
          }
        })
      )
    )

    await directusClient.request(
      withToken(
        accessToken,
        saveToContentVersion(
          contentVersion[0].id,
          {contenu: content}
        )
      )
    )

    setSuccess(`Version créée avec succès : ${name}`)
    setIsSuccessAlertOpen(true)
  } catch (error) {
    if (error?.errors[0]?.message === 'Token expired.') {
      countdownRef.current.startCountdown()
    } else {
      console.log(error?.errors[0]?.message)
      setError(error?.errors[0]?.message)
      setIsErrorAlertOpen(true)
    }
  }
}

export async function handleVote({
  accessToken,
  userId,
  versionId,
  voteValue
}) {
  try {
    await handleUserStatus(accessToken, userId)

    const version = await directusClient.request(
      withToken(
        accessToken,
        readContentVersion(versionId)
      )
    )

    if (!version) {
      throw new Error('Version non trouvée')
    }

    const versionDate = new Date(version.date_created)
    const currentDate = new Date()
    const diffTime = currentDate - versionDate
    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))

    if (diffDays > 3) {
      throw new Error('Le vote n’est plus possible après 3 jours de la création de la version')
    }

    const existingVotes = await directusClient.request(
      withToken(
        accessToken,
        readItems('votes', {
          filter: {
            _and: [
              {content_version_id: {_eq: versionId}},
              {user_created: {_eq: userId}}
            ]
          }
        })
      )
    )

    if (existingVotes && existingVotes.length > 0) {
      const existingVote = existingVotes[0]

      if (existingVote.vote === voteValue) {
        await directusClient.request(
          withToken(
            accessToken,
            deleteItem('votes', existingVote.id)
          )
        )
        return null
      }

      const vote = {
        content_version_id: versionId,
        vote: voteValue
      }

      await directusClient.request(
        withToken(
          accessToken,
          updateItem('votes', existingVote.id, vote)
        )
      )
      return voteValue
    }

    const vote = {
      content_version_id: versionId,
      vote: voteValue
    }

    await directusClient.request(
      withToken(
        accessToken,
        createItem('votes', vote)
      )
    )
    return voteValue
  } catch (error) {
    console.error('Error voting:', error)

    // Extract error message from Directus error object
    let errorMessage = 'Une erreur est survenue lors du vote'

    if (error?.errors?.[0]?.message) {
      errorMessage = error.errors[0].message
    } else if (error?.message) {
      errorMessage = error.message
    } else if (typeof error === 'string') {
      errorMessage = error
    }

    throw new Error(errorMessage)
  }
}

export async function getUserVote({
  accessToken,
  userId,
  versionId
}) {
  try {
    await handleUserStatus(accessToken, userId)

    const existingVotes = await directusClient.request(
      withToken(
        accessToken,
        readItems('votes', {
          filter: {
            _and: [
              {content_version_id: {_eq: versionId}},
              {user_created: {_eq: userId}}
            ]
          }
        })
      )
    )

    return existingVotes && existingVotes.length > 0 ? existingVotes[0].vote : null
  } catch (error) {
    console.error('Error fetching vote:', error)
    throw error
  }
}