// get the result
const result = await getUserAppSettings("[insert uuid]")

// basic type narrowing
if (result.isOK()) {
  result.value // Settings
} else {
  // DrizzleGenericError | DrizzleTransactionRollbackError | UnknownError
  const error = result.error
  // this is why we wrapped it earlier
  if (error.name === "drizzle_transaction_rollback_error") {
    error // DrizzleTransactionRollbackError
  } else if (error.name === "drizzle_generic_error") {
    error // DrizzleGenericError 
  }
  // you get the idea...
}

// take a value and an error and convert it into a single type ("light" | "dark")
const theme = result.match(
  settings => settings?.theme === ("light" ? "light" : "dark") as const,
  // ignore the error just provide a default (dark >:D)
  () => "dark" as const
)

// "unwrapping" is extracting the value or error from the result object
// we can call `_unsafeUnwrap()` to get the value without type narrowing
// as the name implies this can throw errors

import {
  TransactionRollbackError as TransactionRollbackErrorCause,
  DrizzleError as DrizzleErrorCause
} from "drizzle-orm"

// unknown catch-all error
export type UnknownError {
  error: "drizzle_record_not_found_error"
  message: string
  cause: unknown
}

// this is a custom error we'll throw when we find no
// records and we only want to return one record
export class DrizzleRecordNotFoundErrorCause extends Error {
}

export type DrizzleRecordNotFoundError {
  error: "drizzle_record_not_found_error"
  message: string
  cause: DrizzleRecordNotFoundErrorCause
}

// these errors wrap drizzle core errors with the `error` key
// so that they can be narrowed down as a discriminated union
export type DrizzleGenericError = {
  error: "drizzle_generic_error"
  message: string
  cause: DrizzleErrorCause
}

export type DrizzleTransactionRollbackError = {
  error: "drizzle_transaction_rollback_error"
  message: string
  cause: TransactionRollbackErrorCause
}

export type DrizzleError = DrizzleGenericError | DrizzleTransactionRollbackError | DrizzleRecordNotFoundError

export function createDrizzleError(cause: unknown) {
  if (cause instanceof TransactionRollbackErrorCause) {
    return {
      error: "drizzle_transaction_rollback_error",
      message: cause.message,
      cause: cause,
    } satisfies DrizzleTransactionRollbackError
  }

  if (cause instanceof DrizzleErrorCause) {
    return {
      error: "drizzle_generic_error",
      message: cause.message,
      cause: cause,
    } satisfies DrizzleGenericError
  }

  if (cause instanceof DrizzleRecordNotFoundErrorCause) {
    return {
      error: "drizzle_record_not_found_error"
      message: cause.message,
      cause: cause
    } satisfies DrizzleRecordNotFoundError
  }

  return {
    error: "unknown_error",
    message: "Unknown error",
    cause: cause,
  } as UnknownError
}

export async function getUserAppSettings(userId: string) {
  return ResultAsync.fromPromise(
    async () => {
      // make the db call, returns a `Settings[]`
      // but we want one and only one row
      const records = await db
        .select()
        .from(settingsTable)
        .where(eq(settingsTable.userId, userId))
        .execute()

      // getting a missing user settings is an error for our application
      // but drizzle doesn't and shouldn't see it that way, it just
      // returns an empty list, let's make a custom error
      if (result.length === 0) {
        throw new DrizzleRecordNotFoundErrorCause(`App settings for ${userId} not found`)
      }

      return result[0]
    }
    // the second parameter is what brings the errors under our control
    (e) => createDrizzleError(e)
  )
}

/**
 * Setup for demo purposes, skip to application code
 */

// import our zod or valibot schema
import { appSettingsSchema } from "./appSettings"

// import our wrapped parse and auth functions

// returns the parsed schema object or a `ValidationError`
import { safeParse } from "./validation"

// returns a { user, session } object or a `SessionError`
import { getValidatedSession } from "auth"

// returns a Settings object or `DrizzleGenericError | DrizzleTransactionRollbackError | UnknownError`
import { updateUserAppSettingsRepository } from "./user-repository"

/**
 * Application code
 */

async function updateUserAppSettings(unvalidatedInput: unknown) {
  // safeTry is what allows us to propogate errors
  const result = await safeTry(
    // async is cause we want to use async code, this isn't neccessary in all cases,
    // you can define a sync function here

    // function* defines this as a generator function where we'll `yield` out our errors
    async function* () {
      // validate the input, if there's a ValidationError then stop and propogate it up
      // otherwise we keep on the happy path :)
      const input = yield safeParse(appSettingsSchema, unvalidatedInput).safeUnwrap()

      // because this is an async function we need to wrap the async call in brackets
      const { user } = yield (await getValidatedSession()).safeUnwrap()

      // for the last call we just need to return the result directly
      return updateUserAppSettingsRepository(user.id, input)
    }
  )

  /**
   * Result<
   *   AppSettings,
   *   ValidationError | SessionError | DrizzleGenericError | DrizzleTransactionRollbackError | UnknownError
   * >
   */
  return result
}

const result = await updateUserAppSettings()

if (result.isOK()) {
  // set flash message and redirect back to index
} else {
  const error = result.error
  // validation errors should be set on the form,
  // everything else should be just reported as an error
  if (isValidationError(result.error)) {
    return new Response(JSON.stringify(error.issues), {
      status: 400
    })
  } else {
    // report is just an example, this post is already too long
    await report(error)
    return new Response(error.message, {
      status: 500
    })
  }
}