import { BadRequestException, Injectable } from "@nestjs/common";

import { CityMessage, ProvinceMessage } from "../../../common/enums/message.enum";
import { PaginationUtils } from "../../utils/providers/pagination.utils";
import { SearchCitiesDto } from "../DTO/cities-search-query.dto";
import { CityRepository } from "../repositories/city.repository";
import { ProvinceRepository } from "../repositories/province.repository";

@Injectable()
export class AddressService {
  constructor(
    private readonly cityRepository: CityRepository,
    private readonly provinceRepository: ProvinceRepository,
  ) {}

  async getAllCities(queryDto: SearchCitiesDto) {
    const { limit, skip } = PaginationUtils(queryDto);

    const queryBuilder = this.cityRepository.createQueryBuilder("city");

    if (queryDto.q) {
      queryBuilder.andWhere("city.name ILIKE :q", { q: `%${queryDto.q}%` });
    }

    queryBuilder.skip(skip).take(limit);

    const [cities, count] = await queryBuilder.getManyAndCount();

    return {
      cities,
      count,
      paginate: true,
    };
  }

  async getAllProvinces(queryDto: SearchCitiesDto) {
    const { limit, skip } = PaginationUtils(queryDto);

    const queryBuilder = this.provinceRepository.createQueryBuilder("province");

    if (queryDto.q) {
      queryBuilder.andWhere("province.name ILIKE :q", { q: `%${queryDto.q}%` });
    }

    queryBuilder.skip(skip).take(limit);

    const [provinces, count] = await queryBuilder.getManyAndCount();

    return {
      provinces,
      count,
      paginate: true,
    };
  }

  async getProvince(id: number) {
    const province = await this.provinceRepository.findOneBy({
      id,
    });
    if (!province) throw new BadRequestException(CityMessage.NOT_FOUND);

    return { province };
  }

  async getCity(id: number) {
    const city = await this.cityRepository.findOneBy({
      id,
    });
    if (!city) throw new BadRequestException(CityMessage.NOT_FOUND);

    return { city };
  }

  async getCitiesByProvince(queryDto: SearchCitiesDto, id: number) {
    const { limit, skip } = PaginationUtils(queryDto);

    const province = await this.provinceRepository.findOneBy({
      id,
    });
    if (!province) throw new BadRequestException(CityMessage.NOT_FOUND);

    const queryBuilder = this.cityRepository.createQueryBuilder("city").where("city.provinceId = :provinceId", { provinceId: province.id });
    if (queryDto.q) {
      queryBuilder.andWhere("city.name ILIKE :q", { q: `%${queryDto.q}%` });
    }

    queryBuilder.skip(skip).take(limit);

    const [cities, count] = await queryBuilder.getManyAndCount();

    return {
      cities,
      count,
      pagination: true,
    };
  }

  async getProvinceByCity(id: number) {
    const province = await this.provinceRepository.findOne({
      where: {
        cities: {
          id,
        },
      },
    });
    if (!province) throw new BadRequestException(ProvinceMessage.NOT_FOUND);

    return { province };
  }
}