import {
  BadRequestException,
  Injectable,
  Logger,
} from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { ClientConfig } from "src/entities/client-config";
import { HistClientConfig } from "src/entities/hist-client-config";
import { PaginateQuery } from "src/types/paginate-query";
import { GeneralException } from "src/util";
import { DataSource, Not, Repository } from "typeorm";
import { Client } from "../../entities/client";
import { BodyClientConfigDTO, DeleteClientConfigDTO } from "../dto/client.dto";
import { enumOperationClientConfig } from "../types/operation-client-config";

@Injectable()
export class ClientConfigService {
  private logger = new Logger(ClientConfigService.name)

  constructor(
    @InjectRepository(ClientConfig)
    private readonly clientConfigRepository: Repository<ClientConfig>,
    @InjectRepository(HistClientConfig)
    private readonly historicRepository: Repository<ClientConfig>,
    private readonly dataSource: DataSource,
  ) {}

  async findByClient(clientId, query: PaginateQuery) {
    const { size } = query;
    const page = +query.page || 0;
    const skip = page * size;
    return await this.clientConfigRepository.find({
      where: {
        clientId,
      },
      skip,
      take: size,
    });
  }

  async addConfig(data: BodyClientConfigDTO, session) {
    const clientExists = await this.dataSource.manager.countBy(Client, { id: data.clientId })
    if (!clientExists) {
      throw new GeneralException('client_not_found')
    }

    const queryRunner = this.dataSource.createQueryRunner();

    try {
      await queryRunner.startTransaction();

      // Inserir configuração
      const resultInsert = await queryRunner.manager.insert(ClientConfig, {
        ...data,
        usernameCreatedBy: session.username,
      });

      // Gravar na tabela de histórico
      await queryRunner.manager.insert(HistClientConfig, {
        operation: enumOperationClientConfig.CREATE,
        clientId: data.clientId,
        usernameOperation: session.username,
        typeClientConfigId: data.typeClientConfigId,
        numberMonths: data.numberMonths,
      });

      console.log(resultInsert.raw[0]);

      await queryRunner.commitTransaction();
      return resultInsert.identifiers[0].id;
    } catch (error) {
      this.logger.error('Erro ao adicionar configuração do cliente', error);
      await queryRunner.rollbackTransaction();
      if (error.constraint == 'client_config_client_id_type_client_config_id_uk') {
        throw new GeneralException('client_config_exists_with_type')
      }
      throw new BadRequestException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async updateConfig(id: number, data: BodyClientConfigDTO, session) {
    const clientExists = await this.dataSource.manager.countBy(Client, { id: data.clientId })
    if (!clientExists) {
      throw new GeneralException('client_not_found')
    }

    const clientConfigWithTypeExists = await this.clientConfigRepository.countBy({
      id: Not(id),
      clientId: data.clientId,
      typeClientConfigId: data.typeClientConfigId,
    })
    if (clientConfigWithTypeExists) {
      throw new GeneralException('client_config_exists_with_type')
    }
    const clientConfigExists = await this.clientConfigRepository.countBy({ id })
    if (!clientConfigExists) {
      throw new GeneralException('client_config_not_found')
    }

    const queryRunner = this.dataSource.createQueryRunner();

    try {
      await queryRunner.startTransaction();

      // Atualizar configuração
      await queryRunner.manager.update(ClientConfig, id, {
        ...data,
      });

      // Gravar na tabela de histórico
      await queryRunner.manager.insert(HistClientConfig, {
        operation: enumOperationClientConfig.UPDATE,
        clientId: data.clientId,
        usernameOperation: session.username,
        typeClientConfigId: data.typeClientConfigId,
        numberMonths: data.numberMonths,
      });

      await queryRunner.commitTransaction();
    } catch (error) {
      this.logger.error('Erro ao adicionar configuração do cliente', error);
      await queryRunner.rollbackTransaction();
      throw new BadRequestException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async deleteConfig(params: DeleteClientConfigDTO, session) {
    const clientExists = await this.dataSource.manager.countBy(Client, { id: params.clientId })
    if (!clientExists) {
      throw new GeneralException('client_not_found');
    }

    const queryRunner = this.dataSource.createQueryRunner();

    try {
      await queryRunner.startTransaction();

      // Remover configuração
      const resultDelete = await queryRunner.manager.delete(ClientConfig, {
        clientId: params.clientId,
        id: params.id,
      });

      if(resultDelete.affected === 0) {
        throw new GeneralException('client_config_not_found');
      }

      // Gravar na tabela de histórico
      await queryRunner.manager.insert(HistClientConfig, {
        operation: enumOperationClientConfig.DELETE,
        clientId: params.clientId,
        usernameOperation: session.username,
      });

      await queryRunner.commitTransaction();
    } catch (error) {
      this.logger.error('Erro ao adicionar configuração do cliente', error);
      await queryRunner.rollbackTransaction();
      throw new BadRequestException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async getHistorict(clientId: number, query: PaginateQuery) {
    const { size = 10 } = query;
    const page = +query.page || 0;
    const skip = page * size;

    const queryBuilder = this.dataSource
      .createQueryBuilder(HistClientConfig, "hist")
      .take(size)
      .skip(skip)
      .orderBy("hist.dateOperation");

    queryBuilder.where({ clientId });

    const content = await queryBuilder.getMany();
    const total = await queryBuilder.getCount();

    return {
      content,
      totalElements: total,
    };
  }
}