syntax="proto3";
message Student {
  int32 id = 1;
  string name = 2;
}
message Question {
  int32 id = 1;
  string text = 2;
}
message Answer {
  int32 id = 1;
  Student student = 2;
  Question question = 3;
  string text = 4;
}
message Evaluation {
  int32 id = 1;
  int32 answerId = 2;
  int32 mark = 3;
}
message AnsweredQuestion {
  Question question = 1;
  string answer = 2;
}
message Exam {
  int32 id = 1;
  repeated Question questions = 2;
}
service Umka {
  rpc getQuestion(Student) returns(Question) {}
  rpc sendAnswer(Answer) returns(Evaluation) {}
  rpc getTutorial(Student) returns (stream AnsweredQuestion) {}
  rpc getExam(Student) returns (Exam) {}
  rpc takeExam(stream Answer) returns(Evaluation) {}
}

@override
  Future<Exam> getExam(ServiceCall call, Student request) async {
    final exam = Exam()..id = 1;
    exam.questions.addAll(questionsDb);
    return exam;
  }

@override
  Future<Evaluation> takeExam(ServiceCall call, Stream<Answer> asnswers) async {
    var score = 0;
    await for (var answer in asnswers) {
      final isCorrect = getCorrectAnswerById(answer.question.id) == answer.text;
      print('Received an answer from ${answer.student.name}\n'
          'for a question: ${answer.question.text}'
          'answer: ${answer.text} is correct: $isCorrect');
      if (isCorrect) {
        score++;
      }
    }
    print('The student: ${call.clientMetadata?['student_name']}'
        ' finished exam with the score: $score');
    return Evaluation()
      ..id = 1
      ..mark = score;
  }
}

Future<Evaluation> takeExam(Student student) async {
    final exam = await stub.getExam(student);
    final questions = exam.questions;
    final answersStream = StreamController<Answer>();
    final evaluationFuture = stub.takeExam(answersStream.stream,
        options: CallOptions(metadata: {'student_name': '${student.name}'}));
    for (var question in questions) {
      final answer = Answer()
        ..question = question
        ..student = student;
      print('Enter the answer for the question: ${question.text}');
      answer.text = stdin.readLineSync()!;
      answersStream.add(answer);
      await Future.delayed(Duration(milliseconds: 1));
    }
    unawaited(answersStream.close());
    return evaluationFuture;
  }

Future<void> callService(Student student) async {
    final evaluation = await takeExam(student);
    print('${student.name}, your exam score is: ${evaluation.mark}');
    await channel.shutdown();
  }

message InterviewMessage {
  string name = 1;
  string body = 2;
}

rpc techInterview(stream InterviewMessage) returns(stream InterviewMessage) {}

const interviewQuestions = [
  'What was wrong in your previous job place?',
  'Why do you want to work for Us?',
  'Who do you see yourself in 5 years?',
  'We will inform you about the decision. Bye!',
];

InterviewMessage _createMessage(String text, {String name = 'Interviewer'}) =>
      InterviewMessage()
        ..name = name
        ..body = text;

@override
  Stream<InterviewMessage> techInterview(
      ServiceCall call, Stream<InterviewMessage> interviewStream) async* {
    var count = 0;
    await for (var message in interviewStream) {
      print('Candidate ${message.name} message: ${message.body}');
      if (count >= interviewQuestions.length) {
        return;
      } else {
        yield _createMessage(interviewQuestions[count++]);
      }
    }
  }

Future<void> techInterview(String candidateName) async {
    final candidateStream = StreamController<InterviewMessage>();
    final interviewerStream = stub.techInterview(candidateStream.stream);
    candidateStream.add(InterviewMessage()
      ..name = candidateName
      ..body = 'I am ready!');
    await for (var message in interviewerStream) {
      print('\nMessage from the ${message.name}:\n${message.body}\n');
      print('Enter your answer:');
      final answer = stdin.readLineSync();
      candidateStream.add(InterviewMessage()..body = answer!);
    }
    unawaited(candidateStream.close());
  }

Future<void> callService(Student student) async {
    await techInterview(student.name);
    await channel.shutdown();
  }