import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { BaseRepository } from '@devstroupe/devkit-nest';
import { IPaginator } from '@devstroupe/devkit-core';
import { IUserRepository } from '../../domain/user.repository';
import { User } from '../../domain/user';
import { UserOrmEntity } from './user.orm-entity';

@Injectable()
export class UserRepositoryAdapter extends BaseRepository<UserOrmEntity> implements IUserRepository {
  constructor(
    @InjectRepository(UserOrmEntity)
    private readonly repo: Repository<UserOrmEntity>,
  ) {
    super(repo);
  }

  private toDomain(orm: UserOrmEntity): User {
    return {
      id: orm.id,
      name: orm.name,
      email: orm.email,
      password: orm.password,
      role: orm.role,
      tenantId: orm.tenantId,
      currentRefreshToken: orm.currentRefreshToken,
      isActive: orm.isActive,
      createdAt: orm.createdAt,
      updatedAt: orm.updatedAt,
    };
  }

  async create(user: Omit<User, 'id'>): Promise<User> {
    const created = this.repo.create(user);
    const saved = await this.repo.save(created);
    return this.toDomain(saved);
  }

  async update(id: number, user: Partial<User>): Promise<User> {
    await this.repo.update(id, user);
    const updated = await this.findById(id);
    if (!updated) throw new Error('User not found after update');
    return updated;
  }

  async findById(id: number): Promise<User | null> {
    const found = await this.repo.findOne({ where: { id } });
    return found ? this.toDomain(found) : null;
  }

  async findByEmail(email: string): Promise<User | null> {
    const found = await this.repo.findOne({ where: { email } });
    return found ? this.toDomain(found) : null;
  }

  async findAll(): Promise<User[]> {
    const found = await this.repo.find({ relations: ['role'] });
    return found.map((u) => this.toDomain(u));
  }

  async findMany(filter: any): Promise<IPaginator<User>> {
    const alias = 'user';
    const qb = this.repo.createQueryBuilder(alias);
    qb.leftJoinAndSelect(`${alias}.role`, 'role');
    const paginated = await this.paginate(qb, filter, {
      allowedFilters: ['name', 'email', 'isActive'],
      allowedSorts: ['id', 'name', 'email'],
      searchableFields: ['name', 'email'],
    });

    return {
      items: paginated.items.map((u) => this.toDomain(u)),
      meta: paginated.meta,
    };
  }

  async delete(id: number): Promise<void> {
    await this.repo.delete(id);
  }
}