import * as fs from 'fs'
import { Subject } from 'rxjs';
import { ColorCode, ReportStatus } from '../interfaces/general.interface';
import { GrpcService } from '../services/grpc.service';
import { FisErrorHandlingService } from '../services/error.handling.service.fis';

// Subject for bidirectional communication
const errorHandlingService: FisErrorHandlingService = new FisErrorHandlingService()
const grpcService: GrpcService = new GrpcService()
const messagesJSON: any = fs.readFileSync('payload.json')
let parsedMessages: any[] = JSON.parse(messagesJSON) // load the fake messages generated for this trial 
let messageToBeReleased: Subject<any> = new Subject() // Sample message to be transmitted over to target server
let statusControl: Subject<ReportStatus> = new Subject() // Listening for error events and states
let dataMessages = stream() // Emulate messges to be sent over to target server
let server1: string = 'localhost:3000'
let unaryRequestSubject: Subject<any> = new Subject()

/* Server Streaming Test case */
errorHandlingService.handleMessage(unaryRequestSubject, statusControl).subscribe((messages) => {
  messageToBeReleased.next(messages)
})
grpcService.createGrpcInstance(server1, messageToBeReleased, statusControl, { instanceType: 'client', serviceMethod: 'server streaming' })

/* Bidirectional streaming test case */
// errorHandlingService.handleMessage(dataMessages, statusControl).subscribe((messages) => {
//   messageToBeReleased.next(messages)
// })
// grpcService.createGrpcInstance(server1, messageToBeReleased, statusControl, { instanceType: 'client', serviceMethod: 'bidirectional' })
// }

setTimeout(() => {
  messageToBeReleased.next(parsedMessages[0])
}, 1000)
setTimeout(() => {
  messageToBeReleased.next(parsedMessages[1])
}, 4000)
setTimeout(() => {
  unaryRequestSubject.next(parsedMessages[2])
}, 7000)

// this is just to publish an array of fake data as a Subject
function stream(): Subject<any> {
  let result: Subject<any> = new Subject()
  let messages: any[] = parsedMessages
  let count = 0
  const intervalId = setInterval(() => {
    result.next(messages[count]);
    count++;
    if (count >= 1000) {
      clearInterval(intervalId);
      result.complete();
    }
  }, 500)

  return result
}