import {
  Controller,
  Delete,
  Get,
  Inject,
  OnModuleInit,
  Param,
  Post,
  Put,
} from '@nestjs/common';
import {
  Client,
  ClientGrpc,
  MessagePattern,
  Payload,
} from '@nestjs/microservices';
import { ApiTags } from '@nestjs/swagger';
import { TransformationsServiceInterface } from '@victorradael/protospack';
import { ICreateTransformationElement, ICreateTransformationsRequest, IdRequest, IUpdateTransformationRequest } from './interfaces';

@Controller('transformation')
export class TransformationsClientService implements OnModuleInit {
  private transformationService: TransformationsServiceInterface;
  constructor(
    @Inject('TRANSFORMATIONS_PACKAGE') private readonly grpcClient: ClientGrpc,
  ) {}

  onModuleInit() {
    this.transformationService =
      this.grpcClient.getService<TransformationsServiceInterface>(
        'TransformationService',
      );
  }

  @Post()
  async create(createTransformationsDto: ICreateTransformationsRequest) {
    console.log('TransformationClientService', 'Create');

    const createTransformationResponse = await new Promise((resolve, reject) => {
      this.transformationService.create(createTransformationsDto).subscribe({
        next(x) {
          resolve(x);
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });
    return createTransformationResponse;
  }

  async findAll() {
    console.log('TransformationClientService', 'FindAll');

    const findAllTransformationResponse = await new Promise((resolve, reject) => {
      this.transformationService.findAll({}).subscribe({
        next(x) {
          resolve(x);
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return findAllTransformationResponse;
  }

  async findOne({id}: IdRequest) {
    console.log('TransformationClientService', 'FindOne');

    const findOneTransformationResponse = await new Promise((resolve, reject) => {
      this.transformationService.findOne({id}).subscribe({
        next(x) {
          resolve(x);
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return findOneTransformationResponse;
  }

  async update(updateTransformationDTO: IUpdateTransformationRequest) {
    console.log('TransformationClientService', 'Update');

    const updateTransformationResponse = await new Promise((resolve, reject) => {
      this.transformationService.update(updateTransformationDTO).subscribe({
        next(x) {
          resolve(x);
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return updateTransformationResponse;
  }

  async remove({id}: IdRequest) {
    console.log('TransformationClientService', 'Remove');

    const removeTransformationResponse = await new Promise((resolve, reject) => {
      this.transformationService.remove({id}).subscribe({
        next(x) {
          resolve(x);
        },
        error(err) {
          console.log('Observable Error');
          reject(err);
        },
        complete() {
          console.log('done');
        },
      });
    })
      .then((res) => res)
      .catch((err) => {
        throw new Error(err);
      });

    return removeTransformationResponse;
  }
}