import type { GenericDatabaseReader } from "convex/server";
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import type { BaseDatabaseReader } from "@confect/core/Types";
import * as DatabaseSchema from "./DatabaseSchema";
import type * as DataModel from "./DataModel";
import * as QueryInitializer from "./QueryInitializer";
import * as Table from "./Table";

type IncludedTables<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
  | DatabaseSchema.Tables<DatabaseSchema_>
  | Table.SystemTables;

type IncludedDataModel<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> =
  DataModel.FromTables<IncludedTables<DatabaseSchema_>>;

export interface DatabaseReaderService<
  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
  Docs = {},
> {
  readonly table: <
    const TableName extends Table.Name<IncludedTables<DatabaseSchema_>>,
  >(
    tableName: TableName,
  ) => QueryInitializer.QueryInitializer<
    IncludedDataModel<DatabaseSchema_>,
    TableName,
    TableName extends keyof Docs
      ? Docs[TableName]
      : DataModel.DocumentWithName<
          IncludedDataModel<DatabaseSchema_>,
          TableName
        >
  >;
}

export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
  databaseSchema: DatabaseSchema_,
  convexDatabaseReader: GenericDatabaseReader<
    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
  >,
): DatabaseReaderService<DatabaseSchema_> => {
  return {
    table: <
      const TableName extends Table.Name<IncludedTables<DatabaseSchema_>>,
    >(
      tableName: TableName,
    ) => {
      const isSystem = Object.hasOwn(Table.systemTables, tableName);

      const baseDatabaseReader: BaseDatabaseReader<any> = isSystem
        ? {
            get: convexDatabaseReader.system.get.bind(
              convexDatabaseReader.system,
            ),
            query: convexDatabaseReader.system.query.bind(
              convexDatabaseReader.system,
            ),
          }
        : {
            get: convexDatabaseReader.get.bind(convexDatabaseReader),
            query: convexDatabaseReader.query.bind(convexDatabaseReader),
          };

      const table = (
        isSystem
          ? (Table.systemTables as Record<string, Table.AnyWithProps>)[
              tableName
            ]
          : DatabaseSchema.tables(databaseSchema)[tableName]
      ) as Table.WithName<IncludedTables<DatabaseSchema_>, TableName>;

      return QueryInitializer.make<IncludedTables<DatabaseSchema_>, TableName>(
        baseDatabaseReader,
        table,
      );
    },
  } as DatabaseReaderService<DatabaseSchema_>;
};

/**
 * The tag's _Identifier_ (the Effect requirements-channel type) is
 * `Docs`-independent so a helper's `R` channel is the same whether or not a
 * codegen document registry is supplied—this keeps it identical to what
 * `Handler`/runtime provisioning provide. The tag's _Service_ (what `yield*`
 * produces) carries `Docs`, so queries resolve to the named doc interfaces.
 */
export type DatabaseReaderTag<
  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
  Docs = {},
> = Context.Service<
  DatabaseReaderService<DatabaseSchema_>,
  DatabaseReaderService<DatabaseSchema_, Docs>
>;

export const DatabaseReader = <
  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
  Docs = {},
>(): DatabaseReaderTag<DatabaseSchema_, Docs> =>
  Context.Service<
    DatabaseReaderService<DatabaseSchema_>,
    DatabaseReaderService<DatabaseSchema_, Docs>
  >("@confect/server/DatabaseReader");

export type DatabaseReader<
  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
> = DatabaseReaderService<DatabaseSchema_>;

export const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
  databaseSchema: DatabaseSchema_,
  convexDatabaseReader: GenericDatabaseReader<
    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
  >,
) =>
  Layer.succeed(
    DatabaseReader<DatabaseSchema_>(),
    make(databaseSchema, convexDatabaseReader),
  );