import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { PipelinesClientService } from 'src/clients/pipelines/client.service';
import { IIdRequest, Info } from 'src/clients/pipelines/interfaces';
import { objectCamelToSnake } from 'src/utils/CaseConverter';

@Injectable()
export class PipelinesService {
  constructor(private pipelineClient: PipelinesClientService) {}

  async create(createPipelineDto) {
    try {
      const createPipelineResponse = await this.pipelineClient.create(
        createPipelineDto,
      );

      return objectCamelToSnake(createPipelineResponse);
    } catch (err) {
      console.log(err);
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async findOne(data: IIdRequest) {
    try {
      const findOnePipelineResponse = await this.pipelineClient.findOne(data);
      return objectCamelToSnake(findOnePipelineResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async findAll(data) {
    try {
      const findAllPipelineResponse = await this.pipelineClient.findAll(data);

      return objectCamelToSnake(findAllPipelineResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async update(id: string, data, info: Info) {
    try {
      const updatePipelineResponse = await this.pipelineClient.update({
        id,
        info,
        ...data,
      });

      return objectCamelToSnake(updatePipelineResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async remove(data: IIdRequest) {
    try {
      const removePipelineResponse = await this.pipelineClient.remove(data);

      return removePipelineResponse;
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async getPipelineLogsMessages(id: string, details: string) {
    try {
      const pipelineLogsResponse =
        await this.pipelineClient.getPipelineLogsMessages({ id, details });

      return objectCamelToSnake(pipelineLogsResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async getPipelineStatus(data: IIdRequest) {
    try {
      const pipelineStatusResponse =
        await this.pipelineClient.getPipelineStatus(data);

      return objectCamelToSnake(pipelineStatusResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }

  async runPipeline({ id, info }: IIdRequest) {
    try {
      const triggerPipelineResponse = await this.pipelineClient.runPipeline({
        id,
        info,
      });

      return objectCamelToSnake(triggerPipelineResponse);
    } catch (err) {
      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
    }
  }
}