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 { IRoleRepository } from '../../domain/role.repository';
import { Role } from '../../domain/role';
import { RoleOrmEntity } from './role.orm-entity';

@Injectable()
export class RoleRepositoryAdapter extends BaseRepository<RoleOrmEntity> implements IRoleRepository {
  constructor(
    @InjectRepository(RoleOrmEntity)
    private readonly repo: Repository<RoleOrmEntity>,
  ) {
    super(repo);
  }

  private toDomain(orm: RoleOrmEntity): Role {
    return {
      id: orm.id,
      name: orm.name,
      permissions: orm.permissions || [],
    };
  }

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

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

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

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

  async findAll(): Promise<Role[]> {
    const found = await this.repo.find();
    return found.map(orm => this.toDomain(orm));
  }

  async findMany(query: any): Promise<IPaginator<Role>> {
    const qb = this.repo.createQueryBuilder('role');
    const paginated = await this.paginate(qb, query, {
      allowedFilters: ['name'],
      allowedSorts: ['id', 'name'],
      searchableFields: ['name'],
    });
    return {
      items: paginated.items.map((orm) => this.toDomain(orm)),
      meta: paginated.meta,
    };
  }

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