Assignment 1

PrincessBrideTrivia/PrincessBrideTrivia.Tests/ProgramTests.cs

@@ -30,8 +30,7 @@ public void LoadQuestions_RetrievesQuestionsFromFile()
     public void DisplayResult_ReturnsTrueIfCorrect(string userGuess, bool expectedResult)
     {
         // Arrange
-        Question question = new();
-        question.CorrectAnswerIndex = "1";
+        Question question = new() { CorrectAnswerIndex = "1" };
 
         // Act
         bool displayResult = Program.DisplayResult(userGuess, question);
@@ -69,6 +68,33 @@ public void GetPercentCorrect_ReturnsExpectedPercentage(int numberOfCorrectGuess
         Assert.AreEqual(expectedString, percentage);
     }
 
+    [TestMethod]
+    public async Task GenerateQuestions_Success()
+    {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+
+        if (apiKey == null)
+        {
+            return; // test cannot run without the API key
+        }
+
+        Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+        Assert.IsNotNull(q);
+    }
+
+    [TestMethod]
+    public async Task GenerateQuestions_GeneratesFourChoices_Success()
+    {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+
+        if (apiKey == null)
+        {
+            return; // test cannot run without the API key
+        }
+
+        Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+        Assert.HasCount(4, q.Answers);
+    }
 
     private static void GenerateQuestionsFile(string filePath, int numberOfQuestions)
     {

PrincessBrideTrivia/PrincessBrideTrivia.sln

@@ -1,7 +1,6 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
-VisualStudioVersion = 16.0.29215.179
+VisualStudioVersion = 17.14.36518.9 d17.14
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PrincessBrideTrivia", "PrincessBrideTrivia\PrincessBrideTrivia.csproj", "{43E8309C-D064-4743-B038-16F808E98D98}"
 EndProject

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

@@ -2,34 +2,91 @@
 
 public class Program
 {
-    public static void Main(string[] args)
+    public static async Task Main()
     {
+        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
+
         string filePath = GetFilePath();
         Question[] questions = LoadQuestions(filePath);
 
         int numberCorrect = 0;
+        int numberOfQuestions = questions.Length;
+        bool runWhile = true;
+
+        // ✅ Show quit option at the very start
+        Console.WriteLine("Type 'quit' anytime to exit");
+
         for (int i = 0; i < questions.Length; i++)
         {
-            bool result = AskQuestion(questions[i]);
+            (bool result, bool quitProgram) = AskQuestion(questions[i]);
+            if (quitProgram)
+            {
+                runWhile = false;
+                break;
+            }
             if (result)
             {
                 numberCorrect++;
             }
         }
-        Console.WriteLine("You got " + GetPercentCorrect(numberCorrect, questions.Length) + " correct");
+
+        // ✅ If user answered all file questions and we are NOT running AI loop, print score now
+        if (!runWhile || apiKey == null)
+        {
+            Console.WriteLine($"You got {GetPercentCorrect(numberCorrect, numberOfQuestions)} correct");
+            return;
+        }
+
+        while (runWhile)
+        {
+            try
+            {
+                Question q = await TriviaGenerator.GeneratePrincessBrideQuestionAsync(apiKey);
+
+                (bool result, bool quitProgram) = AskQuestion(q);
+
+                if (quitProgram)
+                {
+                    runWhile = false;
+                }
+                else
+                {
+                    numberOfQuestions++;
+                    if (result)
+                    {
+                        numberCorrect++;
+                    }
+                }
+            }
+            catch (InvalidOperationException ex)
+            {
+                Console.WriteLine(ex.Message);
+                continue;
+            }
+        }
+
+        // ✅ Always print score at the very end
+        Console.WriteLine($"You got {GetPercentCorrect(numberCorrect, numberOfQuestions)} correct");
     }
 
     public static string GetPercentCorrect(int numberCorrectAnswers, int numberOfQuestions)
     {
-        return (numberCorrectAnswers / numberOfQuestions * 100) + "%";
+        double roundedPercent = Math.Round((float)numberCorrectAnswers / (float)numberOfQuestions * 100, 2);
+        return $"{roundedPercent}%";
     }
 
-    public static bool AskQuestion(Question question)
+    public static (bool answeredCorrectly, bool quitProgram) AskQuestion(Question question)
     {
         DisplayQuestion(question);
-
         string userGuess = GetGuessFromUser();
-        return DisplayResult(userGuess, question);
+
+        if (userGuess == "quit")
+        {
+            return (false, true);
+        }
+
+        bool isCorrect = DisplayResult(userGuess, question);
+        return (isCorrect, false);
     }
 
     public static string GetGuessFromUser()
@@ -51,10 +108,10 @@ public static bool DisplayResult(string userGuess, Question question)
 
     public static void DisplayQuestion(Question question)
     {
-        Console.WriteLine("Question: " + question.Text);
+        Console.WriteLine($"Question: {question.Text}");
         for (int i = 0; i < question.Answers.Length; i++)
         {
-            Console.WriteLine((i + 1) + ": " + question.Answers[i]);
+            Console.WriteLine($"{i + 1}: {question.Answers[i]}");
         }
     }
 
@@ -71,22 +128,20 @@ public static Question[] LoadQuestions(string filePath)
         for (int i = 0; i < questions.Length; i++)
         {
             int lineIndex = i * 5;
-            string questionText = lines[lineIndex];
 
-            string answer1 = lines[lineIndex + 1];
-            string answer2 = lines[lineIndex + 2];
-            string answer3 = lines[lineIndex + 3];
-
-            string correctAnswerIndex = lines[lineIndex + 4];
+            Question question = new()
+            {
+                Text = lines[lineIndex],
+                Answers = new string[3],
+                CorrectAnswerIndex = lines[lineIndex + 4]
+            };
+            question.Answers[0] = lines[lineIndex + 1];
+            question.Answers[1] = lines[lineIndex + 2];
+            question.Answers[2] = lines[lineIndex + 3];
 
-            Question question = new();
-            question.Text = questionText;
-            question.Answers = new string[3];
-            question.Answers[0] = answer1;
-            question.Answers[1] = answer2;
-            question.Answers[2] = answer3;
-            question.CorrectAnswerIndex = correctAnswerIndex;
+            questions[i] = question;
         }
+
         return questions;
     }
 }

PrincessBrideTrivia/PrincessBrideTrivia/TriviaGenerator.cs

@@ -0,0 +1,94 @@
+using OpenAI.Chat;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace PrincessBrideTrivia
+{
+    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.");
+        }
+    }
+}