import { Model, FilterQuery, UpdateQuery, Types, Document, QueryOptions, UpdateResult, DeleteResult, ClientSession } from 'mongoose';
import { UpdateOptions } from 'mongodb';

export interface WithId {
  _id: Types.ObjectId;
  id?: string;
}

export interface SoftDeletable {
  deleted?: boolean;
  deletedAt?: Date;
}

export interface RepositoryOptions {
  useSoftDelete?: boolean;
}

export interface PaginationOptions {
  page: number;
  pageSize: number;
  sort?: Record<string, 1 | -1>;
}

export interface PaginationResult<T> {
  items: T[];
  total: number;
  page: number;
  pageSize: number;
  totalPages: number;
  hasNext: boolean;
  hasPrev: boolean;
}

export interface SearchOptions {
  fields: string[];
  query: string;
  caseSensitive?: boolean;
}

export type SoftDeleteResult = { type: 'soft'; result: UpdateResult | null };
export type HardDeleteResult = { type: 'hard'; result: DeleteResult | null };

export function toObjectId(id: string | Types.ObjectId): Types.ObjectId {
  if (id instanceof Types.ObjectId) {
    return id;
  }
  return new Types.ObjectId(id);
}

export function validateObjectId(id: string): boolean {
  return Types.ObjectId.isValid(id);
}

export class BaseRepository<T extends Document & WithId & Partial<SoftDeletable>> {
  protected options: RepositoryOptions;

  constructor(
    protected readonly model: Model<T>,
    options: RepositoryOptions = { useSoftDelete: true }
  ) {
    this.options = { useSoftDelete: true, ...options };
  }

  protected buildFilter(filter: FilterQuery<T> = {}): FilterQuery<T> {
    if (this.options.useSoftDelete) {
      return { ...filter, deleted: { $ne: true } } as any;
    }
    return filter;
  }

  protected validateId(id: string | Types.ObjectId): void {
    if (typeof id === 'string' && !validateObjectId(id)) {
      throw new Error(`Invalid ObjectId: ${id}`);
    }
  }

  toObjectId(id: string | Types.ObjectId): Types.ObjectId {
    return toObjectId(id);
  }

  async findById(id: string | Types.ObjectId, projection: any = {}, options: QueryOptions = {}): Promise<T | null> {
    this.validateId(id);
    return this.model.findOne(this.buildFilter({ _id: toObjectId(id) }), projection, options).exec() as unknown as Promise<T | null>;
  }

  async findByIds(ids: string[] | Types.ObjectId[], projection: any = {}, options: QueryOptions = {}): Promise<T[]> {
    ids.forEach(id => this.validateId(id));
    return this.model.find(this.buildFilter({ _id: { $in: ids.map(toObjectId) } }), projection, options).exec() as unknown as Promise<T[]>;
  }

  async find(filter: FilterQuery<T> = {}, projection: any = {}, options: QueryOptions = {}): Promise<T[]> {
    return this.model.find(this.buildFilter(filter), projection, options).exec() as unknown as Promise<T[]>;
  }

  async findOne(filter: FilterQuery<T> = {}, projection: any = {}, options: QueryOptions = {}): Promise<T | null> {
    return this.model.findOne(this.buildFilter(filter), projection, options).exec() as Promise<T | null>;
  }

  async findQuery(filter: FilterQuery<T> = {}, projection: any = {}, options: QueryOptions = {}): Promise<T[]> {
    return this.model.find(this.buildFilter(filter), projection, options).exec() as unknown as Promise<T[]>;
  }

  async search(searchOptions: SearchOptions, filter: FilterQuery<T> = {}, projection: any = {}, options: QueryOptions = {}): Promise<T[]> {
    const { fields, query, caseSensitive = false } = searchOptions;
    const searchConditions = fields.map(field => ({
      [field]: { $regex: query, $options: caseSensitive ? '' : 'i' }
    }));

    const searchFilter = { ...filter, $or: searchConditions };
    return this.find(searchFilter, projection, options);
  }

  async findWithSort(
    filter: FilterQuery<T> = {},
    sort: Record<string, 1 | -1> = { createdAt: -1 },
    projection: any = {},
    options: QueryOptions = {}
  ): Promise<T[]> {
    return this.find(filter, projection, { sort, ...options });
  }

  async count(filter: FilterQuery<T> = {}): Promise<number> {
    return this.model.countDocuments(this.buildFilter(filter)).exec();
  }

  async exists(filter: FilterQuery<T> = {}): Promise<boolean> {
    return !!(await this.model.exists(this.buildFilter(filter)));
  }

  async create(doc: Partial<T>, session?: ClientSession): Promise<T> {
    if (session) {
      const [result] = await this.model.create([doc], { session });
      return result as T;
    }
    return this.model.create(doc) as Promise<T>;
  }

  async createMany(docs: Partial<T>[], session?: ClientSession): Promise<T[]> {
    const options = session ? { session } : {};
    return this.model.insertMany(docs, options) as unknown as Promise<T[]>;
  }

  async updateById(
    id: string | Types.ObjectId,
    update: UpdateQuery<T>,
    options: UpdateOptions & QueryOptions = { new: true, timestamps: true }
  ): Promise<T | null> {
    this.validateId(id);
    return this.model.findByIdAndUpdate(toObjectId(id), update, options).exec() as unknown as Promise<T | null>;
  }

  async updateOne(
    filter: FilterQuery<T>,
    update: UpdateQuery<T>,
    options: UpdateOptions & QueryOptions = { timestamps: true }
  ): Promise<UpdateResult | null> {
    return this.model.updateOne(this.buildFilter(filter), update, options).exec() as unknown as Promise<UpdateResult | null>;
  }

  async updateMany(
    filter: FilterQuery<T>,
    update: UpdateQuery<T>,
    options: UpdateOptions & QueryOptions = { timestamps: true }
  ): Promise<UpdateResult | null> {
    return this.model.updateMany(this.buildFilter(filter), update, options).exec() as unknown as Promise<UpdateResult | null>;
  }

  async updateManyByIds(ids: string[] | Types.ObjectId[], update: UpdateQuery<T>, options: UpdateOptions & QueryOptions = { timestamps: true }): Promise<UpdateResult | null> {
    ids.forEach(id => this.validateId(id));
    return this.model.updateMany(this.buildFilter({ _id: { $in: ids.map(toObjectId) } }), update, options).exec() as unknown as Promise<UpdateResult | null>;
  }

  async removeById(id: string | Types.ObjectId): Promise<T | null> {
    this.validateId(id);
    if (this.options.useSoftDelete) {
      return this.softDeleteById(id);
    }
    return this.model.findByIdAndDelete(toObjectId(id)).exec();
  }

  async removeMany(filter: FilterQuery<T>): Promise<SoftDeleteResult | HardDeleteResult> {
    if (this.options.useSoftDelete) {
      return { type: 'soft', result: await this.softDeleteMany(filter) as unknown as UpdateResult | null };
    }
    return { type: 'hard', result: await this.model.deleteMany(filter).exec() as unknown as DeleteResult | null };
  }

  async paginate(
    filter: FilterQuery<T> = {},
    paginationOptions: PaginationOptions,
    projection: any = {},
    options: QueryOptions = {},
  ): Promise<PaginationResult<T>> {
    const { page, pageSize, sort = { createdAt: -1 } } = paginationOptions;
    const skip = (page - 1) * pageSize;

    const [items, total] = await Promise.all([
      this.find(filter, projection, { ...options, skip, limit: pageSize, sort }),
      this.count(filter),
    ]);

    const totalPages = Math.ceil(total / pageSize);

    return {
      items,
      total,
      page,
      pageSize,
      totalPages,
      hasNext: page < totalPages,
      hasPrev: page > 1,
    };
  }

  async aggregate(pipeline: any[], session?: ClientSession): Promise<any[]> {
    if (this.options.useSoftDelete) {
      pipeline.unshift({ $match: { deleted: { $ne: true } } });
    }
    const options = session ? { session } : {};
    return this.model.aggregate(pipeline, options).exec();
  }

  async groupBy(
    groupField: string,
    filter: FilterQuery<T> = {},
    countField = 'count'
  ): Promise<any[]> {
    return this.aggregate([
      { $match: filter },
      { $group: { _id: `$${groupField}`, [countField]: { $sum: 1 } } },
      { $sort: { [countField]: -1 } }
    ]);
  }

  async distinct(field: string, filter: FilterQuery<T> = {}): Promise<any[]> {
    return this.model.distinct(field, this.buildFilter(filter)).exec();
  }

  async bulkWrite(ops: any[], session?: ClientSession): Promise<any> {
    const options = session ? { session } : {};
    return this.model.bulkWrite(ops, options);
  }

  async findNear(
    coordinates: [number, number],
    maxDistance = 5000,
    filter: FilterQuery<T> = {},
  ): Promise<T[]> {
    return this.model.find({
      ...this.buildFilter(filter),
      location: {
        $near: {
          $geometry: { type: 'Point', coordinates },
          $maxDistance: maxDistance,
        },
      },
    }).exec();
  }

  async findOneAndUpdate(
    filter: FilterQuery<T>,
    update: UpdateQuery<T>,
    options: QueryOptions = {},
  ): Promise<T | null> {
    return this.model.findOneAndUpdate(
      this.buildFilter(filter),
      update,
      { new: true, ...options },
    ).exec() as unknown as Promise<T | null>;
  }

  async upsert(
    filter: FilterQuery<T>,
    update: UpdateQuery<T>,
    docIfNew: Partial<T> = {},
  ): Promise<T | null> {
    return this.model.findOneAndUpdate(
      this.buildFilter(filter),
      { $set: update, $setOnInsert: docIfNew },
      { upsert: true, new: true },
    ).exec() as unknown as Promise<T | null>;
  }

  async findOrCreate(
    filter: FilterQuery<T>,
    docIfNew: Partial<T> = {},
  ): Promise<T> {
    let item = await this.findOne(filter);
    if (!item) item = await this.create(docIfNew);
    return item;
  }

  async incrementById(id: string | Types.ObjectId, field: string, value: number = 1): Promise<T | null> {
    this.validateId(id);
    return this.model.findByIdAndUpdate(
      toObjectId(id),
      { $inc: { [field]: value } } as any,
      { new: true },
    ).exec();
  }

  async decrementById(id: string | Types.ObjectId, field: string, value: number = 1): Promise<T | null> {
    return this.incrementById(id, field, -value);
  }

  async incrementMany(filter: FilterQuery<T>, field: string, value: number = 1): Promise<UpdateResult | null> {
    return this.updateMany(filter, { $inc: { [field]: value } } as any);
  }

  async findRandom(filter: FilterQuery<T> = {}, limit = 1): Promise<T[]> {
    return this.aggregate([
      { $match: filter },
      { $sample: { size: limit } }
    ]);
  }

  async findAll(
    filter: FilterQuery<T> = {},
    projection: any = {},
    options: QueryOptions = {},
  ): Promise<T[]> {
    return this.model.find(filter, projection, options).exec() as unknown as Promise<T[]>;
  }

  async softDeleteById(id: string | Types.ObjectId): Promise<T | null> {
    if (!this.options.useSoftDelete) {
      throw new Error('Soft delete is not enabled for this repository');
    }
    this.validateId(id);
    const update: any = { deleted: true, deletedAt: new Date() };
    return this.model.findByIdAndUpdate(toObjectId(id), update, { new: true }).exec();
  }

  async softDeleteMany(filter: FilterQuery<T>): Promise<UpdateResult | null> {
    if (!this.options.useSoftDelete) {
      throw new Error('Soft delete is not enabled for this repository');
    }
    const update: any = { deleted: true, deletedAt: new Date() };
    return this.model.updateMany(this.buildFilter(filter), update).exec() as unknown as Promise<UpdateResult | null>;
  }

  async restoreById(id: string | Types.ObjectId): Promise<T | null> {
    if (!this.options.useSoftDelete) {
      throw new Error('Soft delete is not enabled for this repository');
    }
    this.validateId(id);
    return this.model.findByIdAndUpdate(toObjectId(id), { deleted: false, deletedAt: null }, { new: true }).exec();
  }

  async restoreMany(filter: FilterQuery<T>): Promise<UpdateResult | null> {
    if (!this.options.useSoftDelete) {
      throw new Error('Soft delete is not enabled for this repository');
    }
    return this.model.updateMany(
      { ...filter, deleted: true } as any,
      { deleted: false, deletedAt: null }
    ).exec() as unknown as Promise<UpdateResult | null>;
  }

  async findDeleted(
    filter: FilterQuery<T> = {},
    projection: any = {},
    options: QueryOptions = {},
  ): Promise<T[]> {
    if (!this.options.useSoftDelete) {
      throw new Error('Soft delete is not enabled for this repository');
    }
    return this.model.find({ ...filter, deleted: true } as any, projection, options).exec() as unknown as Promise<T[]>;
  }

  async hardDeleteById(id: string | Types.ObjectId): Promise<T | null> {
    this.validateId(id);
    return this.model.findByIdAndDelete(toObjectId(id)).exec();
  }

  async hardDeleteMany(filter: FilterQuery<T>): Promise<DeleteResult | null> {
    return this.model.deleteMany(filter).exec() as unknown as Promise<DeleteResult | null>;
  }

  async getStats(filter: FilterQuery<T> = {}): Promise<{
    total: number;
    active: number;
    deleted: number;
  }> {
    const [total, active, deleted] = await Promise.all([
      this.model.countDocuments(filter).exec(),
      this.count(filter),
      this.options.useSoftDelete ?
        this.model.countDocuments({ ...filter, deleted: true }).exec() :
        0
    ]);

    return { total, active, deleted };
  }

  async findDuplicates(field: string): Promise<any[]> {
    return this.aggregate([
      { $group: { _id: `$${field}`, count: { $sum: 1 }, docs: { $push: '$_id' } } },
      { $match: { count: { $gt: 1 } } }
    ]);
  }
}