Assignment 1

PrincessBrideTrivia/PrincessBrideTrivia.Tests/ProgramTests.cs

@@ -69,6 +69,21 @@ public void GetPercentCorrect_ReturnsExpectedPercentage(int numberOfCorrectGuess
         Assert.AreEqual(expectedString, percentage);
     }
 
+    [TestMethod]
+    public async Task GenerateQuestions_SuccessfullyGeneratesQuestions()
+    {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+        Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+        Assert.IsNotNull(q);
+    }
+
+    [TestMethod]
+    public async Task GenerateQuestions_GeneratesFourChoices()
+    {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+        Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+        Assert.HasCount(4, q.Answers);
+    }
 
     private static void GenerateQuestionsFile(string filePath, int numberOfQuestions)
     {

PrincessBrideTrivia/PrincessBrideTrivia/PrincessBrideTrivia.csproj

@@ -7,6 +7,10 @@
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="OpenAI" Version="2.5.0" />
+  </ItemGroup>
+
   <ItemGroup>
     <None Update="Trivia.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

PrincessBrideTrivia/PrincessBrideTrivia/Program.cs

@@ -1,13 +1,22 @@
-namespace PrincessBrideTrivia;
+using OpenAI.Chat;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace PrincessBrideTrivia;
 
 public class Program
 {
-    public static void Main(string[] args)
+    public static async Task Main(string[] args)
     {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+
         string filePath = GetFilePath();
         Question[] questions = LoadQuestions(filePath);
 
         int numberCorrect = 0;
+        int numberOfQuestions = questions.Length;
+        bool runWhile = true;
+
         for (int i = 0; i < questions.Length; i++)
         {
             bool result = AskQuestion(questions[i]);
@@ -16,20 +25,48 @@ public static void Main(string[] args)
                 numberCorrect++;
             }
         }
-        Console.WriteLine("You got " + GetPercentCorrect(numberCorrect, questions.Length) + " correct");
+
+        Console.WriteLine("Enter 'exit' to exit");
+
+        while (runWhile)
+        {
+            Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+            try
+            {
+                bool result = AskQuestion(q);
+                numberOfQuestions++;
+                if (result)
+                {
+                    numberCorrect++;
+                }
+            }
+            catch (Exception)
+            {
+                runWhile = false;
+            }
+        }
+
+        Console.WriteLine("You got " + GetPercentCorrect(numberCorrect, numberOfQuestions) + " correct");
     }
 
     public static string GetPercentCorrect(int numberCorrectAnswers, int numberOfQuestions)
     {
-        return (numberCorrectAnswers / numberOfQuestions * 100) + "%";
+        return ((float)numberCorrectAnswers / (float)numberOfQuestions * 100) + "%";
     }
 
     public static bool AskQuestion(Question question)
     {
         DisplayQuestion(question);
 
         string userGuess = GetGuessFromUser();
-        return DisplayResult(userGuess, question);
+
+        if (userGuess == "exit")
+        {
+            throw new Exception("user exit");
+        } else
+        {
+            return DisplayResult(userGuess, question);
+        }
     }
 
     public static string GetGuessFromUser()
@@ -86,7 +123,99 @@ public static Question[] LoadQuestions(string filePath)
             question.Answers[1] = answer2;
             question.Answers[2] = answer3;
             question.CorrectAnswerIndex = correctAnswerIndex;
+
+            questions[i] = question;
         }
+
+
         return questions;
     }
 }
+
+public static class TriviaGenerator
+{
+    private const string Model = "gpt-4.1";
+
+    /// <summary>
+    /// Generates one Princess Bride multiple-choice question using the OpenAI API.
+    /// </summary>
+    public static async Task<Question> GeneratePrincessBrideQuestionAsync(string apiKey, int choices = 4)
+    {
+        if (string.IsNullOrWhiteSpace(apiKey))
+            throw new ArgumentException("API key is required.", nameof(apiKey));
+
+        if (choices is < 3 or > 6)
+            throw new ArgumentOutOfRangeException(nameof(choices), "choices must be between 3 and 6.");
+
+        var client = new ChatClient(model: Model, apiKey: apiKey);
+
+        var system = """
+            You generate trivia strictly about the 1987 film "The Princess Bride".
+            Output ONLY a single JSON object with this exact C#-friendly shape:
+            {
+              "Text": string,                // the question text
+              "Answers": string[],           // exactly N distinct options, concise, no markup
+              "CorrectAnswerIndex": string   // "1"-based index of the correct answer, as a string
+            }
+            Rules:
+            - The question must be unambiguous and answerable from the film (not the novel).
+            - Answers must be short (max ~80 chars each) and mutually exclusive.
+            - Make sure to switch up which index is correct.
+            - Do not include explanations, hints, or extra keys.
+            - Do not include code fences. Print raw JSON only.
+        """;
+
+        var user = $"""
+            Create ONE multiple-choice question.
+            Number of options: {choices}.
+            Difficulty: hard.
+        """;
+
+        var completion = await client.CompleteChatAsync(
+            new ChatMessage[]
+            {
+                new SystemChatMessage(system),
+                new UserChatMessage(user)
+            },
+            new ChatCompletionOptions
+            {
+                // Mild creativity
+                Temperature = (float)0.7
+            });
+
+        var message = completion.Value.Content[0];
+        var json = message.Text?.Trim();
+
+        if (string.IsNullOrWhiteSpace(json))
+            throw new InvalidOperationException("Model returned empty content.");
+
+        // Strict JSON parse
+        var question = JsonSerializer.Deserialize<Question>(json, new JsonSerializerOptions
+        {
+            ReadCommentHandling = JsonCommentHandling.Disallow,
+            AllowTrailingCommas = false,
+            PropertyNameCaseInsensitive = true,
+            NumberHandling = JsonNumberHandling.Strict
+        });
+
+        Validate(question, choices);
+        return question!;
+    }
+
+    private static void Validate(Question q, int expectedChoices)
+    {
+        if (q is null) throw new InvalidOperationException("Failed to parse the model's JSON.");
+        if (string.IsNullOrWhiteSpace(q.Text)) throw new InvalidOperationException("Question text missing.");
+        if (q.Answers is null || q.Answers.Length != expectedChoices)
+            throw new InvalidOperationException($"Expected {expectedChoices} answers, got {q?.Answers?.Length ?? 0}.");
+
+        if (q.Answers.Any(string.IsNullOrWhiteSpace))
+            throw new InvalidOperationException("One or more answers are empty.");
+
+        if (!int.TryParse(q.CorrectAnswerIndex, out var idx))
+            throw new InvalidOperationException("CorrectAnswerIndex must be a numeric string.");
+
+        if (idx < 0 || idx >= q.Answers.Length)
+            throw new InvalidOperationException("CorrectAnswerIndex out of range.");
+    }
+}