import {
  Injectable,
  InternalServerErrorException,
  Logger,
  NotFoundException,
} from '@nestjs/common';
import { DataSource, In, ILike, Not, Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import {
  ApplicationCreateDTO,
  ApplicationUpdateDTO,
} from './dto/application.dto';
import { Application } from '../entities/application';
import { ApplicationTranslation } from 'src/entities/application-translation';
import { ApplicationClient } from '../entities/applicationClient';
import { MinioService } from 'src/provider/minio/minio.service';
import { GeneralException } from 'src/util/general.exception';
import { ApplicationProfile } from 'src/entities/application-profile';
import { ApplicationUser } from 'src/entities/application-user';
import { User } from 'src/entities/user';

@Injectable()
export class ApplicationService {
  private readonly logger = new Logger(ApplicationService.name);

  constructor(
    private dataSource: DataSource,
    @InjectRepository(Application)
    private applicationRepository: Repository<Application>,
    @InjectRepository(ApplicationClient)
    private applicationClientRepository: Repository<ApplicationClient>,
    @InjectRepository(ApplicationProfile)
    private applicationProfileRepository: Repository<ApplicationProfile>,
    private readonly minioService: MinioService,
    @InjectRepository(ApplicationUser)
    private appUserRepository: Repository<ApplicationUser>,
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  getApplication() {
    return this.applicationRepository.find({
      relations: ['translations'],
      order: {
        id: 'ASC',
      },
    });
  }

  getApplicationByName(name: string) {
    return this.applicationRepository.findOne({
      relations: ['translations'],
      where: {
        translations: {
          name: ILike(name)
        }
      },
    });
  }

  // TRAZ AS APLICAÇÕES DE TODOS OS CLIENTES QUE O EMAIL TEM VINCULO
  async getApplicationForClient({ email }) {
    const user = await this.userRepository.findOneBy({ email });

    const applicationProfile = await this.appUserRepository.find({
      select: ['applicationClientId'],
      where: { userId: user.id },
    });

    const idsApp = applicationProfile.map((app) => app.applicationClientId);

    const apps = await this.applicationClientRepository
      .createQueryBuilder('appClient')
      .whereInIds(idsApp)
      // .andWhere({ clientId: 20 }) Atualmente não temos como receber o id do cliente
      .innerJoinAndSelect('appClient.application', 'application')
      .innerJoinAndSelect('application.translations', 'appTranslation')
      .orderBy('appClient.id', 'ASC')
      .getMany();

    const { URL_CCM_API } = process.env;

    const dataViews = apps.map(({ application }) => ({
      ...application,
      urlImage: application.objectNameMinio
        ? `${URL_CCM_API}/images/${application.objectNameMinio}.png`
        : '',
    }));

    return dataViews;
  }

  getApplicationById(id: number) {
    return this.applicationRepository.findOne({
      where: { id },
      relations: ['translations'],
    });
  }

  async postApplication(body: ApplicationCreateDTO) {
    const queryRunner = this.dataSource.createQueryRunner();
    const translationSavedIds: number[] = [];

    const haveName = body.translations.find((it) => it.name.length > 0);
    if (!haveName) {
      throw new GeneralException('application_name_required');
    }

    try {
      await queryRunner.startTransaction();

      const saveResult = await this.applicationRepository.insert({
        url: body.url,
        type: body.type,
        ...body,
      });
      const applicationId: number = saveResult.raw[0].id;

      for await (const translation of body.translations) {
        const saveResult = await queryRunner.manager.insert(
          ApplicationTranslation,
          {
            ...translation,
            applicationId,
          },
        );
        translationSavedIds.push(saveResult.raw[0].id);
      }

      if (body.exclusiveClientId) {
        await this.addExclusiveClient(applicationId, {
          exclusiveClientId: body.exclusiveClientId,
          url: body.url,
        });
      }

      await queryRunner.commitTransaction();
      return applicationId;
    } catch (error) {
      await queryRunner.rollbackTransaction();
      this.logger.error(error);
      throw new InternalServerErrorException();
    } finally {
      await queryRunner.release();
    }
  }

  async putApplication(id: number, body: ApplicationUpdateDTO) {
    const applicationExists = await this.applicationRepository.findOneBy({
      id,
    });

    if (!applicationExists) {
      throw new NotFoundException();
    }

    const queryRunner = this.dataSource.createQueryRunner();
    const translationSavedIds: number[] = [];

    try {
      await queryRunner.startTransaction();

      if (body.objectNameMinio && applicationExists.objectNameMinio) {
        await this.minioService.deleteObject(applicationExists.objectNameMinio);
      }

      await this.applicationRepository.update(id, {
        url: body.url,
        type: body.type,
        objectNameMinio: body.objectNameMinio || undefined,
      });

      for await (const translation of body.translations) {
        const { id: appTranslationId } = await queryRunner.manager.save(
          ApplicationTranslation,
          {
            ...translation,
            applicationId: id,
          },
        );
        translationSavedIds.push(appTranslationId);
      }

      await queryRunner.manager.delete(ApplicationTranslation, {
        applicationId: id,
        id: Not(In(translationSavedIds)),
      });

      const application = await this.applicationRepository.findOneOrFail({
        where: { id },
        relations: ['translations'],
      });
      await queryRunner.commitTransaction();
      return application;
    } catch (error) {
      await queryRunner.rollbackTransaction();
      this.logger.error(error.message);
      throw new InternalServerErrorException();
    } finally {
      await queryRunner.release();
    }
  }

  async enable(id: number): Promise<Application> {
    const application = await this.applicationRepository.findOneBy({ id });
    if (!application) {
      throw new NotFoundException();
    }

    return this.applicationRepository.save({
      ...application,
      enabled: true,
    });
  }

  async disable(id: number): Promise<Application> {
    const application = await this.applicationRepository.findOneBy({ id });
    if (!application) {
      throw new NotFoundException();
    }

    return this.applicationRepository.save({
      ...application,
      enabled: false,
    });
  }

  async deleteApplication(id: number) {
    const applicationClient = await this.applicationClientRepository.findOne({
      where: { applicationId: id },
    });

    if (applicationClient) {
      throw new GeneralException('application_delete_error_client_linked');
    }

    const applicationProfile = await this.applicationProfileRepository.findOne({
      where: { applicationId: id },
    });

    if (applicationProfile) {
      throw new GeneralException('application_delete_error_profile_linked');
    }

    const applicationExists = await this.applicationRepository.findOneBy({
      id,
    });

    if (!applicationExists) {
      throw new NotFoundException();
    }

    if (applicationExists.objectNameMinio) {
      await this.minioService.deleteObject(applicationExists.objectNameMinio);
    }

    return await this.applicationRepository.delete(id);
  }

  async addExclusiveClient(applicationId: number, { exclusiveClientId, url }) {
    await this.applicationClientRepository.insert({
      applicationId: applicationId,
      clientId: exclusiveClientId,
      url: url,
      enabled: true,
      enabledAt: new Date(),
    });
  }
}