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 { DuplicateVehicleNameException } from '../../exceptions';
import { type CreateVehicleNameDto } from './dtos/create-vehicle-name.dto';
import { type VehicleNamePageOptionsDto } from './dtos/get-vehicle-name-page.dto';
import { type UpdateVehicleNameDto } from './dtos/update-vehicle-name.dto';
import { type VehicleNameDto } from './dtos/vehicle-name.dto';
import { VehicleNameEntity } from './vehicle-name.entity';

@Injectable()
export class VehicleNameService {
  constructor(
    @InjectRepository(VehicleNameEntity)
    private vehicleNameRepository: Repository<VehicleNameEntity>,
  ) {}

  async findOne(
    findData: FindOptionsWhere<VehicleNameEntity>,
  ): Promise<VehicleNameEntity | null> {
    const queryBuilder =
      this.vehicleNameRepository.createQueryBuilder('vehicleName');

    queryBuilder.where(findData);

    return queryBuilder.getOne();
  }

  async findMany(
    pageOptionsDto: VehicleNamePageOptionsDto,
    findData?: FindOptionsWhere<VehicleNameEntity>,
  ): Promise<PageDto<VehicleNameDto>> {
    const queryBuilder =
      this.vehicleNameRepository.createQueryBuilder('vehicleName');

    if (findData) {
      queryBuilder.where(findData);
    }

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

    return items.toPageDto(pageMetaDto);
  }

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

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

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

    const returnData = await queryBuilder.getMany();

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

  async createVehicleName(
    dto: CreateVehicleNameDto,
  ): Promise<VehicleNameEntity> {
    const vehicleNameEntity = this.vehicleNameRepository.create(dto);
    await this.vehicleNameRepository.save(vehicleNameEntity);

    return vehicleNameEntity;
  }

  async updateVehicleName(
    vehicleNameEntity: VehicleNameEntity,
    dto: UpdateVehicleNameDto,
  ): Promise<VehicleNameEntity> {
    const { name, isActive } = dto;

    if (name !== undefined) {
      const queryBuilder =
        this.vehicleNameRepository.createQueryBuilder('vehicleName');

      queryBuilder.andWhere('vehicleName.name = :name', { name });
      queryBuilder.andWhere('vehicleName.id != :id', {
        id: vehicleNameEntity.id,
      });

      const vehicleName = await queryBuilder.getOne();

      if (vehicleName) {
        throw new DuplicateVehicleNameException();
      }

      vehicleNameEntity.name = name;
    }

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

    await this.vehicleNameRepository.save(vehicleNameEntity);

    return vehicleNameEntity;
  }
}