import { Injectable } from '@nestjs/common'
import { chunk, compact, isEmpty, isNil } from 'lodash'

import { CampaignMessage } from '../../models'
import { CampaignMessageRepository } from '../../repositories'
import { ComteleService } from '../comtele'

import { Report } from './types/report.type'

@Injectable()
export class ReporterProcessorService {
  constructor(
    private readonly comteleService: ComteleService,
    private readonly campaignMessageRepository: CampaignMessageRepository,
  ) {}

  async processComteleReport(startDateTime: Date, endDateTime: Date): Promise<void> {
    const messages = await this.comteleService.getDetailedReport(startDateTime, endDateTime)

    await this.processReports(messages.map(value => value.toNotificationReport()))
  }

  async processAwsReport(_day: Date): Promise<void> {
    throw new Error('Not implemented')
  }

  private async processReports(reports: Array<Report>): Promise<void> {
    const chunks = chunk(reports, 100)

    for (const chunked of chunks) {
      const values = await this.campaignMessageRepository.findById(
        compact(chunked.map(value => (!isNil(value.controlId) && !isEmpty(value.controlId) ? value.controlId : null))),
      )

      if (isNil(values) || isEmpty(values)) continue

      const messages = compact(chunked.map(message => this.processMessageReport(message, values[message.controlId])))

      if (isEmpty(messages)) continue

      await this.campaignMessageRepository.updateDeliveryRelatedFields(messages)
    }
  }

  private processMessageReport(message: Report, campaignMessage: CampaignMessage): CampaignMessage {
    if (!campaignMessage) {
      console.warn('Report`s message not found', JSON.stringify(message))

      return null
    }

    if (message.status === 'delivered') campaignMessage.received_at = message.receivedAt

    campaignMessage.delivery_status = message.status

    if (message.details && !isEmpty(message.details)) campaignMessage.delivery_details = message.details

    return campaignMessage
  }
}