import { StoreBuilder, StoreUpdater } from "./builder.store"
import type { ExtantKey, MigrationDef, MigrationFn, RowConstraint, SchemaConstraint, Simplify, StoreDef, UnusedKey, VersionDef } from "./schema"

export class VersionBuilder<Schema extends SchemaConstraint> {
  #stores: Map<string, StoreDef<string, any>>
  #migrations: MigrationDef[]

  constructor(previousStores: Map<string, StoreDef<string, any, any, any>> = new Map()) {
    this.#stores = new Map(previousStores)
    this.#migrations = []
  }

  create<Name extends string>(name: UnusedKey<Name, Schema>) {
    if (this.#stores.has(name))
      throw new Error(`cannot create store ${name} - already exists`)

    return <Row extends RowConstraint> (callback: (b: StoreBuilder<Row>) => StoreBuilder<Row, any, any>) => {
      const builder = callback(new StoreBuilder<Row>())
      const created = builder.build(name)

      this.#stores.set(name, created)
      this.#migrations.push(['create', name, created])

      return this as unknown as VersionBuilder<Simplify<Schema & {[K in Name]: Row}>>
    }
  }

  update<Name extends string>(name: ExtantKey<Name, Schema>) {
    const extant = this.#stores.get(name)
    if (extant == null) throw new Error(`cannot update store ${name} - does not exist`)

    return <NewRow extends RowConstraint = Schema[Name]> (callback: (u: StoreUpdater<Name, Schema[Name], any, any>) => StoreUpdater<Name, any, any, any>) => {
      const updater = new StoreUpdater<Name, Schema[Name], typeof extant.__doc, typeof extant.__indexes>(extant as any)
      const updated = callback(updater).build()

      this.#stores.set(name, updated)
      this.#migrations.push(['update', name, updated])

      return this as unknown as VersionBuilder<Simplify<Omit<Schema, Name> & {[K in Name]: NewRow}>>
    }
  }

  drop<Name extends string>(name: Name): VersionBuilder<Omit<Schema, Name>> {
    this.#stores.delete(name)
    this.#migrations.push(['drop', name])

    return this as unknown as VersionBuilder<Simplify<Omit<Schema, Name>>>
  }

  migrate<
    WriteOverrides extends SchemaConstraint,
    OverriddenSchema extends SchemaConstraint = Simplify<Omit<Schema, keyof WriteOverrides> & WriteOverrides>
  >(cb: MigrationFn<Schema, OverriddenSchema>): VersionBuilder<OverriddenSchema> {
    this.#migrations.push(cb)
    return this as unknown as VersionBuilder<OverriddenSchema>
  }

  build(): VersionDef<Simplify<Schema>> {
    return {
      stores: this.#stores,
      migrations: this.#migrations,

      __schema: undefined as unknown as Schema,
    }
  }
}