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

import { type PageDto } from '../../common/dto/page.dto';
import {
  DuplicateSectorException,
  SectorIsInUsedException,
} from '../../exceptions';
import { ActivityRecordSettingService } from '../activity-record/activity-record-setting.service';
import { type CreateSectorDto } from './dtos/create-sector.dto';
import { type SectorPageOptionsDto } from './dtos/get-sector-page.dto';
import { type SectorDto } from './dtos/sector.dto';
import { type UpdateSectorDto } from './dtos/update-sector.dto';
import { SectorEntity } from './sector.entity';

@Injectable()
export class SectorService {
  constructor(
    @InjectRepository(SectorEntity)
    private sectorRepository: Repository<SectorEntity>,
    @Inject(forwardRef(() => ActivityRecordSettingService))
    private activitySettingService: ActivityRecordSettingService,
  ) {}

  async findOne(
    findData: FindOptionsWhere<SectorEntity>,
  ): Promise<SectorEntity | null> {
    const queryBuilder = this.sectorRepository.createQueryBuilder('sector');

    queryBuilder.where(findData);

    return queryBuilder.getOne();
  }

  async findMany(
    pageOptionsDto: SectorPageOptionsDto,
  ): Promise<PageDto<SectorDto>> {
    const { name } = pageOptionsDto;

    const queryBuilder = this.sectorRepository.createQueryBuilder('sector');

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

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

    return items.toPageDto(pageMetaDto);
  }

  async findManyDropdown(): Promise<Array<{ name: string; value: string }>> {
    const queryBuilder = this.sectorRepository.createQueryBuilder('sector');

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

    const returnData = await queryBuilder.getMany();

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

  async createSector(dto: CreateSectorDto): Promise<SectorEntity> {
    const sectorEntity = this.sectorRepository.create(dto);
    await this.sectorRepository.save(sectorEntity);

    return sectorEntity;
  }

  async updateSector(
    sectorEntity: SectorEntity,
    dto: UpdateSectorDto,
  ): Promise<SectorEntity> {
    const { name } = dto;

    if (name !== undefined) {
      const existingSector = await this.findOne({
        name,
      });

      if (existingSector) {
        throw new DuplicateSectorException();
      }

      sectorEntity.name = name;
    }

    await this.sectorRepository.save(sectorEntity);

    return sectorEntity;
  }

  async delete(sectorEntity: SectorEntity): Promise<void> {
    const existingActivitySetting = await this.activitySettingService.findOne({
      sector: { id: sectorEntity.id },
    });

    if (existingActivitySetting) {
      throw new SectorIsInUsedException();
    }

    await this.sectorRepository.remove(sectorEntity);
  }
}