import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { type FindOptionsWhere, Repository } from 'typeorm';

import { type PageDto } from '../../common/dto/page.dto';
import { BlockEntity } from './block.entity';
import { type BlockDto } from './dtos/block.dto';
import { type CreateBlockDto } from './dtos/create-block.dto';
import { type BlockPageOptionsDto } from './dtos/get-block-page.dto';
import { type UpdateBlockDto } from './dtos/update-block.dto';

@Injectable()
export class BlockService {
  constructor(
    @InjectRepository(BlockEntity)
    private blockRepository: Repository<BlockEntity>,
  ) {}

  async findOne(
    findData: FindOptionsWhere<BlockEntity>,
  ): Promise<BlockEntity | null> {
    const queryBuilder = this.blockRepository.createQueryBuilder('block');

    queryBuilder.where(findData);

    return queryBuilder.getOne();
  }

  async findMany(
    pageOptionsDto: BlockPageOptionsDto,
  ): Promise<PageDto<BlockDto>> {
    const { order, isActive, name } = pageOptionsDto;

    const queryBuilder = this.blockRepository.createQueryBuilder('block');

    if (name !== undefined) {
      queryBuilder.searchByString(name, ['block.name']);
    }

    if (isActive !== undefined) {
      queryBuilder.andWhere('block.isActive = :isActive', { isActive });
    }

    queryBuilder.orderBy('block.name', order);

    const [items, pageMetaDto] = await queryBuilder.paginate(pageOptionsDto);

    return items.toPageDto(pageMetaDto);
  }

  async findManyDropdown(
    showInactive = false,
  ): Promise<Array<{ name: string; value: string }>> {
    const queryBuilder = this.blockRepository.createQueryBuilder('block');

    if (!showInactive) {
      queryBuilder.where('block.isActive = :status', { status: true });
    }

    queryBuilder.orderBy('block.name', 'ASC');

    const returnData = await queryBuilder.getMany();

    return returnData.map((el) => ({
      name: el.name,
      value: el.name,
    }));
  }

  async createBlock(dto: CreateBlockDto): Promise<BlockEntity> {
    const blockEntity = this.blockRepository.create(dto);
    await this.blockRepository.save(blockEntity);

    return blockEntity;
  }

  async updateblock(
    blockEntity: BlockEntity,
    dto: UpdateBlockDto,
  ): Promise<BlockEntity> {
    const { isActive, name } = dto;

    if (isActive !== undefined) {
      blockEntity.isActive = isActive;
    }

    if (name !== undefined) {
      blockEntity.name = name;
    }

    await this.blockRepository.save(blockEntity);

    return blockEntity;
  }
}