import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node"
import { Context, Effect, Layer, Schema } from "effect"
import { SqlClient, SqlModel, SqlSchema } from "effect/sql"
import { User } from "../domain/User.ts"
import type { UserId } from "../domain/User.ts"
import { SearchQueryTooShort, UserNotFound, UsersError } from "../domain/UserErrors.ts"

// The SqlClient layer determines which database the SQL implementation talks
// to. Swap it for another driver package to target a different database.
const SqlLayer = SqliteClient.layer({ filename: ":memory:" })

// Migrations are effects keyed by `<id>_<name>` that run once, in id order. A
// real application would keep each migration in its own file and load them
// with `SqliteMigrator.fromFileSystem` instead of an inline record.
const MigratorLayer = SqliteMigrator.layer({
  loader: SqliteMigrator.fromRecord({
    "0001_create_users": Effect.gen(function*() {
      const sql = yield* SqlClient.SqlClient
      yield* sql`
        CREATE TABLE users (
          id TEXT PRIMARY KEY,
          name TEXT NOT NULL,
          email TEXT NOT NULL,
          createdAt TEXT NOT NULL,
          updatedAt TEXT NOT NULL
        )
      `
    })
  })
})

export class Users extends Context.Service<Users, {
  list(search: string | undefined): Effect.Effect<Array<User>, UsersError>
  getById(id: UserId): Effect.Effect<User, UsersError>
  create(input: typeof User.jsonCreate.Type): Effect.Effect<User, UsersError>
  update(id: UserId, input: typeof User.jsonUpdate.Type): Effect.Effect<User, UsersError>
}>()("acme/Users") {
  // The SQL implementation only requires a `SqlClient`, so entrypoints and
  // tests decide how the database is provided.
  static readonly layerNoDeps = Layer.effect(
    Users,
    Effect.gen(function*() {
      const sql = yield* SqlClient.SqlClient

      // CRUD goes through a repository derived from the `User` model. Each
      // operation uses the matching model variant to encode its input and
      // decodes rows with the full model schema.
      const repo = yield* SqlModel.makeRepository(User, {
        tableName: "users",
        spanPrefix: "Users",
        idColumn: "id"
      })

      // Queries the repository does not cover are written with the `sql` tag
      // and decoded with the model schema.
      const listAll = SqlSchema.findAll({
        Request: Schema.Void,
        Result: User,
        execute: () => sql`SELECT * FROM users ORDER BY createdAt`
      })

      const searchUsers = SqlSchema.findAll({
        Request: Schema.String,
        Result: User,
        execute: (search) => {
          const pattern = `%${search}%`
          return sql`SELECT * FROM users WHERE name LIKE ${pattern} OR email LIKE ${pattern}`
        }
      })

      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
        if (search === undefined || search.length === 0) {
          return yield* Effect.orDie(listAll())
        } else if (search.length < SearchQueryTooShort.minimumLength) {
          return yield* new UsersError({
            reason: new SearchQueryTooShort()
          })
        }
        yield* Effect.annotateCurrentSpan({ search })
        return yield* Effect.orDie(searchUsers(search))
      })

      const getById = Effect.fn("Users.getById")((id: UserId) =>
        repo.findById(id).pipe(
          Effect.catchTags({
            NoSuchElementError: () => new UsersError({ reason: new UserNotFound() }),
            // Database and encoding failures are unexpected, so treat them as
            // defects to keep the service interface focused on domain errors.
            SchemaError: Effect.die,
            SqlError: Effect.die
          })
        )
      )

      const create = Effect.fn("Users.create")((input: typeof User.jsonCreate.Type) =>
        // `User.insert.makeEffect` fills in the generated id and timestamps
        // using the Effect clock, so tests can control them with `TestClock`.
        User.insert.makeEffect(input).pipe(
          Effect.flatMap(repo.insert),
          Effect.orDie
        )
      )

      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
        // Ensure the user exists first, so a missing id fails with the domain
        // error instead of a defect.
        yield* getById(id)
        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
        return yield* repo.update(update).pipe(Effect.orDie)
      })

      return Users.of({ list, getById, create, update })
    })
  )

  // The fully provided SQL implementation: the database client and migrations
  // are implementation details, so this layer requires nothing.
  static readonly layer: Layer.Layer<Users> = this.layerNoDeps.pipe(
    Layer.provide(MigratorLayer.pipe(Layer.provideMerge(SqlLayer))),
    Layer.orDie
  )

  // An in-memory implementation for tests, so the HTTP stack can be exercised
  // without a database.
  static readonly layerMemory = Layer.effect(
    Users,
    Effect.gen(function*() {
      const users = new Map<UserId, User>()

      const makeUser = (input: typeof User.jsonCreate.Type) =>
        User.insert.makeEffect(input).pipe(
          Effect.map((user) => new User(user)),
          Effect.orDie
        )

      const admin = yield* makeUser({ name: "Admin", email: "admin@acme.dev" })
      users.set(admin.id, admin)

      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
        const allUsers = Array.from(users.values())
        if (search === undefined || search.length === 0) {
          return allUsers
        } else if (search.length < SearchQueryTooShort.minimumLength) {
          return yield* new UsersError({
            reason: new SearchQueryTooShort()
          })
        }
        yield* Effect.annotateCurrentSpan({ search })
        const normalized = search.toLowerCase()
        return allUsers.filter((user) =>
          user.name.toLowerCase().includes(normalized) || user.email.toLowerCase().includes(normalized)
        )
      })

      const getById = Effect.fn("Users.getById")(function*(id: UserId) {
        yield* Effect.annotateCurrentSpan({ id })
        const user = users.get(id)
        if (user === undefined) {
          return yield* new UsersError({
            reason: new UserNotFound()
          })
        }
        return user
      })

      const create = Effect.fn("Users.create")(function*(input: typeof User.jsonCreate.Type) {
        const user = yield* makeUser(input)
        users.set(user.id, user)
        return user
      })

      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
        const existing = yield* getById(id)
        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
        const updated = new User({ ...existing, ...update })
        users.set(id, updated)
        return updated
      })

      return Users.of({ list, getById, create, update })
    })
  )
}