import { HttpException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { SalesForceLevel } from 'src/entities/salesForceLevel';
import { DataSource, Repository } from 'typeorm';
import { QuerySalesForceLevelDto, SalesForceLevelDto } from './dto/sales-force-level.dto';
import { Client } from 'src/entities/client';
import { Session } from 'src/middleware/keyclock.middleware';

@Injectable()
export class SalesForceLevelService {
  constructor(
    @InjectRepository(SalesForceLevel)
    private salesForceLevelRepository: Repository<SalesForceLevel>,
    @InjectRepository(Client)
    private clientRepository: Repository<Client>,
  ) { }


  async postSalesForceLevel(clientId: number, body: SalesForceLevelDto, session: Session): Promise<SalesForceLevel> {

    const client = await this.clientRepository.findOne({ where: { id: clientId } })

    if (!client) {
      throw new HttpException('client_id_not_found', 404)
    }
    const salesForceLevel = new SalesForceLevel();
    salesForceLevel.description = body.description;
    salesForceLevel.enabled = body.enabled;
    salesForceLevel.color = body.color;
    salesForceLevel.useChannel = body.useChannel;
    salesForceLevel.createBy = session.username;
    salesForceLevel.updateBy = session.username;
    salesForceLevel.enabledAt = new Date();
    salesForceLevel.clientId = clientId;
    await this.salesForceLevelRepository.save(salesForceLevel);
    
    return salesForceLevel;
  }
  async putSalesForceLevel(clientId: number, salesForceLevelId: number, body: SalesForceLevelDto, session: Session): Promise<SalesForceLevel> {
    const client = await this.clientRepository.findOne({ where: { id: clientId } })

    if (!client) {
      throw new HttpException('client_id_not_found', 404)
    }
    const salesForceLevel = await this.salesForceLevelRepository.findOneBy({ id: salesForceLevelId, clientId })
    if (!client) {
      throw new HttpException('sales_force_level_id_to_client_id_not_found', 404)
    }
    salesForceLevel.description = body.description;
    salesForceLevel.useChannel = body.useChannel;
    salesForceLevel.updateBy = session.username;
    salesForceLevel.color = body.color;
    if (salesForceLevel.enabled !== body.enabled)
      salesForceLevel.enabledAt = new Date();

    salesForceLevel.enabled = body.enabled;

    await this.salesForceLevelRepository.save(salesForceLevel);
    return salesForceLevel;
  }
  async getSalesForceLevel(query: QuerySalesForceLevelDto): Promise<any> {

    const {
      description,
      enabled,
      clientId,
      useChannel,
      pageNumber,
      pageRows,
      orderBy,
      sort,
    } = query;
    const skip = (+pageNumber - 1) * +pageRows;
    try {

      const orderList = {
        description: 'sfl.description',
        id: 'sfl.id',
        enabled: 'sfl.enabled',
        useChannel: 'sfl.useChannel'
      };

      if (!orderList[orderBy]) {
        throw new HttpException(
          'colluns_orderby_invalid',
          503,
        );
      }
      let whereUseChannel = ''
      if (String(useChannel) === 'true') {
        whereUseChannel = 'and sfl.useChannel = true'
      }
      else if (String(useChannel) === 'false') {
        whereUseChannel = 'and sfl.useChannel = false'
      }

      let whereEnabled = ''
      if (String(enabled) === 'true')
        whereEnabled = 'and sfl.enabled = true'
      else if (String(enabled) === 'false') {
        whereEnabled = 'and sfl.enabled = false'
      }

      let whereClientId = ''
      if (clientId)
        whereClientId = `and sfl.clientId = ${+clientId}`


      const [recordset, count] =
        await this.salesForceLevelRepository
          .createQueryBuilder('sfl')
          .where(
            ` sfl.description ilike :description ${whereUseChannel} ${whereEnabled} ${whereClientId}`,
            { description: `%${description || ''}%` },
          )
          .skip(+skip)
          .take(+pageRows)
          .orderBy(orderList['id'], sort)
          .getManyAndCount();

      return { recordset, count };
    } catch (error) {
      return { recordset: [], count: 0 };
    }
  }
  async deleteSalesForceLevel(clientId: number, salesForceLevelId: number, session: Session): Promise<SalesForceLevel> {
    const client = await this.clientRepository.findOne({ where: { id: clientId } })

    if (!client) {
      throw new HttpException('client_id_not_found', 404)
    }
    const salesForceLevel = await this.salesForceLevelRepository.findOneBy({ id: salesForceLevelId, clientId })
    if (!client) {
      throw new HttpException('sales_force_level_id_to_client_id_not_found', 404)
    }
    salesForceLevel.deleteBy = session.username;
    await this.salesForceLevelRepository.softRemove(salesForceLevel);
    return salesForceLevel;
  }
}