Refactor LeetCode interaction into centralized API class

Replaced individual modules with a single `LeetCodeAPI` class to handle problem fetching, daily challenges, and solutions. Simplified PracticeFactory logic by integrating API calls. Extended CLI and input handling for study plans and logging improvements.

Author: nicholasadamou

PracticeFactory.py

@@ -1,8 +1,9 @@
-from lib.fetch_problems import get_random_problem
-from lib.fetch_daily_challenge import fetch_daily_challenge
-from lib.fetch_problem import fetch_problem
+import random
+from typing import List, Dict, Any, Optional
+
 from utils.logger import log, LogLevel
 from handlers.SolutionHandler import SolutionHandler
+from api.LeetCodeAPI import LeetCodeAPI
 
 difficulty_map = {
     "easy": "Easy",
@@ -12,104 +13,181 @@
 
 
 class PracticeMode:
-    def handle(self, args):
-        raise NotImplementedError("This method should be implemented by subclasses.")
+    def __init__(self):
+        self.leetcode_api = LeetCodeAPI()
 
-
-class RandomProblemMode(PracticeMode):
     def handle(self, args):
-        problem = get_random_problem(args["difficulties"])
+        raise NotImplementedError("This method should be implemented by subclasses.")
 
-        # Log problem details
+    def log_problem_details(self, problem, difficulty_label, url):
         log(f"🎯 Problem Selected: {problem['title']}", LogLevel.INFO)
-        log(f"✨ Difficulty: {difficulty_map[problem['difficulty']]}", LogLevel.INFO)
-        log(f"🔗 URL: https://leetcode.com/problems/{problem['slug']}", LogLevel.INFO)
+        log(f"✨ Difficulty: {difficulty_label}", LogLevel.INFO)
+        log(f"🔗 URL: {url}", LogLevel.INFO)
 
-        # Open in browser if flag is set
-        if args["open_in_browser"]:
+    def open_in_browser(self, url, open_flag):
+        if open_flag:
             import webbrowser
 
-            webbrowser.open(f"https://leetcode.com/problems/{problem['slug']}")
+            webbrowser.open(url)
 
+    def create_and_solve_handler(self, problem_slug, difficulty_label, args):
         handler = SolutionHandler(
-            problem=problem["slug"],
-            difficulty=difficulty_map[problem["difficulty"]],
+            problem=problem_slug,
+            difficulty=difficulty_label,
             editor=args["editor"],
             language=args["language"],
             time_limit=args["time_limit"],
         )
         handler.solve()
 
+    def get_random_problem(
+        self,
+        category_slug: Optional[str] = None,
+        difficulties: Optional[List[str]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get a random problem from LeetCode.
+        :param category_slug: Slug of the category to fetch problems from.
+        :param difficulties: Difficulty levels of the problems (e.g., "Easy", "Medium", "Hard").
+        :return: A random problem dictionary or None if no problems are found.
+        """
+        problems = self.leetcode_api.fetch_problems(
+            category_slug=category_slug, limit=1000, difficulties=difficulties
+        )
 
-class DailyChallengeMode(PracticeMode):
+        if not problems:
+            return None
+
+        random_index = random.randint(0, len(problems) - 1)
+        return problems[random_index]
+
+    def get_study_plan_problems(self, slug: str) -> List[Dict[str, Any]]:
+        """
+        Fetch the list of problems for a specific study plan.
+        :param slug: The slug of the study plan (e.g., "leetcode-75").
+        :return: A list of dictionaries, each containing details of a problem.
+        """
+        study_plan = self.leetcode_api.get_study_plan(slug)
+
+        if not study_plan:
+            raise Exception(f"❌ Study plan not found for slug: {slug}")
+
+        # Gather all questions from the study plan subgroups
+        problems = []
+        for subgroup in study_plan.get("planSubGroups", []):
+            questions = subgroup.get("questions", [])
+            problems.extend(questions)  # Add all questions to the list
+
+        if not problems:
+            raise Exception(f"❌ No problems found for study plan: {slug}")
+
+        return problems
+
+    def get_random_study_plan_problem(self, slug: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a random problem from a specific study plan.
+        :param slug: The slug of the study plan (e.g., "leetcode-75").
+        :return: A random problem dictionary or None if no problems are found.
+        """
+        problems = self.get_study_plan_problems(slug)
+
+        if not problems:
+            return None
+
+        random_index = random.randint(0, len(problems) - 1)
+        return problems[random_index]
+
+
+class RandomProblemMode(PracticeMode):
     def handle(self, args):
+        log("Selected 🎲 Random Problem Mode", LogLevel.INFO)
+
         try:
-            daily_challenge = fetch_daily_challenge()
+            # Use the LeetCodeAPI's fetch_problems method
+            problem = self.get_random_problem(args["difficulties"])
+
+            if not problem:
+                log("No problems found for the selected difficulties.", LogLevel.ERROR)
+                return
+
+            difficulty_label = difficulty_map[problem["difficulty"].lower()]
+            url = f"https://leetcode.com/problems/{problem['titleSlug']}"
 
+            self.log_problem_details(problem, difficulty_label, url)
+            self.open_in_browser(url, args["open_in_browser"])
+            self.create_and_solve_handler(problem["titleSlug"], difficulty_label, args)
+        except Exception as e:
+            log(f"Failed to fetch random problem: {str(e)}", LogLevel.ERROR)
+
+
+class DailyChallengeMode(PracticeMode):
+    def handle(self, args):
+        log("Selected 📅 Daily Challenge Mode", LogLevel.INFO)
+
+        try:
+            # Use the LeetCodeAPI's fetch_daily_challenge method
+            daily_challenge = self.leetcode_api.fetch_daily_challenge()
             difficulty_label = difficulty_map[
                 daily_challenge["question"]["difficulty"].lower()
             ]
+            url = f"https://leetcode.com{daily_challenge['link'].removesuffix('/')}"
 
-            # Log daily challenge details
             log("🎯 Daily Coding Challenge:", LogLevel.INFO)
             log(f"📅 Date: {daily_challenge['date']}", LogLevel.INFO)
-            log(f"📖 Title: {daily_challenge['question']['title']}", LogLevel.INFO)
-            log(f"✨ Difficulty: {difficulty_label}", LogLevel.INFO)
-            log(
-                f"🔗 Link: https://leetcode.com{daily_challenge['link']}", LogLevel.INFO
-            )
-
-            if args["open_in_browser"]:
-                import webbrowser
-
-                webbrowser.open(f"https://leetcode.com{daily_challenge['link']}")
-
-            handler = SolutionHandler(
-                problem=daily_challenge["question"]["titleSlug"],
-                difficulty=difficulty_label,
-                editor=args["editor"],
-                language=args["language"],
-                time_limit=args["time_limit"],
+            self.log_problem_details(daily_challenge["question"], difficulty_label, url)
+            self.open_in_browser(url, args["open_in_browser"])
+            self.create_and_solve_handler(
+                daily_challenge["question"]["titleSlug"], difficulty_label, args
             )
-            handler.solve()
         except Exception as e:
             log(f"Failed to fetch daily challenge: {str(e)}", LogLevel.ERROR)
 
 
 class CustomPracticeMode(PracticeMode):
     def handle(self, args):
-        problems = args["problems"]
+        log("Selected 🧩 Custom Practice Mode", LogLevel.INFO)
 
-        for slug in problems:
+        for slug in args["problems"]:
             log(f"🔍 Fetching details for problem: {slug}", LogLevel.INFO)
             try:
-                problem = fetch_problem(slug.strip())
+                problem = self.leetcode_api.fetch_problem(slug.strip())
 
                 if not problem:
                     log(f"Problem with slug '{slug}' not found.", LogLevel.ERROR)
                     continue
 
-                log(f"🎯 Problem Selected: {problem['title']}", LogLevel.INFO)
-                log(f"✨ Difficulty: {problem['difficulty']}", LogLevel.INFO)
-                log(f"🔗 URL: https://leetcode.com/problems/{slug}", LogLevel.INFO)
+                difficulty_label = difficulty_map[problem["difficulty"].lower()]
+                url = f"https://leetcode.com/problems/{problem['titleSlug']}"
 
-                if args["open_in_browser"]:
-                    import webbrowser
-
-                    webbrowser.open(f"https://leetcode.com/problems/{problem['slug']}")
-
-                handler = SolutionHandler(
-                    problem=slug,
-                    difficulty=problem["difficulty"],
-                    editor=args["editor"],
-                    language=args["language"],
-                    time_limit=args["time_limit"],
-                )
-                handler.solve()
+                self.log_problem_details(problem, difficulty_label, url)
+                self.open_in_browser(url, args["open_in_browser"])
+                self.create_and_solve_handler(slug, difficulty_label, args)
             except Exception as e:
                 log(f"Failed to process problem '{slug}': {str(e)}", LogLevel.ERROR)
 
 
+class StudyPlanMode(PracticeMode):
+    def handle(self, args):
+        try:
+            log(f"Selected 🎯 Study Plan Mode: {args['study_plan']}", LogLevel.INFO)
+
+            # Use the LeetCodeAPI's fetch_problems method
+            problem = self.get_random_study_plan_problem(args["study_plan"])
+
+            if not problem:
+                log("No problems found for the selected study plan.", LogLevel.ERROR)
+                return
+
+            difficulty_label = difficulty_map[problem["difficulty"].lower()]
+            url = f"https://leetcode.com/problems/{problem['titleSlug']}"
+
+            self.log_problem_details(problem, difficulty_label, url)
+            self.open_in_browser(url, args["open_in_browser"])
+            self.create_and_solve_handler(problem["titleSlug"], difficulty_label, args)
+        except Exception as e:
+            log(f"Failed to fetch random problem: {str(e)}", LogLevel.ERROR)
+
+
 class PracticeModeFactory:
     @staticmethod
     def get_mode(selection_mode: str) -> PracticeMode:
@@ -120,6 +198,6 @@ def get_mode(selection_mode: str) -> PracticeMode:
         elif selection_mode == "custom":
             return CustomPracticeMode()
         elif selection_mode == "study-plan":
-            raise ValueError("Study Plan mode is not yet supported.")
+            return StudyPlanMode()
         else:
             raise ValueError(f"Unsupported mode: {selection_mode}")