import type { Mongoose } from "../../packages";
import type { NSchemeService } from "../services";
import type { Nullable, UnknownObject } from "../utils";

export interface IMongoTunnel {
  setModels(models: NMongoTunnel.SchemaInfo[]): void;
  getRepository<S>(): NMongoTunnel.Repository<S>;
}

export namespace NMongoTunnel {
  export type Create = <T>(
    model: string,
    docs: Mongoose.Docs<T>,
    options: Mongoose.SaveOptions
  ) => Promise<Mongoose.AnyKeys<T>>;

  export type InsertMany = <TRawDocType>(
    model: string,
    docs: Mongoose.Docs<TRawDocType>,
    options?: Mongoose.InsertManyOptions
  ) => Promise<Mongoose.InsertManyResult>;

  export type Aggregate = <TRawDocType>(
    model: string,
    pipeline?: Mongoose.PipelineStage[],
    options?: Mongoose.AggregateOptions
  ) => Promise<Mongoose.AggregateResult<TRawDocType>>;

  export type Hydrate = <TRawDocType>(
    model: string,
    obj: UnknownObject,
    projection?: Mongoose.AnyObject,
    options?: Mongoose.HydrateOptions
  ) => Promise<Mongoose.HydrateResult<TRawDocType>>;

  export type Populate = <TRawDocType>(
    model: string,
    docs: Array<Mongoose.Docs<TRawDocType>>,
    options: Mongoose.PopulateOptions | Array<Mongoose.PopulateOptions> | string
  ) => Promise<Mongoose.PopulateResult<TRawDocType>>;

  export type Validate = (
    name: string,
    optional: unknown,
    pathsToValidate: Mongoose.PathsToValidate
  ) => Promise<void>;

  export type CountDocuments = <TRawDocType>(
    model: string,
    filter?: Mongoose.FilterQuery<TRawDocType>,
    options?: Mongoose.QueryOptions<TRawDocType>
  ) => Promise<Mongoose.CountDocumentsResult<TRawDocType>>;

  export type Exists = <TRawDocType>(
    model: string,
    filter: Mongoose.FilterQuery<TRawDocType>
  ) => Promise<Mongoose.ExistsResult<TRawDocType>>;

  export type Find = <TRawDocType>(
    model: string,
    filter: Mongoose.FilterQuery<TRawDocType>,
    projection?: Nullable<Mongoose.ProjectionType<TRawDocType>>,
    options?: Nullable<Mongoose.QueryOptions<TRawDocType>>
  ) => Mongoose.FindResult<TRawDocType>;

  export type FindById = <
    TRawDocType,
    ResultDoc = Mongoose.THydratedDocumentType<TRawDocType>
  >(
    model: string,
    id: string,
    projection?: Mongoose.ProjectionType<TRawDocType | null>,
    options?: Mongoose.QueryOptions<TRawDocType | null>
  ) => Promise<Mongoose.FindByIdResult<ResultDoc>>;

  export type FindByIdAndUpdate = <
    TRawDocType,
    ResultDoc = Mongoose.THydratedDocumentType<TRawDocType>
  >(
    model: string,
    id: string,
    update: Mongoose.UpdateQuery<TRawDocType>,
    options: Mongoose.QueryOptions<TRawDocType> & { rawResult?: true }
  ) => Promise<Mongoose.FindByIdAndUpdateResult<ResultDoc>>;

  export type FindByIdAndDelete = <
    TRawDocType,
    ResultDoc = Mongoose.THydratedDocumentType<TRawDocType>
  >(
    model: string,
    id: string,
    options?: Mongoose.QueryOptions<TRawDocType>
  ) => Promise<Mongoose.FindByIdAndDeleteResult<ResultDoc>>;

  export type FindOne = <
    TRawDocType,
    ResultDoc = Mongoose.THydratedDocumentType<TRawDocType>
  >(
    model: string,
    filter?: Mongoose.FilterQuery<TRawDocType>,
    projection?: Mongoose.ProjectionType<TRawDocType>,
    options?: Mongoose.QueryOptions<TRawDocType>
  ) => Promise<Mongoose.FindOneResult<ResultDoc>>;

  export type Repository<P> = {
    create: Create<P>;
    insertMany: InsertMany<P>;
    aggregate: Aggregate<P>;
    hydrate: Hydrate<P>;
    populate: Populate<P>;
    validate: Validate<P>;
    countDocuments: CountDocuments<P>;
    exists: Exists<P>;
    find: Find<P>;
    findById: FindById<P>;
    findByIdAndUpdate: FindByIdAndUpdate<P>;
    findByIdAndDelete: FindByIdAndDelete<P>;
    findOne: FindOne<P>;
    findOneAndUpdate: IMongoTunnel["findOneAndUpdate"];
    findOneAndReplace: IMongoTunnel["findOneAndReplace"];
    findOneAndDelete: IMongoTunnel["findOneAndDelete"];
    updateOne: IMongoTunnel["updateOne"];
    updateMany: IMongoTunnel["updateMany"];
    replaceOne: IMongoTunnel["replaceOne"];
    deleteOne: IMongoTunnel["deleteOne"];
    deleteMany: IMongoTunnel["deleteMany"];
  };

  export type Schema<T> = {
    definition: Mongoose.SchemaDefinition<T>;
    options?: Mongoose.SchemaOptions;
  };

  export type SchemaInfo<T = any> = {
    model: string;
    getSchema: SchemaFn<T>;
  };
  export type SchemaFn<T> = (agents: NSchemeService.Agents) => Schema<T>;
}