import grpc from '@grpc/grpc-js';
import { v4 as uuid } from 'uuid';
import { JetroutineFunctionReturnTypes, SupportedTypes, SymbolTable } from '../config/_symbols';
import { execJetroutine } from '../core/exec';
import { remote } from '../proto/runtime/v1alpha1/remote';
import { getPostResultRequest } from './_util';

const taskResults: { [x:string]: remote.Result } = {};
const scheduledTasks: { [x:string]: remote.Task } = {};

export class LocalRuntimeStub {
  /* eslint class-methods-use-this: "off" */
  RegisterApp(_request: remote.RegisterAppRequest, _metadata?: grpc.Metadata) {
    /**
     * This is a no op.
     * In the future we may want to simulate the registration process
     */
    return Promise.resolve(new remote.RegisterAppResponse());
  }

  CreateTask(request: remote.CreateTaskRequest, _metadata?: grpc.Metadata) {
    const taskId = uuid();
    const { task } = request;
    const func = SymbolTable.getRegisteredFunction(task.qualified_symbol);
    scheduledTasks[task.task_id] = task;

    return execJetroutine(
      func,
      JSON.parse(String.fromCharCode(...request.task.encoded_args)) as SupportedTypes[],
      (
        res?: JetroutineFunctionReturnTypes,
        err?: remote.Error,
      ) => this.PostResult(getPostResultRequest(taskId, res, err)),
    ).then(() => new remote.CreateTaskResponse({ task_id: taskId }));
  }

  /* eslint class-methods-use-this: "off" */
  GetTask(request: remote.GetTaskRequest, _metadata?: grpc.Metadata) {
    const task = scheduledTasks[request.task_id];
    return Promise.resolve(new remote.GetTaskResponse({
      id: task.task_id,
      encoded_args: task.encoded_args,
    }));
  }

  /* eslint class-methods-use-this: "off" */
  PostResult(request: remote.PostResultRequest, _metadata?: grpc.Metadata) {
    taskResults[request.exec_id] = request.result;
    return Promise.resolve(new remote.PostResultResponse());
  }

  /* eslint class-methods-use-this: "off" */
  WaitForResult(request: remote.WaitForResultRequest, _metadata?: grpc.Metadata) {
    return Promise.resolve(
      new remote.WaitForResultResponse({ result: taskResults[request.task_id] }),
    );
  }
}