/*
 C# code snippet: Conceptual framework for logging learning insights.
 This emphasizes an active approach to track and reflect on acquired knowledge.
*/

using System;
using System.Collections.Generic;

public class LearningTracker
{
    public class LearningEntry
    {
        public DateTime Date { get; set; }
        public string Topic { get; set; }
        public string Source { get; set; }
        public string KeyTakeaway { get; set; }
        public string ActionableStep { get; set; }

        public LearningEntry(string topic, string source, string takeaway, string step)
        {
            Date = DateTime.UtcNow;
            Topic = topic;
            Source = source;
            KeyTakeaway = takeaway;
            ActionableStep = step;
        }
    }

    private List<LearningEntry> entries;

    public LearningTracker()
    {
        entries = new List<LearningEntry>();
    }

    public void AddEntry(string topic, string source, string takeaway, string step)
    {
        entries.Add(new LearningEntry(topic, source, takeaway, step));
        Console.WriteLine($"Logged learning: {topic} from {source}");
    }

    public void DisplayRecentEntries(int count = 5)
    {
        Console.WriteLine("\n--- Recent Learning Entries ---");
        for (int i = Math.Max(0, entries.Count - count); i < entries.Count; i++)
        {
            var entry = entries[i];
            Console.WriteLine($"Date: {entry.Date.ToShortDateString()}");
            Console.WriteLine($"Topic: {entry.Topic}");
            Console.WriteLine($"Source: {entry.Source}");
            Console.WriteLine($"Takeaway: {entry.KeyTakeaway}");
            Console.WriteLine($"Action: {entry.ActionableStep}\n");
        }
        Console.WriteLine("-------------------------------");
    }

    /*
     // Example Usage:
     public static void Main(string[] args)
     {
         LearningTracker tracker = new LearningTracker();
         tracker.AddEntry("C# 12 Primary Constructors", "C# Blog XYZ", "Simplified class creation", "Refactor existing DTOs");
         tracker.AddEntry("Asynchronous Streams", ".NET Docs", "Process sequences of data asynchronously", "Implement for log processing");
         tracker.DisplayRecentEntries();
     }
    */
}

/*
 C# code snippet: Conceptual class for managing blog feed metadata.
 This allows for structured storage and retrieval of blog information.
*/

using System;
using System.Collections.Generic;

public class BlogFeedManager
{
    public class BlogSource
    {
        public string Name { get; set; }
        public string Url { get; set; }
        public string Category { get; set; } // e.g., "Performance", "Architecture", "Language Features"
        public string LastFetchDate { get; set; }
        public bool IsActive { get; set; }

        public BlogSource(string name, string url, string category, bool isActive = true)
        {
            Name = name;
            Url = url;
            Category = category;
            IsActive = isActive;
            LastFetchDate = "N/A"; // Placeholder, would be updated by a real feed processor
        }
    }

    private List<BlogSource> sources;

    public BlogFeedManager()
    {
        sources = new List<BlogSource>();
    }

    public void AddBlog(string name, string url, string category, bool isActive = true)
    {
        if (!sources.Exists(s => s.Url == url))
        {
            sources.Add(new BlogSource(name, url, category, isActive));
            Console.WriteLine($"Added blog source: {name}");
        }
        else
        {
            Console.WriteLine($"Blog source '{name}' already exists.");
        }
    }

    public List<BlogSource> GetActiveBlogs()
    {
        return sources.FindAll(s => s.IsActive);
    }

    public void UpdateLastFetchDate(string url, DateTime date)
    {
        var source = sources.Find(s => s.Url == url);
        if (source != null)
        {
            source.LastFetchDate = date.ToString("yyyy-MM-dd HH:mm:ss");
            Console.WriteLine($"Updated fetch date for {source.Name}");
        }
    }

    /*
     // Example Usage:
     public static void Main(string[] args)
     {
         BlogFeedManager manager = new BlogFeedManager();
         manager.AddBlog("Microsoft .NET Blog", "https://devblogs.microsoft.com/dotnet/", "General .NET");
         manager.AddBlog("Stephen Toub's Blog", "https://devblogs.microsoft.com/dotnet/author/steve-toub-msft/", "Performance");
         manager.AddBlog("Khalid Abuhakmeh", "https://khalidabuhakmeh.com/", "Web Development");

         Console.WriteLine("\nActive Blogs:");
         foreach (var blog in manager.GetActiveBlogs())
         {
             Console.WriteLine($"- {blog.Name} ({blog.Category}) - {blog.Url}");
         }
         manager.UpdateLastFetchDate("https://devblogs.microsoft.com/dotnet/", DateTime.Now);
     }
    */
}

/*
 C# code snippet: Conceptual structure for managing newsletter metadata.
 This allows tracking and organizing different newsletter subscriptions.
*/

using System;
using System.Collections.Generic;

public class NewsletterSubscriber
{
    public class NewsletterInfo
    {
        public string Name { get; set; }
        public string Editor { get; set; }
        public string Frequency { get; set; } // e.g., "Weekly", "Bi-weekly", "Monthly"
        public string PrimaryFocus { get; set; }
        public bool IsSubscribed { get; set; }

        public NewsletterInfo(string name, string editor, string frequency, string focus, bool subscribed = true)
        {
            Name = name;
            Editor = editor;
            Frequency = frequency;
            PrimaryFocus = focus;
            IsSubscribed = subscribed;
        }
    }

    private List<NewsletterInfo> subscriptions;

    public NewsletterSubscriber()
    {
        subscriptions = new List<NewsletterInfo>();
    }

    public void Subscribe(string name, string editor, string frequency, string focus)
    {
        if (!subscriptions.Exists(n => n.Name == name))
        {
            subscriptions.Add(new NewsletterInfo(name, editor, frequency, focus));
            Console.WriteLine($"Subscribed to newsletter: {name}");
        }
        else
        {
            Console.WriteLine($"Already subscribed to '{name}'.");
        }
    }

    public List<NewsletterInfo> GetActiveSubscriptions()
    {
        return subscriptions.FindAll(n => n.IsSubscribed);
    }

    public void Unsubscribe(string name)
    {
        var newsletter = subscriptions.Find(n => n.Name == name);
        if (newsletter != null)
        {
            newsletter.IsSubscribed = false;
            Console.WriteLine($"Unsubscribed from: {name}");
        }
        else
        {
            Console.WriteLine($"Newsletter '{name}' not found in subscriptions.");
        }
    }

    /*
     // Example Usage:
     public static void Main(string[] args)
     {
         NewsletterSubscriber manager = new NewsletterSubscriber();
         manager.Subscribe(".NET Bites", "Khalid Abuhakmeh", "Weekly", "ASP.NET Core");
         manager.Subscribe(".NET Fwd: News, Articles, and more", "Michael Shpilt", "Weekly", ".NET Ecosystem");
         manager.Subscribe("The Morning Dew", "Alvin Ashcraft", "Daily", "General Dev");

         Console.WriteLine("\nActive Newsletters:");
         foreach (var nl in manager.GetActiveSubscriptions())
         {
             Console.WriteLine($"- {nl.Name} by {nl.Editor} ({nl.Frequency}) - Focus: {nl.PrimaryFocus}");
         }
         manager.Unsubscribe("The Morning Dew");
     }
    */
}

/*
 C# code snippet: Simple console application for a "learning resource" tracker.
 This demonstrates storing and managing diverse learning materials.
*/

using System;
using System.Collections.Generic;

public class LearningResourceTracker
{
    public class ResourceEntry
    {
        public string Title { get; set; }
        public string Type { get; set; } // e.g., "Article", "Video", "Podcast", "Book"
        public string Url { get; set; }
        public string KeyConcepts { get; set; }
        public DateTime DateAdded { get; set; }
        public bool IsCompleted { get; set; }

        public ResourceEntry(string title, string type, string url, string keyConcepts)
        {
            Title = title;
            Type = type;
            Url = url;
            KeyConcepts = keyConcepts;
            DateAdded = DateTime.UtcNow;
            IsCompleted = false;
        }
    }

    private List<ResourceEntry> resources;

    public LearningResourceTracker()
    {
        resources = new List<ResourceEntry>();
    }

    public void AddResource(string title, string type, string url, string keyConcepts)
    {
        resources.Add(new ResourceEntry(title, type, url, keyConcepts));
        Console.WriteLine($"Added new {type} resource: {title}");
    }

    public List<ResourceEntry> GetPendingResources()
    {
        return resources.FindAll(r => !r.IsCompleted);
    }

    public void MarkAsCompleted(string title)
    {
        var resource = resources.Find(r => r.Title == title);
        if (resource != null)
        {
            resource.IsCompleted = true;
            Console.WriteLine($"Marked '{title}' as completed.");
        }
        else
        {
            Console.WriteLine($"Resource '{title}' not found.");
        }
    }

    /*
     // Example Usage:
     public static void Main(string[] args)
     {
         LearningResourceTracker tracker = new LearningResourceTracker();
         tracker.AddResource("Advanced LINQ Techniques", "Article", "https://example.com/linq", "Query optimization, deferred execution");
         tracker.AddResource("ASP.NET Core Minimal APIs Explained", "Video", "https://youtube.com/minimalapis", "Endpoint routing, dependency injection");
         tracker.AddResource("Clean Architecture in .NET", "Book", "https://example.com/cleanarch", "Layered design, inversion of control");

         Console.WriteLine("\nPending Resources:");
         foreach (var res in tracker.GetPendingResources())
         {
             Console.WriteLine($"- {res.Title} ({res.Type}) - Key Concepts: {res.KeyConcepts}");
         }
         tracker.MarkAsCompleted("Advanced LINQ Techniques");
     }
    */
}