import { EntityManager, QueryOrder } from "@mikro-orm/postgresql";
import { BadRequestException, Injectable } from "@nestjs/common";

import { CommonMessage, CriticismMessage } from "../../../common/enums/message.enum";
import { Business } from "../../businesses/entities/business.entity";
import { UsersService } from "../../users/services/users.service";
import { PaginationUtils } from "../../utils/providers/pagination.utils";
import { CreateCriticismDto } from "../DTO/create-criticism.dto";
import { SearchCriticismQueryDto } from "../DTO/search-criticism-query.dto";
import { Criticism } from "../entities/criticism.entity";
import { CriticismRepository } from "../repositories/criticisms.repository";

@Injectable()
export class CriticismsService {
  constructor(
    private readonly criticismRepository: CriticismRepository,
    private readonly usersService: UsersService,
    private readonly em: EntityManager,
  ) {}

  async create(createDto: CreateCriticismDto, userId: string, business: Business) {
    const em = this.em.fork();
    try {
      em.begin();

      const user = await this.usersService.findOneByIdWithEntityManager(userId, em);
      const files =
        createDto.files?.map((file) => {
          return { fileUrl: file };
        }) || [];
      const criticism = em.create(Criticism, { ...createDto, user, files, business });
      await em.persistAndFlush(criticism);

      await em.commit();
      return {
        message: CommonMessage.CREATED,
        criticism,
      };
    } catch (error) {
      await em.rollback();
      throw error;
    }
  }

  //#####################################  ##

  async findAll(queryDto: SearchCriticismQueryDto, businessId: string) {
    const { limit, skip } = PaginationUtils(queryDto);

    const queryBuilder = this.criticismRepository.createQueryBuilder("criticism");

    queryBuilder.where({ business: { id: businessId } });

    if (queryDto.since) {
      queryBuilder.andWhere({ createdAt: { $gte: queryDto.since } });
    }

    if (queryDto.q) {
      queryBuilder.andWhere({ title: { $ilike: `%${queryDto.q}%` } });
      queryBuilder.andWhere({ content: { $ilike: `%${queryDto.q}%` } });
    }

    queryBuilder.orderBy({ createdAt: QueryOrder.DESC });

    const [criticisms, count] = await queryBuilder.offset(skip).limit(limit).getResultAndCount();

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

  //#####################################  ##

  async findOneAndMarkAsRead(id: string, businessId: string) {
    const criticism = await this.criticismRepository.findOne({ id, business: { id: businessId } });
    if (!criticism) throw new BadRequestException(CriticismMessage.NOT_FOUND);
    criticism.isRead = true;

    await this.em.flush();
    return {
      criticism,
    };
  }

  //#####################################  ##

  async delete(id: string, businessId: string) {
    const criticism = await this.criticismRepository.findOne({ id, business: { id: businessId } });
    if (!criticism) throw new BadRequestException(CriticismMessage.NOT_FOUND);

    await this.em.removeAndFlush(criticism);

    return {
      message: CommonMessage.DELETED,
    };
  }
}