// builders

import {StoreBuilder, StoreUpdater} from './builder.store'
import type {
  DatabaseDef,
  ExtantKey,
  Increment,
  IndexesConstraint,
  MigrationDef,
  MigrationFn,
  RowConstraint,
  SchemaConstraint,
  Simplify,
  StoreDef,
  UnusedKey,
} from './schema'

// Helper: merge row type changes into schema, preserving indexes for existing stores
type MergeRowChanges<
  Current extends SchemaConstraint,
  Changes extends Record<string, RowConstraint>
> = {
  [K in keyof Current | keyof Changes]:
    K extends keyof Changes
      ? K extends keyof Current
        // Existing store: update row, preserve indexes
        ? StoreDef<K & string, Changes[K], Changes[K], Current[K]['__indexes']>
        // New store: no indexes
        : StoreDef<K & string, Changes[K], Changes[K], IndexesConstraint>
      // Unchanged store
      : K extends keyof Current ? Current[K] : never
}

export class DatabaseBuilder<
  Name extends string,
  Version extends number = 0,
  Schema extends SchemaConstraint = {},
> {
  #name: Name
  #stores: Record<string, StoreDef<string, any, any, any>>
  #migrations: MigrationDef[]

  constructor(name: Name) {
    this.#name = name
    this.#stores = {}
    this.#migrations = []
  }

  create<SName extends string, Builder extends StoreBuilder<any, any, any>>(
    name: UnusedKey<SName, Schema>,
    callback: (builder: StoreBuilder<{}>) => Builder
  ) {
    if (this.#stores[name]) throw new Error('cannot add store ${name} - already exists')

    const builder = callback(new StoreBuilder())
    const store = builder.build(name)

    this.#stores[name] = store
    this.#migrations.push(['create', name, store])

    type FinalStore = Builder extends StoreBuilder<infer R, infer D, infer I>
      ? StoreDef<SName, R, D, I>
      : never
    return this as unknown as DatabaseBuilder<
      Name,
      Increment<Version>,
      Simplify<Schema & {[K in SName]: FinalStore}>
    >
  }

  modify<SName extends string, Builder extends StoreUpdater<any, any, any, any>>(
    name: ExtantKey<SName, Schema>,
    callback: (b: StoreUpdater<
      SName,
      Schema[SName]['__row'],
      Schema[SName]['__doc'],
      Schema[SName]['__indexes']
    >) => Builder
  ) {
    if (this.#stores[name] === undefined) throw new Error('cannot update store ${name} - does not exist')

    const extant = this.#stores[name satisfies string]
    type InputUpdater = StoreUpdater<
      SName,
      Schema[SName]['__row'],
      Schema[SName]['__doc'],
      Schema[SName]['__indexes']
    >
    const builder = new StoreUpdater(extant as any) as InputUpdater
    const store = callback(builder).build()

    this.#stores[name] = store
    this.#migrations.push(['update', name, store])

    type FinalStore = Builder extends StoreUpdater<any, infer R, infer D, infer I>
      ? StoreDef<SName, R, D, I>
      : never

    return this as unknown as DatabaseBuilder<
      Name,
      Increment<Version>,
      Simplify<Omit<Schema, SName> & {[K in SName]: FinalStore}>
    >
  }

  drop<SName extends string>(name: ExtantKey<SName, Schema>) {
    if (this.#stores[name] === undefined) throw new Error('cannot remove store ${name} - does not exist')

    this.#migrations.push(['drop', name, this.#stores[name]])
    delete this.#stores[name]

    return this as unknown as DatabaseBuilder<Name, Increment<Version>, Simplify<Omit<Schema, SName>>>
  }

  migrate<
    Write extends Record<string, RowConstraint>,
    NextSchema extends SchemaConstraint = Simplify<MergeRowChanges<Schema, Write>>,
  >(fn: MigrationFn<Schema, NextSchema>) {
    this.#migrations.push(fn)

    return this as unknown as DatabaseBuilder<Name, Increment<Version>, NextSchema>
  }

  build(): DatabaseDef<Name, Version, Schema> {
    return {
      name: this.#name,
      version: this.#migrations.length as Version,
      migrations: this.#migrations,
      stores: this.#stores,

      __schema: undefined as unknown as Schema,
    }
  }
}