import { Injectable } from '@nestjs/common';
import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
import { CompanyEntity } from './company.entity';
import { EntityManager, Like, Repository } from 'typeorm';
import { CompanyDto, CompanyQueryDto, CompanyUpdateDto } from './company.dto';
import { Pagination } from '~/helper/paginate/pagination';
import { paginate } from '~/helper/paginate';
import { Storage } from '../tools/storage/storage.entity';
import { BusinessException } from '~/common/exceptions/biz.exception';
import { ErrorEnum } from '~/constants/error-code.constant';
import { fieldSearch } from '~/shared/database/field-search';

@Injectable()
export class CompanyService {
  constructor(
    @InjectEntityManager() private entityManager: EntityManager,
    @InjectRepository(CompanyEntity)
    private companyRepository: Repository<CompanyEntity>,
    @InjectRepository(Storage)
    private storageRepository: Repository<Storage>
  ) {}

  /**
   * 查询所有公司
   */
  async findAll({
    page,
    pageSize,
    ...fields
  }: CompanyQueryDto): Promise<Pagination<CompanyEntity>> {
    const queryBuilder = this.companyRepository
      .createQueryBuilder('company')
      .leftJoin('company.files', 'files')
      .addSelect(['files.id', 'files.path'])
      .where(fieldSearch(fields))
      .andWhere('company.isDelete = 0');

    return paginate<CompanyEntity>(queryBuilder, {
      page,
      pageSize
    });
  }

  /**
   * 新增
   */
  async create(dto: CompanyDto): Promise<void> {
    await this.companyRepository.insert(dto);
  }

  /**
   * 更新
   */
  async update(id: number, { fileIds, ...data }: Partial<CompanyUpdateDto>): Promise<void> {
    await this.entityManager.transaction(async manager => {
      await manager.update(CompanyEntity, id, {
        ...data
      });
      const company = await this.companyRepository
        .createQueryBuilder('company')
        .leftJoinAndSelect('company.files', 'files')
        .where('company.id = :id', { id })
        .getOne();
      if (fileIds?.length) {
        const count = await this.storageRepository
          .createQueryBuilder('storage')
          .where('storage.id in(:fileIds)', { fileIds })
          .getCount();
        if (count !== fileIds?.length) {
          throw new BusinessException(ErrorEnum.STORAGE_NOT_FOUND);
        }
        // 附件要批量更新
        await manager
          .createQueryBuilder()
          .relation(CompanyEntity, 'files')
          .of(id)
          .addAndRemove(fileIds, company.files);
      }
    });
  }

  /**
   * 删除
   */
  async delete(id: number): Promise<void> {
    // 合同比较重要，做逻辑删除
    await this.companyRepository.update(id, { isDelete: 1 });
  }

  /**
   * 获取单个合同信息
   */
  async info(id: number) {
    const info = await this.companyRepository
      .createQueryBuilder('company')
      .where({
        id
      })
      .andWhere('company.isDelete = 0')
      .getOne();
    return info;
  }

  /**
   * 解除附件关联
   * @param id 合同ID
   * @param fileIds 附件ID
   */
  async unlinkAttachments(id: number, fileIds: number[]) {
    await this.entityManager.transaction(async manager => {
      const company = await this.companyRepository
        .createQueryBuilder('company')
        .leftJoinAndSelect('company.files', 'files')
        .where('company.id = :id', { id })
        .getOne();
      const linkedFiles = company.files
        .map(item => item.id)
        .filter(item => !fileIds.includes(item));
      // 附件要批量更新
      await manager
        .createQueryBuilder()
        .relation(CompanyEntity, 'files')
        .of(id)
        .addAndRemove(linkedFiles, company.files);
    });
  }
}