import {
  BadRequestException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { CreateProvinceDto } from './dto/create-province.dto';
import { UpdateProvinceDto } from './dto/update-province.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Province } from './entities/province.entity';
import { ProvincesRepository } from './provinces.repository';
import { Repository } from 'typeorm';
import isValidUuidV4 from 'src/common/uuid validator/uuid-validate';
import { lan } from 'src/lan';
import { isEmpty } from 'src/common/helper';

@Injectable()
export class ProvincesService {
  constructor(
    @InjectRepository(Province)
    private readonly provinceEntity: Repository<Province>,
    private readonly provinceRepository: ProvincesRepository,
  ) {}

  async create(createProvinceDto: CreateProvinceDto) {
    if (await this.provinceRepository.isUnique(createProvinceDto.name)) {
      throw new BadRequestException(lan('data_already_exists'));
    }

    const province = new Province();

    Object.assign(province, createProvinceDto);
    const data = await this.provinceEntity.save(province);

    return data;
  }

  async findAll(take: number, skip: number, headers: any) {
    return this.provinceRepository.findAllProvince(take, skip, headers);
  }

  async findOne(id: string) {
    if (!isValidUuidV4(id)) {
      throw new BadRequestException(lan('common.invalid_uuid_format'));
    }

    const data = await this.provinceRepository.findById(id);

    if (isEmpty(data)) {
      throw new NotFoundException(lan('common.data_not_found'));
    }
    return data;
  }

  async update(id: string, updateProvinceDto: UpdateProvinceDto) {
    if (await this.provinceRepository.isUnique(updateProvinceDto.name, id)) {
      throw new BadRequestException(lan('data_already_exists'));
    }

    const data = await this.provinceRepository.findById(id);

    if (isEmpty(data)) {
      throw new NotFoundException(lan('common.data_not_found'));
    }

    const province = new Province();
    Object.assign(province, updateProvinceDto);

    const updatedProvince = await this.provinceEntity.update(id, province);

    return updatedProvince;
  }

  async remove(id: string) {
    if (!isValidUuidV4(id)) {
      throw new BadRequestException(lan('common.invalid_uuid_format'));
    }

    const province = await this.provinceRepository.findById(id);

    if (isEmpty(province)) {
      throw new NotFoundException(lan('common.data_not_found'));
    }

    await this.provinceEntity.softDelete(id);
  }
}