import { OnQueueCompleted, OnQueueFailed, Process, Processor } from '@nestjs/bull';
import { Job } from 'bull';
import { JobData } from '../models/data.model';
import { CloudService } from '../cloud/cloud.service';
import { DeviceService } from '../device/device.service';
import { DbService } from '../db/db.service';
import { SocketService } from '../socket/socket.service';
import { QService } from './q.service';
import { EVENTS, hash } from '../const';

@Processor('device-request')
export class CertificateProcessor {
  constructor(
    private readonly qService: QService,
    private readonly cloudService: CloudService,
    private readonly deviceService: DeviceService,
    private readonly db: DbService,
    private readonly socketService: SocketService
  ) {
  }

  @Process('certificate')
  async certificate(job: Job<JobData>) {
    const errorResponse = {
      error: {
        log: job.data.metadata
      },
      metadata: job.data.metadata,
      time: Date.now()
    };
    await this.db.add(hash(job.data.metadata.sn), EVENTS.TRY_GET_CERTIFICATE, errorResponse);
    return this.cloudService.getCert(job.data.payload.id);
  }

  @OnQueueFailed()
  async fail(job: Job<JobData>, error: any) {
    const errorResponse = {
      error: {
        log: error
      },
      metadata: job.data.metadata,
      time: Date.now()
    };
    await this.db.add(hash(job.data.metadata.sn), EVENTS.CERTIFICATE_ERROR, errorResponse);
    this.socketService.send({ event: EVENTS.CERTIFICATE_ERROR });
    console.log('CERT JOB FAILS', error);
  }

  @OnQueueCompleted()
  async completed(job: Job<JobData>, result) {
    try {
      await this.deviceService.setCert(job.data.metadata.ip, {
        certificate: result.certificate,
        public_key: result.publicKey,
        private_key: result.privateKey
      }).then(async (res) => {
        await this.db.add(hash(job.data.metadata.sn), EVENTS.SET_CERTIFICATE, {
          metadata: job.data.metadata,
          time: Date.now(),
          error: {
            log: res
          }
        });
        await this.deviceService.connectivityTest(job.data.metadata.ip)
          .then(async (res) => {

            await this.db.add(hash(job.data.metadata.sn), EVENTS.CONNECTIVITY_TEST, {
              metadata: job.data.metadata,
              time: Date.now(),
              error: { log: res }
            });
            this.socketService.send({ event: EVENTS.CONNECTIVITY_TEST });

            return res;
          }).catch(async (error) => {
            await this.db.add(hash(job.data.metadata.sn), EVENTS.CONNECTIVITY_TEST_ERROR, {
              metadata: job.data.metadata,
              time: Date.now(),
              error: { error }
            });

            this.socketService.send({ event: EVENTS.CONNECTIVITY_TEST_ERROR });

          });
        return res;
      });
    } catch (error) {
      const errorResponse = {
        error: {
          log: error
        },
        metadata: job.data.metadata,
        time: Date.now()
      };
      await this.db.add(hash(job.data.metadata.sn), EVENTS.SET_CERTIFICATE_ERROR, errorResponse);
      this.socketService.send({ event: EVENTS.SET_CERTIFICATE_ERROR });
    }
  }
}