Builder and Prototype

using System;
using System.Collections.Generic;
using System.Linq;

// Demonstrates: Builder for validated construction; Prototype for cloning.
// Why preferable to simpler alternatives:
// - Builder centralizes optional parameters and validation; better than many ctor overloads.
// - Prototype (typed DeepClone) gives explicit, predictable cloning semantics.
// Misuse warning:
// - Shallow clones (MemberwiseClone) will copy references to mutable collections and can silently
//   introduce shared-state bugs.

namespace BuilderPrototypeDemo
{
    // Strongly-typed clone interface to avoid the ambiguity of ICloneable
    public interface IPrototype<T>
    {
        T DeepClone();
    }

    public class Product : IPrototype<Product>
    {
        public string Name { get; }
        public decimal Price { get; }
        // Mutable nested state that requires careful cloning
        public List<string> Options { get; }

        public Product(string name, decimal price, List<string>? options = null)
        {
            Name = name;
            Price = price;
            Options = options ?? new List<string>();
        }

        // Shallow clone: demonstrates the pitfall (copies Options reference)
        public Product ShallowClone()
        {
            // MemberwiseClone is protected; accessible inside the type
            return (Product)this.MemberwiseClone();
        }

        // Explicit deep clone: copy nested mutable collections
        public Product DeepClone()
        {
            return new Product(Name, Price, new List<string>(Options));
        }

        public override string ToString()
        {
            return $"Product(Name={Name}, Price={Price}, Options=[{string.Join(", ", Options)}])";
        }
    }

    // Classic extension method wrapper (works on all supported C# versions)
    public static class ProductExtensions
    {
        public static Product DeepCloneExt(this Product p)
        {
            // This simply delegates to the explicit DeepClone implementation.
            return p.DeepClone();
        }
    }

    // Builder pattern with fluent API and validation
    public class ProductBuilder
    {
        private string? _name;
        private decimal? _price;
        private readonly List<string> _options = new();

        public ProductBuilder SetName(string name)
        {
            _name = name ?? throw new ArgumentNullException(nameof(name));
            return this;
        }

        public ProductBuilder SetPrice(decimal price)
        {
            if (price < 0) throw new ArgumentOutOfRangeException(nameof(price));
            _price = price;
            return this;
        }

        public ProductBuilder AddOption(string option)
        {
            if (string.IsNullOrWhiteSpace(option)) throw new ArgumentException("Option cannot be empty", nameof(option));
            _options.Add(option);
            return this;
        }

        // Build enforces invariants in one place
        public Product Build()
        {
            if (string.IsNullOrEmpty(_name)) throw new InvalidOperationException("Name is required");
            if (_price == null) throw new InvalidOperationException("Price is required");
            // Return a product with a defensive copy of options to prevent external mutation
            return new Product(_name, _price.Value, new List<string>(_options));
        }
    }

    class Program
    {
        static void Main()
        {
            // 1) Builder usage
            var phone = new ProductBuilder()
                .SetName("Phone")
                .SetPrice(699)
                .AddOption("Case")
                .AddOption("Charger")
                .Build();

            Console.WriteLine("Built product: " + phone);

            // 2) Prototype shallow vs deep clone demonstration
            var laptop = new Product("Laptop", 1299m, new List<string> { "Dock" });
            Console.WriteLine("Original product before cloning: " + laptop);

            // Shallow clone (pitfall): the Options list reference is shared
            var shallow = laptop.ShallowClone();
            shallow.Options.Add("Shared-Hack");
            Console.WriteLine("After shallow clone mutation, original is: " + laptop);
            // Shows that original was mutated because Options was shared.

            // Reset laptop to clean state for deep clone demonstration
            laptop = new Product("Laptop", 1299m, new List<string> { "Dock" });

            // Deep clone (correct): Options copied
            var deep = laptop.DeepClone();
            deep.Options.Add("Deep-Safe");
            Console.WriteLine("After deep clone mutation, original is: " + laptop);
            Console.WriteLine("Deep clone is: " + deep);

            // 3) Using extension convenience wrapper
            var extClone = laptop.DeepCloneExt();
            extClone.Options.Add("Ext-Clone");
            Console.WriteLine("Using extension DeepCloneExt, original remains: " + laptop);
            Console.WriteLine("Extension clone: " + extClone);

            // Summary lines to make output deterministic and easy to assert in tests
            Console.WriteLine("DEMO-END");
        }
    }
}