//// Public entrypoint for the `gdo` package.

import gdo/connection
import gdo/decode
import gdo/error.{type Error}
import gdo/result
import gdo/row
import gdo/statement
import gdo/value.{type Param}
import gleam/option.{type Option}

pub const package_name = "gdo"

pub const version = "0.1.0"

pub fn sqlite(database: String) -> connection.ConnectionConfig {
  connection.sqlite(database)
}

pub fn sqlite_config(database: String) -> connection.ConnectionConfig {
  connection.sqlite_config(database)
}

pub fn open_sqlite(database: String) -> Result(connection.Connection, Error) {
  database
  |> connection.sqlite
  |> connection.open
}

pub fn prepare(sql: String) -> Result(statement.Statement, Error) {
  statement.prepare(sql)
}

pub fn exec_sqlite(
  database: String,
  sql: String,
  params: List(Param),
) -> Result(result.ExecutionResult, Error) {
  case open_sqlite(database) {
    Ok(connection) -> connection.exec(connection, sql, params)
    Error(error) -> Error(error)
  }
}

pub fn query_one_sqlite(
  database: String,
  sql: String,
  params: List(Param),
) -> Result(Option(row.Row), Error) {
  case open_sqlite(database) {
    Ok(connection) -> connection.query_one(connection, sql, params)
    Error(error) -> Error(error)
  }
}

pub fn query_all_sqlite(
  database: String,
  sql: String,
  params: List(Param),
) -> Result(result.QueryResult, Error) {
  case open_sqlite(database) {
    Ok(connection) -> connection.query_all(connection, sql, params)
    Error(error) -> Error(error)
  }
}

pub fn query_one_sqlite_as(
  database: String,
  sql: String,
  params: List(Param),
  using decoder: decode.Decoder(a),
) -> Result(Option(a), Error) {
  case open_sqlite(database) {
    Ok(connection) ->
      connection.query_one_as(connection, sql, params, using: decoder)
    Error(error) -> Error(error)
  }
}

pub fn query_all_sqlite_as(
  database: String,
  sql: String,
  params: List(Param),
  using decoder: decode.Decoder(a),
) -> Result(List(a), Error) {
  case open_sqlite(database) {
    Ok(connection) ->
      connection.query_all_as(connection, sql, params, using: decoder)
    Error(error) -> Error(error)
  }
}