import type { StorageTable } from '@prisma-next/sql-contract/types';
import type { AnyFromSource, TableSource } from '@prisma-next/sql-relational-core/ast';
import type {
  AggregateFunctions,
  Expression,
  ExpressionBuilder,
  ExtractScopeFields,
  FieldProxy,
  Functions,
  WithField,
  WithFields,
} from '../expression';
import type {
  EmptyRow,
  Expand,
  JoinOuterScope,
  JoinSource,
  MergeScopes,
  NullableScope,
  QueryContext,
  RebindScope,
  Scope,
  ScopeField,
  ScopeTable,
  StorageTableToScopeTable,
  Subquery,
} from '../scope';
import type { NamespaceTable, TableProxyContract } from '../types/db';
import type { JoinedTables } from '../types/joined-tables';
import type { DeleteQuery, InsertQuery, UpdateQuery } from '../types/mutation-query';
import type { SelectQuery } from '../types/select-query';
import type { LateralBuilder } from '../types/shared';
import type { TableProxy } from '../types/table-proxy';
import { BuilderBase, type BuilderContext, emptyState, tableToScope } from './builder-base';
import { JoinedTablesImpl } from './joined-tables-impl';
import {
  buildParamValues,
  buildSetExpressions,
  DeleteQueryImpl,
  evaluateUpdateCallback,
  InsertQueryImpl,
  UpdateQueryImpl,
  type UpdateSetCallback,
} from './mutation-impl';
import { SelectQueryImpl } from './query-impl';
import { tableSourceForProxy } from './table-source-for-proxy';

export class TableProxyImpl<
    C extends TableProxyContract,
    Name extends string,
    Alias extends string,
    AvailableScope extends Scope,
    QC extends QueryContext,
    NsId extends string = string,
  >
  extends BuilderBase<C['capabilities']>
  implements TableProxy<C, NsId, Name, Alias, AvailableScope, QC>
{
  declare readonly [JoinOuterScope]: JoinSource<
    StorageTableToScopeTable<NamespaceTable<C, NsId, Name>>,
    Alias
  >[typeof JoinOuterScope];

  readonly #tableName: string;
  readonly #table: StorageTable;
  readonly #namespaceId: string;
  readonly #fromSource: TableSource;
  readonly #scope: Scope;

  constructor(
    tableName: string,
    table: StorageTable,
    alias: string,
    ctx: BuilderContext,
    namespaceId: string,
  ) {
    super(ctx);
    this.#tableName = tableName;
    this.#table = table;
    this.#namespaceId = namespaceId;
    this.#scope = tableToScope(alias, table, {
      storage: ctx.storage,
      tableName,
      namespaceId,
    });
    this.#fromSource = tableSourceForProxy(tableName, alias, namespaceId);
  }

  lateralJoin = this._gate(
    { sql: { lateral: true } },
    'lateralJoin',
    <LAlias extends string, LateralRow extends Record<string, ScopeField>>(
      alias: LAlias,
      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
    ): JoinedTables<
      QC,
      MergeScopes<AvailableScope, { topLevel: LateralRow; namespaces: Record<LAlias, LateralRow> }>
    > => {
      return this.#toJoined().lateralJoin(alias, builder);
    },
  ) as TableProxy<C, NsId, Name, Alias, AvailableScope, QC>['lateralJoin'];

  outerLateralJoin = this._gate(
    { sql: { lateral: true } },
    'outerLateralJoin',
    <LAlias extends string, LateralRow extends Record<string, ScopeField>>(
      alias: LAlias,
      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
    ): JoinedTables<
      QC,
      MergeScopes<
        AvailableScope,
        NullableScope<{ topLevel: LateralRow; namespaces: Record<LAlias, LateralRow> }>
      >
    > => {
      return this.#toJoined().outerLateralJoin(alias, builder);
    },
  ) as TableProxy<C, NsId, Name, Alias, AvailableScope, QC>['outerLateralJoin'];

  getJoinOuterScope(): Scope {
    return this.#scope;
  }

  buildAst(): AnyFromSource {
    return this.#fromSource;
  }

  as<NewAlias extends string>(
    newAlias: NewAlias,
  ): TableProxy<C, NsId, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>, QC> {
    return new TableProxyImpl<
      C,
      Name,
      NewAlias,
      RebindScope<AvailableScope, Alias, NewAlias>,
      QC,
      NsId
    >(this.#tableName, this.#table, newAlias, this.ctx, this.#namespaceId);
  }

  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
    ...columns: Columns
  ): SelectQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>;
  select<LAlias extends string, Field extends ScopeField>(
    alias: LAlias,
    expr: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Expression<Field>,
  ): SelectQuery<QC, AvailableScope, WithField<EmptyRow, Field, LAlias>>;
  select<Result extends Record<string, Expression<ScopeField>>>(
    callback: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Result,
  ): SelectQuery<QC, AvailableScope, Expand<ExtractScopeFields<Result>>>;
  select(...args: unknown[]): unknown {
    return new SelectQueryImpl(emptyState(this.#fromSource, this.#scope), this.ctx).select(
      ...(args as string[]),
    );
  }

  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(
    other: Other,
    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
  ): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>> {
    return this.#toJoined().innerJoin(other, on);
  }

  outerLeftJoin<Other extends JoinSource<ScopeTable, string | never>>(
    other: Other,
    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
  ): JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<Other[typeof JoinOuterScope]>>> {
    return this.#toJoined().outerLeftJoin(other, on);
  }

  outerRightJoin<Other extends JoinSource<ScopeTable, string | never>>(
    other: Other,
    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
  ): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, Other[typeof JoinOuterScope]>> {
    return this.#toJoined().outerRightJoin(other, on);
  }

  outerFullJoin<Other extends JoinSource<ScopeTable, string | never>>(
    other: Other,
    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
  ): JoinedTables<
    QC,
    MergeScopes<NullableScope<AvailableScope>, NullableScope<Other[typeof JoinOuterScope]>>
  > {
    return this.#toJoined().outerFullJoin(other, on);
  }

  insert(rows: ReadonlyArray<Record<string, unknown>>): InsertQuery<QC, AvailableScope, EmptyRow> {
    return new InsertQueryImpl(
      this.#fromSource,
      this.#namespaceId,
      this.#table,
      this.#scope,
      rows,
      this.ctx,
    );
  }

  update(
    setOrCallback:
      | Record<string, unknown>
      | ((
          fields: FieldProxy<AvailableScope>,
          fns: Functions<QC>,
        ) => Record<string, Expression<ScopeField> | undefined>),
  ): UpdateQuery<QC, AvailableScope, EmptyRow> {
    if (typeof setOrCallback === 'function') {
      const callbackExprs = evaluateUpdateCallback(
        setOrCallback as UpdateSetCallback,
        this.#scope,
        this.ctx.queryOperationTypes,
        this.ctx.rawCodecInferer,
      );
      const setExpressions = buildSetExpressions(
        callbackExprs,
        this.#namespaceId,
        this.#table,
        this.#tableName,
        'update',
        this.ctx,
      );
      return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
    }
    const setExpressions = buildParamValues(
      setOrCallback,
      this.#namespaceId,
      this.#table,
      this.#tableName,
      'update',
      this.ctx,
    );
    return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
  }

  delete(): DeleteQuery<QC, AvailableScope, EmptyRow> {
    return new DeleteQueryImpl(this.#fromSource, this.#scope, this.ctx);
  }

  #toJoined(): JoinedTables<QC, AvailableScope> {
    return new JoinedTablesImpl(emptyState(this.#fromSource, this.#scope), this.ctx);
  }
}