import { OnQueueCompleted, OnQueueFailed, Process, Processor } from '@nestjs/bull';
import { QService } from './q.service';
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 { Job } from 'bull';
import { JobData } from '../models/data.model';
import { EVENTS, hash } from '../const';

@Processor('validation-processor')
export class ValidationProcessor {

  constructor(
    private readonly qService: QService,
    private readonly cloudService: CloudService,
    private readonly deviceService: DeviceService,
    private readonly db: DbService,
    private readonly socketService: SocketService
  ) {
  }

  @Process('validation')
  async validation(job: Job<JobData>) {
    const deviceId = await this.db.getDevice(hash(job.data.metadata.sn));
    const logData = {
      error: {
        log: {
          metadata: job.data.metadata,
          payload: job.data.payload,
          deviceId
        }
      },
      metadata: job.data.metadata,
      time: Date.now()
    };


    if (Object.values(job.data.payload).length > 0) {
      await this.db.add(hash(job.data.metadata.sn), EVENTS.DEVICE_VALIDATION_ERROR, logData);
      throw 'ERROR';
    }


    await this.db.add(hash(job.data.metadata.sn), EVENTS.TRY_SET_DEVICE_STATUS, logData);
    return this.cloudService.updateDeviceStatus(Number(deviceId));
  }

  @OnQueueCompleted()
  async completed(job: Job<JobData>, result) {
    try {
      const response = await this.deviceService.reset(job.data.metadata.ip);
      console.log('DONE', job.data);
      const logData = {
        error: {
          response
        },
        metadata: job.data.metadata,
        time: Date.now()
      };
      this.socketService.send({ event: EVENTS.INITIATE_FACTORY_RESET });
      await this.db.add(hash(job.data.metadata.sn), EVENTS.INITIATE_FACTORY_RESET, logData);
      await this.db.complete(hash(job.data.metadata.sn), logData).then(() => {
        this.socketService.send({ event: EVENTS.COMPLETED });
      });

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

  }

  @OnQueueFailed()
  async fail(job: Job<JobData>, error: any) {
    const logData = {
      error: {
        log: {
          metadata: job.data.metadata,
          payload: job.data.payload,
          error
        }
      },
      metadata: job.data.metadata,
      time: Date.now()
    };
    await this.db.add(hash(job.data.metadata.sn), EVENTS.SET_DEVICE_STATUS_FAILED, logData);
    this.socketService.send({ event: EVENTS.SET_DEVICE_STATUS_FAILED });
    console.log('VALIDATION PROCESSOR FAILED', error);
  }
}