import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { DataSource, Repository, UpdateResult } from 'typeorm';
import { PageDto, FilterRepository } from 'upsti-lib-common';

import { {{moduleName}} } from '../entities/{{toLowerCase moduleName}}.entity';

import { Delete{{moduleName}}DTO } from './dtos/{{toLowerCase moduleName}}-delete.dto';
import { Search{{moduleName}}DTO } from './dtos/{{toLowerCase moduleName}}-search.dto';

@Injectable()
export class {{moduleName}}Repository extends Repository<{{moduleName}}> {
  private filter: FilterRepository<{{moduleName}}>;

  constructor(private dataSource: DataSource) {
    super({{moduleName}}, dataSource.createEntityManager());
    this.filter = FilterRepository.getInstance();
  }

  async search(request: Search{{moduleName}}DTO): Promise<PageDto<{{moduleName}}>> {
    this.filter.queryBuilder = this.dataSource
      .getRepository({{moduleName}})
      .createQueryBuilder('{{toLowerCase moduleName}}');

    if (request.id) {
      this.filter.addFilter({
        filter: 'id',
        value: request.id,
        isString: false,
      });
    }

    if (request.active !== undefined) {
      this.filter.addFilter({
        filter: 'active',
        value: request.active,
        isString: false,
      });
    }
    if (request.getOrderByCriterias().length > 0) {
      request.getOrderByCriterias().forEach((orderByDto) => {
        this.filter.orderBy(orderByDto);
      });
    }

    return await this.filter.getPaginatedList(request.getOffset(), request.getTake());
  }

  async findById(id: number): Promise<{{moduleName}}> {
    const {{toLowerCase moduleName}} = await this.createQueryBuilder('{{toLowerCase moduleName}}')
      .where('{{toLowerCase moduleName}}.id = :id')
      .setParameter('id', id)
      .getOne();
    if (!{{toLowerCase moduleName}}) {
      throw new NotFoundException(`No se encontro el registro: ${id}`);
    }
    return {{toLowerCase moduleName}};
  }

  async logicalDeletes({{toLowerCase moduleName}}Ids: Delete{{moduleName}}DTO) {
    {{toLowerCase moduleName}}Ids.ids.forEach(async (id) => {
      const {{toLowerCase moduleName}} = await this.findOneBy({
        id,
      });

      if (!{{toLowerCase moduleName}}) {
        throw new NotFoundException(`No se encontro el registro: ${id}`);
      }

      await this.update(id, { isActive: false });
      const logicalDelete = await this.softDelete(id);
      if (!logicalDelete.affected) {
        throw new BadRequestException(`No se pudo eliminar el registro: ${id}`);
      }
      return logicalDelete;
    });
  }

  async logicalDelete(id: number): Promise<UpdateResult> {
    const {{toLowerCase moduleName}} = await this.findOneBy({
      id,
    });
    if (!{{toLowerCase moduleName}}) {
      throw new NotFoundException(`No se encontro el registro: ${id}`);
    }
    await this.update(id, { isActive: false });
    return await this.softDelete(id);
  }
}