dal.js

import "server-only"
import { cache } from "react"
import { redirect } from "next/navigation"
import { cookies } from "next/headers"
import { decrypt } from "@/server/session/session"
import * as users from "@/server/db/users"
import * as jokes from "@/server/db/jokes"
import * as votes from "@/server/db/votes"
import * as recommendation from "@/server/db/rec"

// Session

export const verifySession = cache(async () => {
  const cookie = (await cookies()).get("session")?.value
  const session = await decrypt(cookie)

  if (!session?.userId) {
    redirect("/login")
  }

  return { isAuth: true, userId: session.userId }
})

// Reads

export const getUser = cache(async () => {
  const session = await verifySession()
  if (!session) return null

  try {
    return users.getUserById(session.userId) ?? null
  } catch {
    console.log("Failed to fetch user")
    return null
  }
})

export const getUserById = cache(async userId => {
  await verifySession()

  try {
    return users.getUserById(userId) ?? null
  } catch {
    console.log("Failed to fetch user by id")
    return null
  }
})

export const searchUsersQuery = cache(async (query, limit = 50) => {
  await verifySession()

  try {
    return users.searchUsers(query, limit)
  } catch {
    console.log("Failed to search users")
    return []
  }
})

export const getJoke = cache(async jokeId => {
  await verifySession()

  try {
    return jokes.getJokeById(jokeId) ?? null
  } catch {
    console.log("Failed to fetch joke")
    return null
  }
})

export const getJokesQuery = cache(async (sort, order, limit = 50, text) => {
  await verifySession()

  const offset = 0

  try {
    const allowedSortBy = ["date", "popularity"]
    if (!allowedSortBy.includes(sort)) throw new Error("Invalid sortBy")

    let sortBy
    if (sort === "recent") {
      sortBy = "date"
    } else if (sort === "top") {
      sortBy = "popularity"
    }

    return jokes.getJokes({ sortBy, order, limit, offset, text })
  } catch {
    console.log("Failed to fetch jokes")
    return []
  }
})

export const getJokesByAuthor = cache(async authorId => {
  await verifySession()

  try {
    return jokes.getJokesByAuthor(authorId)
  } catch {
    console.log("Failed to fetch jokes by author")
    return []
  }
})

export const getTopJokesByAuthor = cache(async (userId, limit = 3) => {
  await verifySession()

  try {
    return jokes.getTopJokesByAuthor(userId, limit)
  } catch {
    console.log("Failed to fetch top jokes by author")
    return []
  }
})

export const getUserScoreRatio = cache(async userId => {
  userId ??= (await verifySession()).userId

  try {
    return users.getUserScoreRatio(userId)
  } catch {
    console.log("Failed to fetch user score ratio")
    return 0
  }
})

export const getRecommendation = cache(async opts => {
  const session = await verifySession()
  if (!session) return null

  try {
    return recommendation.recommendHottestUnvoted(session.userId, opts)
  } catch {
    console.log("Failed to fetch recommendation")
    return null
  }
})

export const getVote = cache(async jokeId => {
  const session = await verifySession()
  if (!session) return null

  try {
    return votes.getVote(session.userId, jokeId) ?? null
  } catch {
    console.log("Failed to fetch vote")
    return null
  }
})

export const getVotesForJoke = cache(async jokeId => {
  await verifySession()

  try {
    return votes.getVotesForJoke(jokeId)
  } catch {
    console.log("Failed to fetch votes for joke")
    return []
  }
})

export const getVotesByUser = cache(async () => {
  const session = await verifySession()
  if (!session) return null

  try {
    return votes.getVotesByUser(session.userId)
  } catch {
    console.log("Failed to fetch votes by user")
    return []
  }
})

export const getAgreeability = cache(async userId => {
  const session = await verifySession()
  if (!session) return null

  try {
    return votes.getAgreeability(userId)
  } catch {
    console.log("Failed to fetch agreeability")
    return null
  }
})

export const getHotnessForJoke = cache(async jokeId => {
  const session = await verifySession()
  if (!session) return null

  try {
    return votes.getHotnessForJoke(jokeId)
  } catch {
    console.log("Failed to fetch hotness")
    return null
  }
})

export const getJokesPage = cache(
  async ({ page, sort, order, limit = 50, text }) => {
    await verifySession()

    try {
      const allowedSortBy = ["recent", "top", "hot"]
      if (!allowedSortBy.includes(sort)) throw new Error("Invalid sortBy")

      const realSortBy = ["date", "popularity", "hotness"]
      const sortBy = realSortBy[allowedSortBy.indexOf(sort)]

      const { jokes: results, total } = jokes.getJokesPage({
        page,
        sortBy,
        order,
        limit,
        text
      })

      return { jokes: results, count: total }
    } catch {
      console.log("Failed to fetch joke page")
      return { jokes: [], count: 0 }
    }
  }
)

// Writes

export async function insertJoke(body) {
  const session = await verifySession()
  if (!session) return null
  try {
    return jokes.createJoke({ authorId: session.userId, body })
  } catch {
    console.log("Failed to insert joke")
    return null
  }
}

export async function updateVote(jokeId, action) {
  const session = await verifySession()
  if (!session) return null

  try {
    return votes.setVote(session.userId, jokeId, action)
  } catch {
    console.log("Failed to update vote")
    return null
  }
}

export async function removeJoke(jokeId) {
  const session = await verifySession()
  if (!session) return null

  try {
    const joke = jokes.getJokeById(jokeId)
    if (!joke || joke.author_id !== session.userId) return null

    const result = jokes.deleteJoke(jokeId)
    if (result.changes === 0) throw new Error("Joke not found")
    return result
  } catch {
    console.log("Failed to delete joke")
    return null
  }
}

export async function updatePassword(newPasswordHash) {
  const session = await verifySession()
  if (!session) return null

  try {
    users.updatePassword(session.userId, newPasswordHash)
    return { success: true }
  } catch {
    console.log("Failed to update password")
    return null
  }
}

export async function deleteAccount() {
  const session = await verifySession()
  if (!session) return null

  try {
    users.deleteUser(session.userId)
    return { success: true }
  } catch {
    console.log("Failed to delete account")
    return null
  }
}