import { Injectable } from "@nestjs/common"
import { InjectRepository } from "@nestjs/typeorm"
import { Not, Repository } from "typeorm"
import { BaseAbstractRepository } from "../../../common/repository/base.repository"
import { MisBusinessKpis } from "../entities/mis-business-kpis.entity"

@Injectable()
export class MisBusinessKpiRepository extends BaseAbstractRepository<MisBusinessKpis> {
  constructor(
    @InjectRepository(MisBusinessKpis)
    private readonly misBusinessKpisRepository: Repository<MisBusinessKpis>,
  ) {
    super(misBusinessKpisRepository)
  }

  async fetchKpisWithFilters(params: {
    companyId: number
    departmentId?: number
    search?: string
    skip: number
    take: number
  }) {
    const { companyId, departmentId, search, skip, take } = params

    const query = this.misBusinessKpisRepository
      .createQueryBuilder("kpi")
      .leftJoinAndSelect("kpi.departments", "department")
      .leftJoinAndSelect("department.parentDepartment", "parentDepartment")
      .where("kpi.company_id = :companyId", { companyId })

    if (departmentId) {
      query.andWhere("parentDepartment.id = :departmentId", {
        departmentId,
      })
    }

    if (search) {
      query.andWhere("kpi.name ILIKE :search", {
        search: `%${search}%`,
      })
    }

    query
      .select([
        "kpi.id",
        "kpi.name",
        "department.id",
        "department.name",
        "parentDepartment.id",
        "parentDepartment.name",
      ])
      .orderBy("kpi.name", "ASC")
      .skip(skip)
      .take(take)

    const data = query.getManyAndCount()

    return data
  }

  async isKpiNameTaken(
    name: string,
    companyId: number,
    excludeId?: number,
  ): Promise<boolean> {
    const whereCondition: any = {
      name: name.trim(),
      company_id: companyId,
    }

    if (excludeId) {
      whereCondition.id = Not(excludeId)
    }

    return this.misBusinessKpisRepository.exist({
      where: whereCondition,
    })
  }
}