import { Injectable, HttpException, HttpStatus, Inject } from '@nestjs/common';
import { DataConsultRepository } from './data-consult.repository';
import { StoreDto } from './dto/store.dto';
import { SellerDto } from './dto/seller.dto';
import { BillingDto } from './dto/billing.dto';
import { CustomerDto } from './dto/customer.dto';
import { ProductDto } from './dto/product.dto';
import { ILogger } from '../Log/ILogger';
import { RedisClientToken } from '../core/configs/cache/redis-client.adapter.provider';
import { IRedisClient } from '../core/configs/cache/IRedisClient';
import { getOrSetCache } from '../shared/cache.util';
import { DataSource } from 'typeorm';
import { DATA_SOURCE } from '../core/constants';

@Injectable()
export class DataConsultService {
  private readonly SELLERS_CACHE_KEY = 'data-consult:sellers';
  private readonly SELLERS_TTL = 3600;     
  private readonly STORES_TTL = 3600;
  private readonly BILLINGS_TTL = 3600;
  private readonly ALL_PRODUCTS_CACHE_KEY = 'data-consult:products:all';
  private readonly ALL_PRODUCTS_TTL = 600; 

  constructor(
    private readonly repository: DataConsultRepository,
    @Inject(RedisClientToken) private readonly redisClient: IRedisClient,
    @Inject('LoggerService') private readonly logger: ILogger,
    @Inject(DATA_SOURCE) private readonly dataSource: DataSource
  ) {}

  /**
   * Obter todas as lojas
   * @returns Array de StoreDto
   */
  async stores(): Promise<StoreDto[]> {
    this.logger.log('Buscando todas as lojas');
    try {
      const stores = await this.repository.findStores();
      return stores.map(store => new StoreDto(store));
    } catch (error) {
      this.logger.error('Erro ao buscar lojas', error);
      throw new HttpException('Erro ao buscar lojas', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  /**
   * Obter todos os vendedores
   * @returns Array de SellerDto
   */
  async sellers(): Promise<SellerDto[]> {
    this.logger.log('Buscando vendedores com cache Redis...');
    try {
      return getOrSetCache<SellerDto[]>(
        this.redisClient,
        this.SELLERS_CACHE_KEY,
        this.SELLERS_TTL,
        async () => {
          const sellers = await this.repository.findSellers();
          return sellers.map(seller => new SellerDto(seller));
        }
      );
    } catch (error) {
      this.logger.error('Erro ao buscar vendedores', error);
      throw new HttpException('Erro ao buscar vendedores', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }    

  /**
   * @returns Array de BillingDto
   */
  async billings(): Promise<BillingDto[]> {
    this.logger.log('Buscando informações de faturamento');
    try {
      const billings = await this.repository.findBillings();
      return billings.map(billing => new BillingDto(billing));
    } catch (error) {
      this.logger.error('Erro ao buscar faturamento', error);
      throw new HttpException('Erro ao buscar faturamento', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  /**
   * Obter clientes filtrados por termo de pesquisa
   * @param filter - Termo de pesquisa para filtrar clientes
   * @returns Array de CustomerDto
   */
  async customers(filter: string): Promise<CustomerDto[]> {
    this.logger.log(`Buscando clientes com filtro: ${filter}`);
    try {
      if (!filter || typeof filter !== 'string') {
        throw new HttpException('Filtro inválido', HttpStatus.BAD_REQUEST);
      }
      const customers = await this.repository.findCustomers(filter);
      return customers.map(customer => new CustomerDto(customer));
    } catch (error) {
      this.logger.error('Erro ao buscar clientes', error);
      throw new HttpException('Erro ao buscar clientes', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  /**
   * Obter produtos filtrados por termo de pesquisa
   * @param filter - Termo de pesquisa para filtrar produtos
   * @returns Array de ProductDto
   */
  async products(filter: string): Promise<ProductDto[]> {
    this.logger.log(`Buscando produtos com filtro: ${filter}`);
    try {
      if (!filter || typeof filter !== 'string') {
        throw new HttpException('Filtro inválido', HttpStatus.BAD_REQUEST);
      }
      const products = await this.repository.findProducts(filter);
      return products.map(product => new ProductDto(product));
    } catch (error) {
      this.logger.error('Erro ao buscar produtos', error);
      throw new HttpException('Erro ao buscar produtos', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }

  async getAllProducts(): Promise<ProductDto[]> {
    this.logger.log('Buscando todos os produtos');
    try {
      return getOrSetCache<ProductDto[]>(
        this.redisClient,
        this.ALL_PRODUCTS_CACHE_KEY,
        this.ALL_PRODUCTS_TTL,
        async () => {
          const products = await this.repository.findAllProducts();
          return products.map(product => new ProductDto(product));
        }
      );
    } catch (error) {
      this.logger.error('Erro ao buscar todos os produtos', error);
      throw new HttpException('Erro ao buscar produtos', HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }
}