trivia_app_demo.ts

/**
 * Trivia Q&A Application - Demo Version (TypeScript)
 *
 * Uses mock data to demonstrate the application flow without requiring network access.
 * Run with: npm run build && node dist/trivia_app_demo.js
 * Or with ts-node: ts-node trivia_app_demo.ts
 */

import * as readline from "readline";

// ============================================================================
// Configuration & Constants
// ============================================================================

const API_ENDPOINT = "https://opentdb.com/api.php?amount=10";

// ============================================================================
// Logging Configuration
// ============================================================================

enum LogLevel {
  DEBUG = 0,
  INFO = 1,
  WARNING = 2,
  ERROR = 3,
}

class Logger {
  private level: LogLevel;
  private name: string;

  constructor(name: string, level: LogLevel = LogLevel.INFO) {
    this.name = name;
    this.level = level;
  }

  private formatMessage(logLevel: LogLevel, message: string): string {
    const timestamp = new Date().toISOString();
    const levelName = LogLevel[logLevel];
    return `${timestamp} - ${this.name} - ${levelName} - ${message}`;
  }

  debug(message: string): void {
    if (this.level <= LogLevel.DEBUG) {
      console.log(this.formatMessage(LogLevel.DEBUG, message));
    }
  }

  info(message: string): void {
    if (this.level <= LogLevel.INFO) {
      console.log(this.formatMessage(LogLevel.INFO, message));
    }
  }

  warning(message: string): void {
    if (this.level <= LogLevel.WARNING) {
      console.log(this.formatMessage(LogLevel.WARNING, message));
    }
  }

  error(message: string, error?: Error): void {
    if (this.level <= LogLevel.ERROR) {
      const errorMessage = error ? `${message}\n${error.stack}` : message;
      console.error(this.formatMessage(LogLevel.ERROR, errorMessage));
    }
  }
}

const logger = new Logger("trivia_app", LogLevel.INFO);

// ============================================================================
// Domain Models
// ============================================================================

interface TriviaQuestion {
  category: string;
  difficulty: string;
  question: string;
  correct_answer: string;
  incorrect_answers: string[];
}

interface TriviaResponseData {
  response_code: number;
  results: TriviaQuestion[];
}

class Question {
  private category: string;
  private difficulty: string;
  private question: string;
  private correctAnswer: string;
  private incorrectAnswers: string[];

  constructor(data: TriviaQuestion) {
    this.category = this.decodeHtmlEntities(data.category);
    this.difficulty = data.difficulty;
    this.question = this.decodeHtmlEntities(data.question);
    this.correctAnswer = this.decodeHtmlEntities(data.correct_answer);
    this.incorrectAnswers = data.incorrect_answers.map((ans) =>
      this.decodeHtmlEntities(ans)
    );
  }

  private decodeHtmlEntities(text: string): string {
    const htmlEntities: Record<string, string> = {
      "&amp;": "&",
      "&lt;": "<",
      "&gt;": ">",
      "&quot;": '"',
      "&#039;": "'",
      "&apos;": "'",
    };

    return text.replace(/&[a-zA-Z]+;/g, (entity) => htmlEntities[entity] || entity);
  }

  getCategory(): string {
    return this.category;
  }

  getDifficulty(): string {
    return this.difficulty;
  }

  getQuestion(): string {
    return this.question;
  }

  getCorrectAnswer(): string {
    return this.correctAnswer;
  }

  getAllAnswers(): string[] {
    const answers = [...this.incorrectAnswers, this.correctAnswer];
    return this.shuffle(answers);
  }

  private shuffle<T>(array: T[]): T[] {
    for (let i = array.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [array[i], array[j]] = [array[j], array[i]];
    }
    return array;
  }
}

class TriviaResponse {
  private responseCode: number;
  private results: Question[];

  constructor(data: TriviaResponseData) {
    this.responseCode = data.response_code;
    this.results = data.results.map((item) => new Question(item));
  }

  getResponseCode(): number {
    return this.responseCode;
  }

  getResults(): Question[] {
    return this.results;
  }
}

// ============================================================================
// Mock Data Provider
// ============================================================================

class MockTriviaProvider {
  static getMockData(): TriviaResponse {
    const mockResults: TriviaQuestion[] = [
      {
        category: "Entertainment: Comics",
        difficulty: "hard",
        question:
          "Better known by his nickname Logan, what is Wolverine&#039;s birth name?",
        correct_answer: "James Howlett",
        incorrect_answers: ["Logan Wolf", "Thomas Wilde", "John Savage"],
      },
      {
        category: "History",
        difficulty: "easy",
        question:
          "Which one of these countries was NOT in the Central Powers during WWI?",
        correct_answer: "Spain",
        incorrect_answers: ["Austria-Hungary", "Turkey", "Germany"],
      },
      {
        category: "Entertainment: Video Games",
        difficulty: "easy",
        question: 'When was &quot;Luigi&#039;s Mansion 3&quot; released?',
        correct_answer: "October 31st, 2019",
        incorrect_answers: [
          "January 13th, 2019",
          "September 6th, 2018",
          "October 1st, 2019",
        ],
      },
      {
        category: "General Knowledge",
        difficulty: "easy",
        question: "Earth is located in which galaxy?",
        correct_answer: "The Milky Way Galaxy",
        incorrect_answers: ["The Mars Galaxy", "The Galaxy Note", "The Black Hole"],
      },
      {
        category: "Science: Gadgets",
        difficulty: "medium",
        question:
          "In what year was the Oculus Rift revealed to the public through a Kickstarter campaign?",
        correct_answer: "2012",
        incorrect_answers: ["2010", "2011", "2013"],
      },
      {
        category: "Entertainment: Books",
        difficulty: "easy",
        question: 'Who wrote &quot;A Tale of Two Cities&quot;?',
        correct_answer: "Charles Dickens",
        incorrect_answers: ["Charles Darwin", "Mark Twain", "Roald Dahl"],
      },
      {
        category: "Entertainment: Japanese Anime &amp; Manga",
        difficulty: "medium",
        question:
          'Which of the stands from &quot;JoJo&#039;s Bizarre Adventure&quot; mimics the likeness of a tomato?',
        correct_answer: "Pearl Jam",
        incorrect_answers: [
          "Red Hot Chili Pepper",
          "Cream Starter",
          "Nut King Call",
        ],
      },
      {
        category: "Entertainment: Video Games",
        difficulty: "medium",
        question:
          "How many times do you fight the Imprisoned in The Legend of Zelda: Skyward Sword?",
        correct_answer: "3",
        incorrect_answers: ["2", "4", "5"],
      },
      {
        category: "Science: Computers",
        difficulty: "medium",
        question: "What does the term MIME stand for, in regards to computing?",
        correct_answer: "Multipurpose Internet Mail Extensions",
        incorrect_answers: [
          "Mail Internet Mail Exchange",
          "Multipurpose Interleave Mail Exchange",
          "Mail Interleave Method Exchange",
        ],
      },
      {
        category: "Entertainment: Video Games",
        difficulty: "hard",
        question:
          "In Diablo lore, this lesser evil spawned from one of the seven heads of Tathamet, and was known as the Maiden of Anguish.",
        correct_answer: "Andariel",
        incorrect_answers: ["Valla", "Malthael", "Kashya"],
      },
    ];

    const responseData: TriviaResponseData = {
      response_code: 0,
      results: mockResults,
    };

    return new TriviaResponse(responseData);
  }
}

// ============================================================================
// Trivia Game
// ============================================================================

interface AnswerRecord {
  question: string;
  selected: string;
  correct: string;
  isCorrect: boolean;
}

class TriviaGame {
  private questions: Question[];
  private currentQuestionIndex: number = 0;
  private score: number = 0;
  private answersGiven: AnswerRecord[] = [];

  constructor(questions: Question[]) {
    this.questions = questions;
  }

  getCurrentQuestion(): Question | null {
    if (this.currentQuestionIndex < this.questions.length) {
      return this.questions[this.currentQuestionIndex];
    }
    return null;
  }

  submitAnswer(selectedAnswer: string): boolean {
    const question = this.getCurrentQuestion();
    if (!question) {
      return false;
    }

    const isCorrect = selectedAnswer === question.getCorrectAnswer();

    this.answersGiven.push({
      question: question.getQuestion(),
      selected: selectedAnswer,
      correct: question.getCorrectAnswer(),
      isCorrect,
    });

    if (isCorrect) {
      this.score++;
      logger.debug(`Correct answer. Score: ${this.score}/${this.answersGiven.length}`);
    } else {
      logger.debug(`Incorrect answer. Correct was: ${question.getCorrectAnswer()}`);
    }

    this.currentQuestionIndex++;
    return isCorrect;
  }

  isGameOver(): boolean {
    return this.currentQuestionIndex >= this.questions.length;
  }

  getScore(): number {
    return this.score;
  }

  getQuestionCount(): number {
    return this.questions.length;
  }

  getScorePercentage(): number {
    if (this.answersGiven.length === 0) {
      return 0;
    }
    return (this.score / this.answersGiven.length) * 100;
  }

  getAnswersGiven(): AnswerRecord[] {
    return this.answersGiven;
  }
}

// ============================================================================
// Console UI
// ============================================================================

class ConsoleUI {
  private rl: readline.Interface;

  constructor() {
    this.rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
    });
  }

  printHeader(text: string): void {
    console.log("\n" + "=".repeat(80));
    console.log(` ${text}`);
    console.log("=".repeat(80));
  }

  printQuestion(
    question: Question,
    questionNumber: number,
    total: number
  ): void {
    console.log(`\n[Question ${questionNumber}/${total}]`);
    console.log(`Category: ${question.getCategory()}`);
    console.log(`Difficulty: ${question.getDifficulty().toUpperCase()}`);
    console.log(`\n${question.getQuestion()}\n`);
  }

  printOptions(options: string[]): void {
    options.forEach((option, index) => {
      console.log(`  ${index + 1}. ${option}`);
    });
  }

  async getUserSelection(numOptions: number): Promise<number> {
    return new Promise((resolve) => {
      const askForInput = (): void => {
        this.rl.question(
          `\nYour answer (1-${numOptions}): `,
          (input: string) => {
            const selection = parseInt(input.trim(), 10);

            if (isNaN(selection) || selection < 1 || selection > numOptions) {
              console.log(
                `Please enter a number between 1 and ${numOptions}`
              );
              askForInput();
              return;
            }

            resolve(selection);
          }
        );
      };

      askForInput();
    });
  }

  printAnswerFeedback(isCorrect: boolean, correctAnswer: string): void {
    if (isCorrect) {
      console.log("\n✓ CORRECT!");
    } else {
      console.log(`\n✗ INCORRECT. The correct answer was: ${correctAnswer}`);
    }
  }

  printFinalScore(game: TriviaGame): void {
    this.printHeader("GAME OVER - FINAL RESULTS");

    console.log(
      `\nTotal Score: ${game.getScore()}/${game.getQuestionCount()}`
    );
    console.log(`Percentage: ${game.getScorePercentage().toFixed(1)}%`);
    console.log("\n" + "-".repeat(80));
    console.log("Question Summary:\n");

    game.getAnswersGiven().forEach((answer, index) => {
      const status = answer.isCorrect ? "✓" : "✗";
      console.log(`${index + 1}. ${status} ${answer.question}`);
      console.log(`   Your answer: ${answer.selected}`);
      if (!answer.isCorrect) {
        console.log(`   Correct answer: ${answer.correct}`);
      }
      console.log();
    });
  }

  async promptContinue(): Promise<void> {
    return new Promise((resolve) => {
      this.rl.question("\nPress Enter to continue to the next question...", () => {
        resolve();
      });
    });
  }

  close(): void {
    this.rl.close();
  }
}

// ============================================================================
// Main Application (Demo)
// ============================================================================

async function main(): Promise<void> {
  logger.info("Starting Trivia Q&A Application (DEMO MODE)");

  const ui = new ConsoleUI();

  try {
    ui.printHeader("TRIVIA Q&A - OPEN TRIVIA DATABASE (DEMO)");
    console.log("\nLoading trivia questions (using mock data for demo)...\n");

    // Get mock data
    const triviaResponse = MockTriviaProvider.getMockData();
    const questions = triviaResponse.getResults();

    if (!questions || questions.length === 0) {
      console.log("\n✗ Failed to load trivia questions.");
      logger.error("Application terminated due to data load failure");
      ui.close();
      return;
    }

    console.log(`✓ Loaded ${questions.length} questions\n`);

    // Initialize game
    const game = new TriviaGame(questions);

    // Run game loop
    while (!game.isGameOver()) {
      const question = game.getCurrentQuestion();
      if (!question) {
        break;
      }

      const questionNumber = game.getAnswersGiven().length + 1;
      const totalQuestions = game.getQuestionCount();

      ui.printQuestion(question, questionNumber, totalQuestions);

      const options = question.getAllAnswers();
      ui.printOptions(options);

      // Get user's answer
      const selectionIndex = (await ui.getUserSelection(options.length)) - 1;
      const selectedAnswer = options[selectionIndex];

      // Check answer and provide feedback
      const isCorrect = game.submitAnswer(selectedAnswer);
      ui.printAnswerFeedback(isCorrect, question.getCorrectAnswer());

      // Pause before next question
      if (!game.isGameOver()) {
        await ui.promptContinue();
      }
    }

    // Display final results
    ui.printFinalScore(game);
    logger.info(
      `Game completed. Final score: ${game.getScore()}/${game.getQuestionCount()}`
    );
  } catch (error) {
    logger.error(
      "Unexpected error during game",
      error instanceof Error ? error : new Error(String(error))
    );
    console.log(
      `\n✗ An unexpected error occurred: ${error instanceof Error ? error.message : String(error)}`
    );
  } finally {
    ui.close();
  }
}

// Run the application
main();