LlmService.cs

using System;
using System.Configuration;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;

// Using statements for Betalgo.Ranul.OpenAI
using Betalgo.Ranul.OpenAI; // For OpenAIService, OpenAIOptions
using System.Text.Json; // Added for System.Text.Json
using System.Text.Json.Serialization; // Added for JsonPropertyName attributes
using Betalgo.Ranul.OpenAI.Interfaces; // For IOpenAIService
using Betalgo.Ranul.OpenAI.ObjectModels; // For Models (e.g., Models.Gpt_3_5_Turbo)
using Betalgo.Ranul.OpenAI.ObjectModels.RequestModels; // For ChatCompletionCreateRequest, ChatMessage

namespace TimeTask
{
    public enum ClarityStatus
    {
        Clear,
        NeedsClarification,
        Unknown
    }

    public enum DecompositionStatus
    {
        Sufficient,
        NeedsDecomposition,
        Unknown
    }

    public class ProposedDailyTask
    {
        [JsonPropertyName("day")]
        public int Day { get; set; }

        [JsonPropertyName("task_description")]
        public string TaskDescription { get; set; }

        [JsonPropertyName("quadrant")]
        public string Quadrant { get; set; }

        [JsonPropertyName("estimated_time")]
        public string EstimatedTime { get; set; }
    }

    public class LlmLearningMilestone
    {
        [JsonPropertyName("stage")]
        public int Stage { get; set; }

        [JsonPropertyName("title")]
        public string Title { get; set; }

        [JsonPropertyName("description")]
        public string Description { get; set; }

        [JsonPropertyName("estimated_time")]
        public string EstimatedTime { get; set; }

        [JsonPropertyName("is_completed")]
        public bool IsCompleted { get; set; }
    }

    public class LlmSkillRecommendation
    {
        [JsonPropertyName("skill_id")]
        public string SkillId { get; set; }

        [JsonPropertyName("title")]
        public string Title { get; set; }

        [JsonPropertyName("why")]
        public string Why { get; set; }

        [JsonPropertyName("next_step")]
        public string NextStep { get; set; }

        [JsonPropertyName("confidence")]
        public double Confidence { get; set; }
    }

    public class LlmService : ILlmService
    {
        private IOpenAIService _openAiService;
        private string _apiKey;
        private string _apiBaseUrl; // New field for API Base URL
        private string _modelName;  // New field for Model Name
        private TimeSpan _httpClientTimeout = TimeSpan.FromSeconds(120); // Default value
        private const string PlaceholderApiKey = "YOUR_API_KEY_GOES_HERE"; 
        private const string DefaultModelName = "gpt-3.5-turbo"; // Default model

        // Prompts remain the same
        private const string PrioritizationSystemPrompt = 
            "Analyze the following task description and determine its importance and urgency. " +
            "Return your answer strictly in the format: \"Importance: [High/Medium/Low], Urgency: [High/Medium/Low]\". " +
            "Do not add any other text, explanations, or elaborations. Just the single line in the specified format.\n" +
            "For example, if the task is 'Fix critical login bug', you should respond with: \"Importance: High, Urgency: High\".\n" +
            "Task: ";

        private const string ClarityAnalysisSystemPrompt =
            "Analyze the following task description for clarity, specificity, and actionability. " +
            "Respond in the following format ONLY:\n" +
            "Status: [Clear/NeedsClarification]\n" +
            "Question: [If Status is NeedsClarification, provide a concise question to the user to get the necessary details. Otherwise, write N/A]\n" +
            "Examples:\n" +
            "Input Task: Organize event.\n" +
            "Status: NeedsClarification\n" +
            "Question: What kind of event is it and what are the key objectives or desired outcomes?\n\n" +
            "Input Task: Draft a project proposal for Q3 by Friday.\n" +
            "Status: Clear\n" +
            "Question: N/A\n\n" +
            "Input Task: ";

        private const string TaskDecompositionSystemPrompt =
            "Analyze the following task description. If the task is too broad or complex, break it down into 2-5 actionable sub-tasks. " +
            "If the task is already granular and actionable, indicate that it is sufficient. " +
            "Respond in the following format ONLY:\n" +
            "Status: [Sufficient/NeedsDecomposition]\n" +
            "Subtasks: [If NeedsDecomposition, provide a list of sub-tasks, each on a new line, optionally prefixed with '-' or '*'. If Sufficient, write N/A.]\n" +
            "Examples:\n" +
            "Input Task: Plan company retreat.\n" +
            "Status: NeedsDecomposition\n" +
            "Subtasks:\n" +
            "- Define budget and objectives\n" +
            "- Research and select venue\n" +
            "- Plan agenda and activities\n" +
            "- Coordinate logistics (transport, accommodation)\n\n" +
            "Input Task: Email John about the meeting report.\n" +
            "Status: Sufficient\n" +
            "Subtasks: N/A\n\n" +
            "Input Task: ";

        private const string TaskReminderSystemPrompt =
            "You are an assistant helping a user review a task. The task is described below, and you're given how old it is (time since last modification). " +
            "Generate a brief, friendly, encouraging reminder about the task. " +
            "Then, provide 2-3 actionable, concise suggestions for the user. " +
            "Respond in the following format ONLY:\n" +
            "Reminder: [Generated reminder text]\n" +
            "Suggestion1: [Text for suggestion 1]\n" +
            "Suggestion2: [Text for suggestion 2]\n" +
            "(Optional) Suggestion3: [Text for suggestion 3]\n\n" +
            "Task Description: {taskDescription}\n" +
            "Task Age: {taskAge}\n\n" +
            "Example output:\n" +
            "Reminder: Just checking in on the '{taskDescription}' task. It's been about {taskAge}. How's it going?\n" +
            "Suggestion1: Ready to complete it now?\n" +
            "Suggestion2: Need to adjust its plan or priority?\n" +
            "Suggestion3: Want to break it into smaller pieces?";

        private const string ReminderProfileHintTemplate =
            "\n\nUser behavior context (local profile, use as soft guidance only):\n{userContext}\n" +
            "Adapt tone and suggestions to reduce interruption. Keep one clear next step.";

        private const string SkillRecommendationSystemPromptTemplate =
            "You are a task execution copilot. Based on the task and context, recommend 1-3 skills that best help the user move forward now. " +
            "Allowed skill_id values ONLY: {allowedSkillIds}. " +
            "Return ONLY a valid JSON array. Each item must contain: " +
            "\"skill_id\", \"title\", \"why\", \"next_step\", \"confidence\" (0 to 1). " +
            "Keep title/why/next_step concise and actionable.\n" +
            "Task: {taskDescription}\n" +
            "Importance: {importance}\n" +
            "Urgency: {urgency}\n" +
            "InactiveDuration: {inactiveDuration}\n" +
            "UserContext: {userContext}";

        private const string ConversationTaskExtractPrompt =
            "You are an assistant helping a user capture personal action items from a multi-speaker conversation. " +
            "Extract ONLY tasks that the user should do. " +
            "Return a JSON array of strings. Do not include any extra text.\n" +
            "Conversation:\n";

        private const string GoalDecompositionSystemPrompt = @"
      You are an expert goal planning assistant. Your task is to take a user's long-term goal and a specified duration, and break it down into a series of smaller, actionable daily tasks. For each task, you must also categorize it into one of four quadrants based on its importance and urgency, and provide an estimated time for completion.

      The four quadrants are:
      1.  ""Important & Urgent""
      2.  ""Important & Not Urgent""
      3.  ""Not Important & Urgent""
      4.  ""Not Important & Not Urgent""

      The user will provide the goal and duration. You need to generate a plan of daily (or near-daily) tasks that will help the user achieve their goal within the given timeframe.

      Respond with a JSON array of task objects. Each object should have the following fields:
      -   ""task_description"": A string describing the task.
      -   ""quadrant"": A string representing one of the four quadrant categories (e.g., ""Important & Urgent"").
      -   ""estimated_time"": A string describing the estimated time to complete the task (e.g., ""1 hour"", ""30 minutes"").
      -   ""day"": An integer representing the day number in the plan (e.g., 1, 2, 3...). This is relative to the start of the plan.

      Example Input from User:
      Goal: ""I want to learn Python programming for web development.""
      Duration: ""3 months""

      Example JSON Output:
      [
        {
          ""day"": 1,
          ""task_description"": ""Set up Python development environment (install Python, VS Code, Git)."",
          ""quadrant"": ""Important & Urgent"",
          ""estimated_time"": ""2 hours""
        },
        {
          ""day"": 1,
          ""task_description"": ""Complete Chapter 1 of Python basics tutorial (variables, data types)."",
          ""quadrant"": ""Important & Not Urgent"",
          ""estimated_time"": ""1.5 hours""
        }
      ]

      Ensure the tasks are logically sequenced and contribute towards the main goal. Distribute tasks reasonably across the duration. For this request, please provide a detailed daily task plan for the **first 2 weeks** only, based on the user's goal of '{userGoal}' (total duration '{userDuration}'). This 2-week plan should be very detailed.
      User Input:
      Goal: ""{userGoal}""
      Duration: ""{userDuration}""

IMPORTANT: Your entire response MUST be a valid JSON array of task objects for the first 2 weeks, starting with '[' and ending with ']'. Do not include any other text, explanations, or markdown formatting outside of this JSON array. Be direct in your JSON output."; // Note the {userGoal} and {userDuration} placeholders.

        private const string LearningPlanDecompositionSystemPrompt = @"
      You are an expert learning plan assistant. Your task is to take a user's learning subject and goal, along with a specified duration, and break it down into a series of progressive learning milestones. For each milestone, you must provide a title, description, and estimated time for completion.

      The user will provide the subject, goal, and duration. You need to generate a structured learning plan with milestones that will help the user achieve their learning goal within the given timeframe.

      Respond with a JSON array of milestone objects. Each object should have the following fields:
      -   ""stage"": An integer representing the stage number in the learning plan (e.g., 1, 2, 3...).
      -   ""title"": A string title for the milestone.
      -   ""description"": A string describing what will be learned in this milestone.
      -   ""estimated_time"": A string describing the estimated time to complete this milestone (e.g., ""2 weeks"", ""1 month"").
      -   ""is_completed"": A boolean indicating completion status (always false for new plans).

      Example Input from User:
      Subject: ""Python Programming""
      Goal: ""Learn Python for web development""
      Duration: ""3 months""

      Example JSON Output:
      [
        {
          ""stage"": 1,
          ""title"": ""Python Fundamentals"",
          ""description"": ""Master Python basics including variables, data types, control flow, functions, and object-oriented programming concepts."",
          ""estimated_time"": ""3 weeks"",
          ""is_completed"": false
        },
        {
          ""stage"": 2,
          ""title"": ""Web Development with Flask"",
          ""description"": ""Learn Flask framework, routing, templates, and building RESTful APIs."",
          ""estimated_time"": ""4 weeks"",
          ""is_completed"": false
        }
      ]

      Ensure the milestones are logically sequenced and progressively build upon each other. Distribute milestones reasonably across the duration. For this request, please provide a comprehensive learning plan for the subject '{subject}' with the goal '{goal}' (total duration '{duration}').

      User Input:
      Subject: ""{subject}""
      Goal: ""{goal}""
      Duration: ""{duration}""

IMPORTANT: Your entire response MUST be a valid JSON array of milestone objects, starting with '[' and ending with ']'. Do not include any other text, explanations, or markdown formatting outside of this JSON array. Be direct in your JSON output."; // Note the {subject}, {goal}, and {duration} placeholders.
        
        public LlmService()
        {
            LoadLlmConfig(); // Renamed from LoadApiKeyFromConfig
            InitializeOpenAiService();
        }

        // Constructor for dependency injection, typically for testing
        internal LlmService(IOpenAIService openAiService, string apiKey, string apiBaseUrl, string modelName)
        {
            _openAiService = openAiService ?? throw new ArgumentNullException(nameof(openAiService));
            _apiKey = apiKey ?? throw new ArgumentNullException(nameof(apiKey));
            _apiBaseUrl = apiBaseUrl; // Can be null
            _modelName = modelName ?? throw new ArgumentNullException(nameof(modelName));

            // Ensure critical fields are not placeholder values if GetCompletionAsync relies on them
            if (_apiKey == PlaceholderApiKey)
            {
                // Or throw, or handle as per service's expectation for injected services.
                Console.WriteLine("Warning: LlmService injected with a placeholder API key.");
            }
            Console.WriteLine($"LlmService: Initialized with injected IOpenAIService. Model: {_modelName}. API Key Loaded: {!string.IsNullOrWhiteSpace(_apiKey) && _apiKey != PlaceholderApiKey}. Base URL: '{_apiBaseUrl ?? "OpenAI Default"}'");
        }

        public async Task<List<ProposedDailyTask>> DecomposeGoalIntoDailyTasksAsync(string goal, string durationString)
        {
            if (string.IsNullOrWhiteSpace(goal) || string.IsNullOrWhiteSpace(durationString))
            {
                Console.WriteLine("Goal or duration string is empty for DecomposeGoalIntoDailyTasksAsync.");
                return new List<ProposedDailyTask>();
            }

            string fullPrompt = GoalDecompositionSystemPrompt
                .Replace("{userGoal}", goal)
                .Replace("{userDuration}", durationString);

            string llmResponse = await GetCompletionAsync(fullPrompt);
            Console.WriteLine("LlmService: Raw LLM Response for Goal Decomposition:");
            Console.WriteLine(llmResponse);

            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid response for goal decomposition. Goal: '{goal}'. Response: {llmResponse}");
                throw new InvalidOperationException($"LLM API调用失败: {llmResponse}");
            }

            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true // Handles "task_description" vs "TaskDescription"
            };

            try
            {
                // Clean the response if it's wrapped in markdown ```json ... ```
                llmResponse = llmResponse.Trim();
                if (llmResponse.StartsWith("```json"))
                {
                    llmResponse = llmResponse.Substring(7);
                }
                if (llmResponse.EndsWith("```"))
                {
                    llmResponse = llmResponse.Substring(0, llmResponse.Length - 3);
                }
                llmResponse = llmResponse.Trim();

                List<ProposedDailyTask> tasks = JsonSerializer.Deserialize<List<ProposedDailyTask>>(llmResponse, options);

                if (tasks != null && tasks.Any())
                {
                    Console.WriteLine($"LlmService: Successfully parsed {tasks.Count} tasks. Reviewing for missing details...");
                    bool foundMissingDetails = false;
                    for (int i = 0; i < tasks.Count; i++)
                    {
                        var taskDetail = tasks[i];
                        bool hasMissingDescription = string.IsNullOrWhiteSpace(taskDetail.TaskDescription);
                        bool hasMissingTime = string.IsNullOrWhiteSpace(taskDetail.EstimatedTime);

                        if (hasMissingDescription || hasMissingTime)
                        {
                            foundMissingDetails = true;
                            Console.WriteLine($"LlmService: Parsed Task #{i + 1} (Day={taskDetail.Day}) has missing details: Description='{taskDetail.TaskDescription}', Quadrant='{taskDetail.Quadrant}', EstimatedTime='{taskDetail.EstimatedTime}'");
                        }
                    }
                    if (!foundMissingDetails)
                    {
                        Console.WriteLine("LlmService: All parsed tasks appear to have descriptions and estimated times.");
                        // Optional: Log first few tasks for confirmation if desired, e.g.:
                        // Console.WriteLine("LlmService: Logging first few tasks for confirmation (up to 3):");
                        // foreach (var taskDetail in tasks.Take(3))
                        // {
                        //     Console.WriteLine($"LlmService: Parsed Task: Day={taskDetail.Day}, Description='{taskDetail.TaskDescription}', Quadrant='{taskDetail.Quadrant}', EstimatedTime='{taskDetail.EstimatedTime}'");
                        // }
                    }
                }
                else if (tasks != null) // tasks is not null but empty, i.e., tasks.Count == 0
                {
                    Console.WriteLine("LlmService: LLM response parsed into an empty list of tasks.");
                }
                // If tasks is null, it implies a deserialization failure, which should be caught by JsonException handler.

                return tasks ?? new List<ProposedDailyTask>();
            }
            catch (JsonException jsonEx)
            {
                Console.WriteLine($"Error parsing JSON response for goal decomposition: {jsonEx.Message}. Response was: {llmResponse}");
                return new List<ProposedDailyTask>(); // Directly return an empty list
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An unexpected error occurred during goal decomposition: {ex.Message}. Response was: {llmResponse}");
                return new List<ProposedDailyTask>(); // Or throw
            }
        }

        public async Task<List<LlmLearningMilestone>> DecomposeLearningPlanIntoMilestonesAsync(string subject, string goal, string durationString)
        {
            if (string.IsNullOrWhiteSpace(subject) || string.IsNullOrWhiteSpace(goal) || string.IsNullOrWhiteSpace(durationString))
            {
                Console.WriteLine("Subject, goal, or duration string is empty for DecomposeLearningPlanIntoMilestonesAsync.");
                return new List<LlmLearningMilestone>();
            }

            string fullPrompt = LearningPlanDecompositionSystemPrompt
                .Replace("{subject}", subject)
                .Replace("{goal}", goal)
                .Replace("{duration}", durationString);

            string llmResponse = await GetCompletionAsync(fullPrompt);
            Console.WriteLine("LlmService: Raw LLM Response for Learning Plan Decomposition:");
            Console.WriteLine(llmResponse);

            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid response for learning plan decomposition. Subject: '{subject}', Goal: '{goal}'. Response: {llmResponse}");
                throw new InvalidOperationException($"LLM API调用失败: {llmResponse}");
            }

            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };

            try
            {
                llmResponse = llmResponse.Trim();
                if (llmResponse.StartsWith("```json"))
                {
                    llmResponse = llmResponse.Substring(7);
                }
                if (llmResponse.EndsWith("```"))
                {
                    llmResponse = llmResponse.Substring(0, llmResponse.Length - 3);
                }
                llmResponse = llmResponse.Trim();

                List<LlmLearningMilestone> milestones = JsonSerializer.Deserialize<List<LlmLearningMilestone>>(llmResponse, options);

                if (milestones != null && milestones.Any())
                {
                    Console.WriteLine($"LlmService: Successfully parsed {milestones.Count} milestones.");
                    foreach (var milestone in milestones)
                    {
                        milestone.IsCompleted = false;
                    }
                }
                else if (milestones != null)
                {
                    Console.WriteLine("LlmService: LLM response parsed into an empty list of milestones.");
                }

                return milestones ?? new List<LlmLearningMilestone>();
            }
            catch (JsonException jsonEx)
            {
                Console.WriteLine($"Error parsing JSON response for learning plan decomposition: {jsonEx.Message}");
                Console.WriteLine($"JSON Path: {jsonEx.Path}, Line: {jsonEx.LineNumber}, Position: {jsonEx.BytePositionInLine}");
                Console.WriteLine($"Raw response that failed to parse: {llmResponse}");
                return new List<LlmLearningMilestone>();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An unexpected error occurred during learning plan decomposition: {ex.Message}");
                Console.WriteLine($"Exception type: {ex.GetType().Name}");
                Console.WriteLine($"Raw response: {llmResponse}");
                return new List<LlmLearningMilestone>();
            }
        }

        internal string FormatTimeSpan(TimeSpan ts)
        {
            if (ts.TotalDays >= 7)
            {
                int weeks = (int)(ts.TotalDays / 7);
                return $"{weeks} week{(weeks > 1 ? "s" : "")} old";
            }
            if (ts.TotalDays >= 1)
            {
                return $"{(int)ts.TotalDays} day{(ts.TotalDays > 1 ? "s" : "")} old";
            }
            if (ts.TotalHours >= 1)
            {
                return $"{(int)ts.TotalHours} hour{(ts.TotalHours > 1 ? "s" : "")} old";
            }
            return "less than an hour old";
        }

        internal static (string reminder, List<string> suggestions) ParseReminderResponse(string llmResponse)
        {
            Console.WriteLine($"Parsing LLM reminder response: \"{llmResponse}\"");
            var suggestions = new List<string>();
            string reminder = string.Empty;

            if (string.IsNullOrWhiteSpace(llmResponse))
            {
                Console.WriteLine("LLM response is null or whitespace. Returning empty reminder and suggestions.");
                return (reminder, suggestions);
            }

            try
            {
                var reminderRegex = new Regex(@"Reminder\s*:\s*(.*)", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                var suggestion1Regex = new Regex(@"Suggestion1\s*:\s*(.*)", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                var suggestion2Regex = new Regex(@"Suggestion2\s*:\s*(.*)", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                var suggestion3Regex = new Regex(@"Suggestion3\s*:\s*(.*)", RegexOptions.IgnoreCase | RegexOptions.Singleline);

                var reminderMatch = reminderRegex.Match(llmResponse);
                if (reminderMatch.Success)
                {
                    reminder = reminderMatch.Groups[1].Value.Trim();
                }
                else
                {
                    Console.WriteLine("Could not find 'Reminder:' pattern in LLM response.");
                }

                var suggestion1Match = suggestion1Regex.Match(llmResponse);
                if (suggestion1Match.Success)
                {
                    suggestions.Add(suggestion1Match.Groups[1].Value.Trim());
                }
                else
                {
                    Console.WriteLine("Could not find 'Suggestion1:' pattern in LLM response.");
                }

                var suggestion2Match = suggestion2Regex.Match(llmResponse);
                if (suggestion2Match.Success)
                {
                    suggestions.Add(suggestion2Match.Groups[1].Value.Trim());
                }
                else
                {
                     Console.WriteLine("Could not find 'Suggestion2:' pattern in LLM response.");
                }

                var suggestion3Match = suggestion3Regex.Match(llmResponse);
                if (suggestion3Match.Success)
                {
                    string sug3 = suggestion3Match.Groups[1].Value.Trim();
                    if (!string.IsNullOrWhiteSpace(sug3) && !sug3.Equals("N/A", StringComparison.OrdinalIgnoreCase))
                    {
                        suggestions.Add(sug3);
                    }
                }
                // Optional: Log if Suggestion3 is not found, but it's optional so might be too noisy.

                if (string.IsNullOrWhiteSpace(reminder) && !suggestions.Any())
                {
                    Console.WriteLine($"Could not parse any reminder or suggestions from LLM response using regex: '{llmResponse}'.");
                }
                Console.WriteLine($"Parsed Reminder: \"{reminder}\", Suggestions: {suggestions.Count}");
                return (reminder, suggestions);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing LLM reminder response with regex: {ex.Message}. Response was: {llmResponse}");
                Console.WriteLine($"Defaulted Reminder/Suggestions due to exception: Reminder='', Suggestions=[]");
                return (string.Empty, new List<string>());
            }
        }
        
        public async Task<(string reminder, List<string> suggestions)> GenerateTaskReminderAsync(string taskDescription, TimeSpan timeSinceLastModified)
        {
            return await GenerateTaskReminderAsync(taskDescription, timeSinceLastModified, null);
        }

        public async Task<(string reminder, List<string> suggestions)> GenerateTaskReminderAsync(string taskDescription, TimeSpan timeSinceLastModified, string userContext)
        {
            if (string.IsNullOrWhiteSpace(taskDescription)) return (string.Empty, new List<string>());
            string formattedAge = FormatTimeSpan(timeSinceLastModified);
            string fullPrompt = TaskReminderSystemPrompt.Replace("{taskDescription}", taskDescription).Replace("{taskAge}", formattedAge);
            if (!string.IsNullOrWhiteSpace(userContext))
            {
                fullPrompt += ReminderProfileHintTemplate.Replace("{userContext}", userContext);
            }
            string llmResponse = await GetCompletionAsync(fullPrompt);
            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid reminder for '{taskDescription}'. Response: {llmResponse}");
                throw new InvalidOperationException($"LLM API调用失败: {llmResponse}");
            }
            return ParseReminderResponse(llmResponse);
        }

        public async Task<List<LlmSkillRecommendation>> RecommendTaskSkillsAsync(
            string taskDescription,
            string importance,
            string urgency,
            TimeSpan inactiveDuration,
            string userContext,
            int maxSkills = 3)
        {
            if (string.IsNullOrWhiteSpace(taskDescription))
            {
                return new List<LlmSkillRecommendation>();
            }

            string context = string.IsNullOrWhiteSpace(userContext) ? "N/A" : userContext;
            string prompt = SkillRecommendationSystemPromptTemplate
                .Replace("{allowedSkillIds}", ThinkingToolAdvisor.GetAllowedSkillIdsCsv())
                .Replace("{taskDescription}", taskDescription)
                .Replace("{importance}", string.IsNullOrWhiteSpace(importance) ? "Unknown" : importance)
                .Replace("{urgency}", string.IsNullOrWhiteSpace(urgency) ? "Unknown" : urgency)
                .Replace("{inactiveDuration}", FormatTimeSpan(inactiveDuration))
                .Replace("{userContext}", context);

            try
            {
                string llmResponse = await GetCompletionAsync(prompt);
                if (IsErrorResponse(llmResponse))
                {
                    Console.WriteLine($"LLM skill recommendation failed for '{taskDescription}'. Fallback to rules. Response: {llmResponse}");
                    return GetRuleBasedSkillRecommendations(taskDescription, importance, urgency, inactiveDuration, maxSkills);
                }

                var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
                var parsed = JsonSerializer.Deserialize<List<LlmSkillRecommendation>>(llmResponse, options) ?? new List<LlmSkillRecommendation>();
                var filtered = parsed
                    .Where(s => s != null && IsAllowedSkillId(s.SkillId))
                    .Select(s => NormalizeSkillRecommendation(s))
                    .ToList();

                var ruleBased = GetRuleBasedSkillRecommendations(taskDescription, importance, urgency, inactiveDuration, maxSkills);
                var merged = filtered
                    .Concat(ruleBased)
                    .Where(s => s != null && IsAllowedSkillId(s.SkillId))
                    .GroupBy(s => s.SkillId, StringComparer.OrdinalIgnoreCase)
                    .Select(g => g.OrderByDescending(x => x.Confidence).First())
                    .OrderByDescending(s => s.Confidence)
                    .Take(Math.Max(1, maxSkills))
                    .ToList();

                if (merged.Count > 0)
                {
                    return merged;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing LLM skill recommendation, fallback to rules. {ex.Message}");
            }

            return GetRuleBasedSkillRecommendations(taskDescription, importance, urgency, inactiveDuration, maxSkills);
        }

        private static bool IsAllowedSkillId(string skillId)
        {
            return ThinkingToolAdvisor.IsAllowedSkillId(skillId);
        }

        private static LlmSkillRecommendation NormalizeSkillRecommendation(LlmSkillRecommendation s)
        {
            return new LlmSkillRecommendation
            {
                SkillId = (s.SkillId ?? "clarify_goal").Trim().ToLowerInvariant(),
                Title = string.IsNullOrWhiteSpace(s.Title) ? "执行技能建议" : s.Title.Trim(),
                Why = string.IsNullOrWhiteSpace(s.Why) ? "帮助你更快推进任务。" : s.Why.Trim(),
                NextStep = string.IsNullOrWhiteSpace(s.NextStep) ? "先执行一个可在10分钟内完成的动作。" : s.NextStep.Trim(),
                Confidence = Math.Max(0, Math.Min(1, s.Confidence))
            };
        }

        private static List<LlmSkillRecommendation> GetRuleBasedSkillRecommendations(
            string taskDescription,
            string importance,
            string urgency,
            TimeSpan inactiveDuration,
            int maxSkills)
        {
            var result = ThinkingToolAdvisor.RecommendForTask(taskDescription, importance, urgency, inactiveDuration, maxSkills + 2);
            return result
                .Select(r => new LlmSkillRecommendation
                {
                    SkillId = (r.SkillId ?? "clarify_goal").Trim().ToLowerInvariant(),
                    Title = string.IsNullOrWhiteSpace(r.Title) ? "执行技能建议" : r.Title.Trim(),
                    Why = string.IsNullOrWhiteSpace(r.Why) ? "帮助你更快推进任务。" : r.Why.Trim(),
                    NextStep = string.IsNullOrWhiteSpace(r.NextStep) ? "先执行一个可在10分钟内完成的动作。" : r.NextStep.Trim(),
                    Confidence = Math.Max(0, Math.Min(1, r.Confidence))
                })
                .Where(s => IsAllowedSkillId(s.SkillId))
                .GroupBy(s => s.SkillId, StringComparer.OrdinalIgnoreCase)
                .Select(g => g.OrderByDescending(x => x.Confidence).First())
                .OrderByDescending(s => s.Confidence)
                .Take(Math.Max(1, maxSkills))
                .ToList();
        }

        internal static (DecompositionStatus status, List<string> subtasks) ParseDecompositionResponse(string llmResponse)
        {
            Console.WriteLine($"Parsing LLM decomposition response: \"{llmResponse}\"");
            var subtasks = new List<string>();
            DecompositionStatus status = DecompositionStatus.Unknown;

            if (string.IsNullOrWhiteSpace(llmResponse))
            {
                Console.WriteLine("LLM response is null or whitespace. Defaulting to Unknown status and empty subtasks.");
                return (status, subtasks);
            }

            try
            {
                var statusRegex = new Regex(@"Status\s*:\s*(Sufficient|NeedsDecomposition)", RegexOptions.IgnoreCase);
                var statusMatch = statusRegex.Match(llmResponse);

                if (statusMatch.Success)
                {
                    string statusStr = statusMatch.Groups[1].Value;
                    if (!Enum.TryParse(statusStr, true, out status))
                    {
                        status = DecompositionStatus.Unknown;
                        Console.WriteLine($"Could not parse decomposition status value '{statusStr}' from LLM response. Defaulting to Unknown.");
                    }
                }
                else
                {
                    Console.WriteLine($"Could not find 'Status:' for decomposition in LLM response. Defaulting to Unknown.");
                    // No early return, will log final status and subtasks at the end
                }

                if (status == DecompositionStatus.NeedsDecomposition)
                {
                    var subtasksRegex = new Regex(@"Subtasks\s*:\s*((?:.|\n)*)", RegexOptions.IgnoreCase | RegexOptions.Multiline);
                    var subtasksMatch = subtasksRegex.Match(llmResponse);

                    if (subtasksMatch.Success)
                    {
                        string subtasksBlock = subtasksMatch.Groups[1].Value.Trim();
                        if (!string.IsNullOrWhiteSpace(subtasksBlock) && !subtasksBlock.Equals("N/A", StringComparison.OrdinalIgnoreCase))
                        {
                            string[] lines = subtasksBlock.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
                            foreach (string line in lines)
                            {
                                string trimmedLine = line.Trim();
                                if (trimmedLine.StartsWith("-") || trimmedLine.StartsWith("*"))
                                {
                                    trimmedLine = trimmedLine.Substring(1).Trim();
                                }
                                if (!string.IsNullOrWhiteSpace(trimmedLine) && !trimmedLine.Equals("N/A", StringComparison.OrdinalIgnoreCase))
                                {
                                    subtasks.Add(trimmedLine);
                                }
                            }
                        }
                        if (!subtasks.Any())
                        {
                            Console.WriteLine($"Decomposition status is NeedsDecomposition but no valid subtasks found or parsed from block: '{subtasksBlock}'.");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"Decomposition status is NeedsDecomposition but 'Subtasks:' block not found in LLM response.");
                        // Status might remain NeedsDecomposition but subtasks list will be empty.
                    }
                }
                Console.WriteLine($"Parsed Decomposition: Status={status}, Subtasks Count={subtasks.Count}");
                return (status, subtasks);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing LLM decomposition response with regex: {ex.Message}. Response was: {llmResponse}");
                Console.WriteLine($"Defaulted Decomposition due to exception: Status=Unknown, Subtasks=[]");
                return (DecompositionStatus.Unknown, new List<string>());
            }
        }

        public async Task<(DecompositionStatus status, List<string> subtasks)> DecomposeTaskAsync(string taskDescription)
        {
            if (string.IsNullOrWhiteSpace(taskDescription)) return (DecompositionStatus.Unknown, new List<string>());
            string fullPrompt = TaskDecompositionSystemPrompt + taskDescription;
            string llmResponse = await GetCompletionAsync(fullPrompt);
            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid decomposition for '{taskDescription}'. Response: {llmResponse}");
                return (DecompositionStatus.Unknown, new List<string>());
            }
            return ParseDecompositionResponse(llmResponse);
        }

        internal static (ClarityStatus status, string question) ParseClarityResponse(string llmResponse)
        {
            Console.WriteLine($"Parsing LLM clarity response: \"{llmResponse}\"");
            ClarityStatus status = ClarityStatus.Unknown;
            string question = string.Empty; // Default to empty string

            if (string.IsNullOrWhiteSpace(llmResponse))
            {
                Console.WriteLine("LLM response is null or whitespace. Defaulting to Unknown status and empty question.");
                question = "LLM response was empty."; // Keep original error message for this specific case
                return (status, question);
            }

            try
            {
                var statusRegex = new Regex(@"Status\s*:\s*(Clear|NeedsClarification)", RegexOptions.IgnoreCase);
                var questionRegex = new Regex(@"Question\s*:\s*((?:.|\n)*)", RegexOptions.IgnoreCase | RegexOptions.Multiline);

                var statusMatch = statusRegex.Match(llmResponse);
                if (statusMatch.Success)
                {
                    string statusStr = statusMatch.Groups[1].Value;
                    if (Enum.TryParse(statusStr, true, out ClarityStatus parsedStatus))
                    {
                        status = parsedStatus;
                    }
                    else
                    {
                        Console.WriteLine($"Could not parse clarity status value '{statusStr}' from LLM response. Defaulting to Unknown.");
                        status = ClarityStatus.Unknown;
                    }
                }
                else
                {
                    Console.WriteLine("Could not find 'Status:' pattern in LLM response. Defaulting to Unknown status.");
                    // No early return, will log final status and question at the end
                }

                var questionMatch = questionRegex.Match(llmResponse);
                if (questionMatch.Success)
                {
                    question = questionMatch.Groups[1].Value.Trim();
                    if (status == ClarityStatus.Clear && (string.IsNullOrWhiteSpace(question) || question.Equals("N/A", StringComparison.OrdinalIgnoreCase)))
                    {
                        question = string.Empty; // Clear question if status is Clear and question is N/A or empty
                    }
                }
                else
                {
                    Console.WriteLine("Could not find 'Question:' pattern in LLM response.");
                    if (status == ClarityStatus.NeedsClarification)
                    {
                        question = "Question expected but not found in response."; // More specific if status indicated a question was expected
                    } else if (status == ClarityStatus.Unknown) {
                        question = "Failed to parse status and question from LLM response.";
                    }
                }

                if (status == ClarityStatus.Unknown && !statusMatch.Success) { // If status is still unknown because regex failed
                     question = "Failed to parse status from LLM response.";
                } else if (status == ClarityStatus.NeedsClarification && string.IsNullOrWhiteSpace(question)) {
                    Console.WriteLine("Warning: Status is NeedsClarification, but question is empty or N/A.");
                    // question = "Clarification needed, but no specific question was parsed."; // Optionally override if needed
                }


                Console.WriteLine($"Parsed Clarity: Status={status}, Question=\"{question}\"");
                return (status, question);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing LLM clarity response with regex: {ex.Message}. Response was: {llmResponse}");
                Console.WriteLine($"Defaulted Clarity due to exception: Status=Unknown, Question='Failed to analyze task clarity due to an exception.'");
                return (ClarityStatus.Unknown, "Failed to analyze task clarity due to an exception.");
            }
        }

        public async Task<(string importance, string urgency)> AnalyzeTaskPriorityAsync(string taskDescription)
        {
            if (string.IsNullOrWhiteSpace(taskDescription)) return ("Medium", "Medium");
            string fullPrompt = PrioritizationSystemPrompt + taskDescription;
            string llmResponse = await GetCompletionAsync(fullPrompt);
            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid priority analysis for '{taskDescription}'. Response: {llmResponse}");
                return ("Medium", "Medium");
            }
            return ParsePriorityResponse(llmResponse);
        }

        public async Task<(ClarityStatus status, string question)> AnalyzeTaskClarityAsync(string taskDescription)
        {
            if (string.IsNullOrWhiteSpace(taskDescription)) return (ClarityStatus.Unknown, "Task description cannot be empty.");
            string fullPrompt = ClarityAnalysisSystemPrompt + taskDescription;
            string llmResponse = await GetCompletionAsync(fullPrompt);
            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid clarity analysis for '{taskDescription}'. Response: {llmResponse}");
                return (ClarityStatus.Unknown, "Failed to analyze task clarity (LLM error or dummy response).");
            }
            return ParseClarityResponse(llmResponse);
        }

        internal static (string Importance, string Urgency) ParsePriorityResponse(string llmResponse)
        {
            Console.WriteLine($"Parsing LLM priority response: \"{llmResponse}\"");
            if (string.IsNullOrWhiteSpace(llmResponse))
            {
                Console.WriteLine("LLM response is null or whitespace. Defaulting to Unknown/Unknown.");
                return ("Unknown", "Unknown");
            }

            string importance = "Unknown";
            string urgency = "Unknown";

            try
            {
                // Regex to find "Importance: [value]" and "Urgency: [value]", case-insensitive labels, flexible whitespace
                var importanceRegex = new Regex(@"Importance\s*:\s*([A-Za-z]+)", RegexOptions.IgnoreCase);
                var urgencyRegex = new Regex(@"Urgency\s*:\s*([A-Za-z]+)", RegexOptions.IgnoreCase);

                var importanceMatch = importanceRegex.Match(llmResponse);
                var urgencyMatch = urgencyRegex.Match(llmResponse);

                string[] validPriorities = { "High", "Medium", "Low" };
                var validPrioritySet = new HashSet<string>(validPriorities, StringComparer.OrdinalIgnoreCase);

                if (importanceMatch.Success)
                {
                    string extractedImportance = importanceMatch.Groups[1].Value.Trim();
                    if (validPrioritySet.Contains(extractedImportance))
                    {
                        // Normalize to title case e.g. "high" -> "High"
                        importance = validPriorities.First(p => p.Equals(extractedImportance, StringComparison.OrdinalIgnoreCase));
                    }
                    else
                    {
                        Console.WriteLine($"Extracted importance '{extractedImportance}' is not a valid priority. Defaulting to Unknown.");
                    }
                }
                else
                {
                    Console.WriteLine("Could not find 'Importance:' pattern in LLM response.");
                }

                if (urgencyMatch.Success)
                {
                    string extractedUrgency = urgencyMatch.Groups[1].Value.Trim();
                    if (validPrioritySet.Contains(extractedUrgency))
                    {
                        // Normalize to title case
                        urgency = validPriorities.First(p => p.Equals(extractedUrgency, StringComparison.OrdinalIgnoreCase));
                    }
                    else
                    {
                        Console.WriteLine($"Extracted urgency '{extractedUrgency}' is not a valid priority. Defaulting to Unknown.");
                    }
                }
                else
                {
                    Console.WriteLine("Could not find 'Urgency:' pattern in LLM response.");
                }

                if (importance == "Unknown" && urgency == "Unknown" && !importanceMatch.Success && !urgencyMatch.Success)
                {
                     Console.WriteLine($"Could not parse Importance or Urgency from LLM response using regex: '{llmResponse}'. Both remain Unknown.");
                }
                Console.WriteLine($"Parsed Priority: Importance={importance}, Urgency={urgency}");
                return (importance, urgency);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing LLM priority response with regex: {ex.Message}. Response was: {llmResponse}");
                Console.WriteLine($"Defaulted Priority due to exception: Importance=Unknown, Urgency=Unknown");
                return ("Unknown", "Unknown");
            }
        }

        public async Task<(string Importance, string Urgency)> GetTaskPriorityAsync(string taskDescription)
        {
            if (string.IsNullOrWhiteSpace(taskDescription)) return ("Unknown", "Unknown");
            string fullPrompt = PrioritizationSystemPrompt + taskDescription;
            string llmResponse = await GetCompletionAsync(fullPrompt);
            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide a valid priority response for '{taskDescription}'. Response: {llmResponse}");
                return ("Unknown", "Unknown");
            }
            return ParsePriorityResponse(llmResponse);
        }

        public async Task<List<string>> ExtractTasksFromConversationAsync(string conversation)
        {
            if (string.IsNullOrWhiteSpace(conversation))
                return new List<string>();

            string prompt = ConversationTaskExtractPrompt + conversation;
            string llmResponse = await GetCompletionAsync(prompt);

            if (IsErrorResponse(llmResponse))
            {
                Console.WriteLine($"LLM did not provide valid conversation extraction. Response: {llmResponse}");
                return new List<string>();
            }

            try
            {
                var tasks = JsonSerializer.Deserialize<List<string>>(llmResponse);
                if (tasks != null && tasks.Count > 0)
                    return tasks.Where(t => !string.IsNullOrWhiteSpace(t)).ToList();
            }
            catch { }

            // Fallback parse: split lines
            var lines = llmResponse.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(l => l.Trim().TrimStart('-', '*', '•'))
                .Where(l => !string.IsNullOrWhiteSpace(l))
                .ToList();
            return lines;
        }
        
        private void LoadLlmConfig() // Renamed and updated
        {
            try
            {
                _apiKey = ConfigurationManager.AppSettings["OpenAIApiKey"];
                _apiBaseUrl = ConfigurationManager.AppSettings["LlmApiBaseUrl"]; // Load new setting
                _modelName = ConfigurationManager.AppSettings["LlmModelName"];   // Load new setting

                string timeoutSetting = ConfigurationManager.AppSettings["LlmRequestTimeoutSeconds"];
                if (!string.IsNullOrWhiteSpace(timeoutSetting) && int.TryParse(timeoutSetting, out int timeoutSeconds) && timeoutSeconds > 0)
                {
                    _httpClientTimeout = TimeSpan.FromSeconds(timeoutSeconds);
                    Console.WriteLine($"LLM Service: Using configured HTTP client timeout of {timeoutSeconds} seconds.");
                }
                else
                {
                    Console.WriteLine($"LLM Service: LlmRequestTimeoutSeconds setting is missing, invalid, or not positive. Using default timeout of {_httpClientTimeout.TotalSeconds} seconds.");
                }
            }
            catch (ConfigurationErrorsException ex)
            {
                Console.WriteLine($"Error reading App.config: {ex.Message}");
                _apiKey = null; 
                _apiBaseUrl = null;
                _modelName = null;
            }

            if (string.IsNullOrWhiteSpace(_apiKey) || _apiKey == PlaceholderApiKey)
            {
                Console.WriteLine("Warning: LLM Service: API key is placeholder or missing in App.config. LLM features will use dummy responses.");
                _apiKey = PlaceholderApiKey; 
            }

            // _apiBaseUrl can be legitimately empty/null for OpenAI default
            if (string.IsNullOrWhiteSpace(_modelName))
            {
                Console.WriteLine($"Warning: LLM Service: Model name is missing in App.config. Defaulting to '{DefaultModelName}'.");
                _modelName = DefaultModelName;
            }
            else
            {
                // Basic check if model name from config looks like a known OpenAI static model string,
                // otherwise, use it as a custom model string.
                // Example: Models.Gpt_3_5_Turbo is a static string constant.
                // If _modelName is something like "ft:gpt-3.5-turbo:my-org:custom-suffix:id", it's a custom model.
                // The Betalgo library expects the model string directly.
            }
        }

        private bool IsErrorResponse(string llmResponse)
        {
            return string.IsNullOrWhiteSpace(llmResponse) || 
                   llmResponse.StartsWith("LLM dummy response") || 
                   llmResponse.StartsWith("Error from LLM") || 
                   llmResponse.StartsWith("Error from Zhipu AI");
        }

        private async Task<string> CallZhipuAiApiAsync(string prompt)
        {
            try
            {
                string apiUrl = $"{_apiBaseUrl.TrimEnd('/')}/chat/completions";

                var requestBody = new
                {
                    model = _modelName,
                    messages = new[]
                    {
                        new
                        {
                            role = "user",
                            content = prompt
                        }
                    },
                    max_tokens = 8192
                };

                var jsonBody = JsonSerializer.Serialize(requestBody);
                var content = new StringContent(jsonBody, Encoding.UTF8, "application/json");

                using (var httpClient = new HttpClient { Timeout = _httpClientTimeout })
                {
                    httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");

                    Console.WriteLine($"Calling Zhipu AI API: {apiUrl}");
                    Console.WriteLine($"Request body: {jsonBody}");

                    var response = await httpClient.PostAsync(apiUrl, content);
                    string responseContent = await response.Content.ReadAsStringAsync();

                    Console.WriteLine($"Zhipu AI API Response Status: {response.StatusCode}");
                    Console.WriteLine($"Zhipu AI API Response Content: {responseContent}");

                    if (!response.IsSuccessStatusCode)
                    {
                        return $"Error from Zhipu AI: HTTP {response.StatusCode} - {responseContent}";
                    }

                    var jsonResponse = JsonSerializer.Deserialize<JsonElement>(responseContent);
                    if (jsonResponse.TryGetProperty("choices", out var choices) && choices.GetArrayLength() > 0)
                    {
                        var firstChoice = choices[0];
                        if (firstChoice.TryGetProperty("message", out var message) && message.TryGetProperty("content", out var contentElement))
                        {
                            return contentElement.GetString();
                        }
                    }

                    return "Error from Zhipu AI: Invalid response format";
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception calling Zhipu AI API: {ex.Message}");
                return $"Error from Zhipu AI: {ex.Message}";
            }
        }

        private void InitializeOpenAiService()
        {
            var options = new Betalgo.Ranul.OpenAI.OpenAIOptions()
            {
                ApiKey = _apiKey
            };

            if (!string.IsNullOrWhiteSpace(_apiBaseUrl))
            {
                options.BaseDomain = _apiBaseUrl; // Set BaseDomain if provided
                Console.WriteLine($"LlmService: Using custom API Base URL: {_apiBaseUrl}");
            }

            var httpClient = new HttpClient
            {
                Timeout = _httpClientTimeout // Use the configured value
            };

            _openAiService = new Betalgo.Ranul.OpenAI.Managers.OpenAIService(options, httpClient);
            Console.WriteLine($"LlmService: Initialized OpenAIService with custom HttpClient ({_httpClientTimeout.TotalSeconds}s timeout). Provider: OpenAI (Betalgo.Ranul.OpenAI). Model: {_modelName}.");
        }

        public async Task<string> GetCompletionAsync(string prompt)
        {
            // Check if using Zhipu AI
            bool isZhipuAi = !string.IsNullOrWhiteSpace(_apiBaseUrl) && _apiBaseUrl.Contains("bigmodel.cn");
            
            if (isZhipuAi)
            {
                Console.WriteLine("Detected Zhipu AI provider, using custom API client");
                return await CallZhipuAiApiAsync(prompt);
            }

            // Original OpenAI-compatible API path
            if (_openAiService == null || _apiKey == PlaceholderApiKey || string.IsNullOrWhiteSpace(_apiKey))
            {
                Console.WriteLine("LLM Service not properly initialized. Returning dummy response.");
                if (_apiKey == PlaceholderApiKey || string.IsNullOrWhiteSpace(_apiKey))
                {
                    return await Task.FromResult($"LLM dummy response (Configuration Error: API key missing or placeholder). Prompt: {prompt}");
                }
                return await Task.FromResult($"LLM dummy response for: {prompt}");
            }

            // Added logging for diagnostics
            // Determine the correct endpoint path based on the API provider
            string endpointPath;
            if (!string.IsNullOrWhiteSpace(_apiBaseUrl) && _apiBaseUrl.Contains("bigmodel.cn"))
            {
                endpointPath = "chat/completions"; // Zhipu AI (GLM) uses this path
            }
            else
            {
                endpointPath = "v1/chat/completions"; // OpenAI and compatible APIs use this path
            }
            
            string targetUrl = (_apiBaseUrl != null ? _apiBaseUrl.TrimEnd('/') : "https://api.openai.com") + "/" + endpointPath.TrimStart('/');
            Console.WriteLine($"LLM Request: Target URL: {targetUrl}");
            Console.WriteLine($"LLM Request: Model Name: {_modelName}");
            bool apiKeyLoaded = !string.IsNullOrWhiteSpace(_apiKey) && _apiKey != PlaceholderApiKey;
            string apiKeyFirstChars = apiKeyLoaded && _apiKey.Length >= 5 ? _apiKey.Substring(0, 5) : "N/A";
            Console.WriteLine($"LLM Request: ApiKey Loaded: {apiKeyLoaded}, First 5 chars: {(apiKeyLoaded ? apiKeyFirstChars : "N/A")}");

            try
            {
                int currentMaxTokens = 8192; // Define MaxTokens
                Console.WriteLine($"LLM Request: Using MaxTokens = {currentMaxTokens}"); // Log MaxTokens
                var completionResult = await _openAiService.ChatCompletion.CreateCompletion(new ChatCompletionCreateRequest
                {
                    Messages = new List<ChatMessage> 
                    {
                        ChatMessage.FromUser(prompt) 
                    },
                    Model = _modelName, // Use configured model name
                    MaxTokens = currentMaxTokens
                });

                if (completionResult.Successful)
                {
                    if (completionResult.Choices != null) // Defensive null check for Choices
                    {
                        var choice = completionResult.Choices.FirstOrDefault();
                        var content = choice?.Message.Content;
                        if (string.IsNullOrWhiteSpace(content))
                        {
                            Console.WriteLine("LLM API call was successful but returned empty or whitespace content from choice.");
                            Console.WriteLine($"Choice Finish Reason: {choice?.FinishReason}");
                            try
                            {
                                var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true };
                                Console.WriteLine($"Full completionResult details: {System.Text.Json.JsonSerializer.Serialize(completionResult, options)}");
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine($"Failed to serialize completionResult: {ex.Message}");
                            }
                            return content; // content will be null or whitespace
                        }
                        return content;
                    }
                    else // Choices is null despite Successful == true
                    {
                        Console.WriteLine("LLM API call was successful but Choices collection is null. This is unexpected.");
                        try
                        {
                            var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true };
                            Console.WriteLine($"Full completionResult details (Choices was null): {System.Text.Json.JsonSerializer.Serialize(completionResult, options)}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Failed to serialize completionResult (Choices was null): {ex.Message}");
                        }
                        return null; // Or handle as an error specific to this unusual case
                    }
                }
                else // Not successful
                {
                    try // Inner try for parsing the Error object
                    {
                        if (completionResult.Error == null)
                        {
                            Console.WriteLine("LLM API Error: Call was not successful but Error object is null.");
                            return "Error from LLM: Unknown error (null error object).";
                        }
                        
                        // Log the raw error response for debugging
                        try
                        {
                            var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true };
                            Console.WriteLine($"LLM API Raw Error Response: {System.Text.Json.JsonSerializer.Serialize(completionResult, options)}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Failed to serialize completionResult for error logging: {ex.Message}");
                        }
                        
                        // Accessing these properties might trigger JsonException if the Error object itself is malformed
                        string errorMessage = completionResult.Error.Message;
                        string errorCode = completionResult.Error.Code;
                        string errorType = completionResult.Error.Type;
                        Console.WriteLine($"LLM API Error: {errorMessage} (Code: {errorCode}, Type: {errorType})");
                        return $"Error from LLM: {errorMessage}";
                    }
                    catch (System.Text.Json.JsonException jsonExInner)
                    {
                        Console.WriteLine($"Error deserializing the LLM error object. Path: {jsonExInner.Path}, Line: {jsonExInner.LineNumber}, Pos: {jsonExInner.BytePositionInLine}. Details: {jsonExInner.Message}");
                        
                        // Try to get more information about the raw response
                        try
                        {
                            var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true };
                            Console.WriteLine($"LLM API Raw Response (error parsing failed): {System.Text.Json.JsonSerializer.Serialize(completionResult, options)}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Failed to serialize completionResult: {ex.Message}");
                        }
                        
                        return $"Error from LLM: Could not parse the error details from response. Details: {jsonExInner.Message}";
                    }
                }
            }
            catch (System.Text.Json.JsonException jsonExOuter) // For issues with the entire response
            {
                Console.WriteLine($"Error deserializing the entire LLM response. Path: {jsonExOuter.Path}, Line: {jsonExOuter.LineNumber}, Pos: {jsonExOuter.BytePositionInLine}. Details: {jsonExOuter.Message}");
                return $"Error from LLM: Could not parse the entire response. Details: {jsonExOuter.Message}";
            }
            catch (TaskCanceledException tex) // Catch TaskCanceledException specifically
            {
                // Check if the TaskCanceledException is due to HttpClient's timeout
                // The CancellationToken for HttpClient.Timeout is internal, so direct check is hard.
                // However, if tex.CancellationToken.IsCancellationRequested is true, it's a cancellation.
                // If it's an OperationCanceledException (base for TaskCanceledException) and the HttpClient's timeout has passed, it's likely a timeout.
                // For simplicity here, we'll assume TaskCanceledException in this context is often a timeout.
                string errorMessage = $"LLM request timed out or was canceled. Timeout is set to {_httpClientTimeout.TotalSeconds} seconds. Exception: {tex.Message}";
                Console.WriteLine($"Exception during LLM call: {tex.ToString()}");
                // Return a dummy response that includes the timeout information
                return $"LLM dummy response (request timed out or canceled after {_httpClientTimeout.TotalSeconds}s). Prompt: {prompt.Substring(0, Math.Min(prompt.Length, 100))}..."; // Log part of the prompt
            }
            catch (Exception ex) // General catch-all for other exceptions
            {
                Console.WriteLine($"Exception during LLM call: {ex.ToString()}");
                return $"LLM dummy response (due to exception: {ex.Message}). Prompt: {prompt.Substring(0, Math.Min(prompt.Length, 100))}..."; // Log part of the prompt
            }
        }

        public static LlmService Create()
        {
            return new LlmService();
        }

        public void ReloadConfigAndReinitialize()
        {
            Console.WriteLine("LlmService: Reloading configuration and re-initializing...");
            LoadLlmConfig();         // Reloads API key, base URL, and model name from App.config
            InitializeOpenAiService(); // Re-creates the OpenAIService instance with new settings
            Console.WriteLine("LlmService: Re-initialization complete.");
        }
    }
}