// ❌ Технічний код (не слідує UL)
ticket.Status = 3;
ticket.Save();

// ✅ Код, що відображає бізнес-мову
ticket.Escalate(reason);

private readonly CountryCode _country; // ✅ Зрозуміло: код країни
vs
private readonly string _countryCode;  // ❓ Код? Назва? Скорочення?

var heightMetric = Height.Metric(180);
var heightImperial = Height.Imperial(5, 11);

var string1 = heightMetric.ToString(); // "180cm"
var string2 = heightImperial.ToString(); // "5 feet 11 inches"
var string3 = heightMetric.ToImperial().ToString(); // "5 feet 11 inches"

var firstIsHigher = heightMetric > heightImperial; // false

var phone = PhoneNumber.Parse("+359877123503");

var country = phone.Country;     // "BG"
var phoneType = phone.PhoneType; // "MOBILE"
var isValid = PhoneNumber.IsValid("+972120266680"); // false

var red = Color.FromRGB(255, 0, 0);
var green = Color.Green; // Предвизначений колір

var yellow = red.MixWith(green);
var yellowString = yellow.ToString(); // "#FFFF00"

// ❌ Погана практика
ticket._assignedAgent.ActiveTickets += 1;
ticket._assignedAgent.Save();

// ✅ Правильний підхід
var agentId = ticket.AssignedAgent; // Просто ID
// Якщо потрібно модифікувати Agent — це окрема транзакція
var agent = _agentRepository.Load(agentId);
agent.IncrementActiveTickets();
_agentRepository.Save(agent);

// ✅ Order = Aggregate Root
public class Order
{
    private OrderId _id;
    private List<OrderLine> _lines; // Entities всередині
    private OrderStatus _status;
    private decimal _totalAmount;

    public void AddLine(ProductId product, int quantity, decimal price)
    {
        // Business rule: не можна додавати до shipped order
        if (_status == OrderStatus.Shipped)
        {
            throw new InvalidOperationException("Cannot modify shipped order");
        }

        // Business rule: максимум 50 позицій
        if (_lines.Count >= 50)
        {
            throw new InvalidOperationException("Max 50 lines");
        }

        _lines.Add(new OrderLine(product, quantity, price));
        RecalculateTotal(); // Автоматично оновлюємо total
    }

    private void RecalculateTotal()
    {
        _totalAmount = _lines.Sum(line => line.SubTotal);
    }
}

// OrderLine = Entity (НЕ aggregate!)
public class OrderLine
{
    private OrderLineId _id;
    private ProductId _product;
    private int _quantity;
    private decimal _unitPrice;

    public decimal SubTotal => _quantity * _unitPrice;

    // internal — може бути створений тільки з Order
    internal OrderLine(ProductId product, int quantity, decimal price)
    {
        _id = OrderLineId.New();
        _product = product;
        _quantity = quantity;
        _unitPrice = price;
    }
}

// Якщо коментарі прості й неодмінгі
public class BlogPost // Aggregate
{
    private PostId _id;
    private List<Comment> _comments; // Entities

    public void AddComment(UserId author, string text)
    {
        // Business rule: не більше 1000 коментарів
        if (_comments.Count >= 1000)
        {
            throw new InvalidOperationException("Post full");
        }

        _comments.Add(new Comment(author, text));
    }
}

public class Comment // Entity
{
    private CommentId _id;
    private UserId _author;
    private string _text;
    private DateTime _createdAt;
}

// Якщо коментарі складні (модерація, рейтинги, відповіді)
public class BlogPost // Aggregate
{
    private PostId _id;
    private List<CommentId> _commentIds; // Тільки ID!

    public void LinkComment(CommentId commentId)
    {
        _commentIds.Add(commentId);
    }
}

public class Comment // Окремий Aggregate!
{
    private CommentId _id;
    private PostId _postId; // Back reference по ID
    private UserId _author;
    private string _text;
    private ModerationStatus _status;
    private List<CommentId> _replies; // Може мати відповіді
    private int _upvotes;
    private int _downvotes;

    public void Approve() { ... } // Власна бізнес-логіка
    public void addReply(Comment reply) { ... }
}

// ✅ Student = Aggregate
public class Student
{
    private StudentId _id;
    private Name _name;
    private List<EnrollmentId> _enrollments; // Тільки ID!

    public StudentId Id => _id;
}

// ✅ Course = Aggregate
public class Course
{
    private CourseId _id;
    private CourseName _name;
    private int _capacity;
    private List<EnrollmentId> _enrollments;

    public CourseId Id => _id;
    public bool IsFull => _enrollments.Count >= _capacity;
}

// ✅ Enrollment = також Aggregate!
public class Enrollment
{
    private EnrollmentId _id;
    private StudentId _student; // Reference по ID
    private CourseId _course;   // Reference по ID
    private EnrollmentStatus _status;
    private Grade _grade;

    public void Complete(Grade grade)
    {
        if (_status != EnrollmentStatus.Active)
        {
            throw new InvalidOperationException("Enrollment not active");
        }

        _grade = grade;
        _status = EnrollmentStatus.Completed;
    }

    public void Withdraw()
    {
        if (_status == EnrollmentStatus.Completed)
        {
            throw new InvalidOperationException("Cannot withdraw completed course");
        }

        _status = EnrollmentStatus.Withdrawn;
    }
}

// ✅ Account = Aggregate
public class Account
{
    private AccountId _id;
    private decimal _balance;
    private List<Transaction> _transactions; // Entities всередині!

    public void Deposit(decimal amount)
    {
        if (amount <= 0)
        {
            throw new ArgumentException("Amount must be positive");
        }

        _balance += amount;
        _transactions.Add(new Transaction(TransactionType.Deposit, amount));
    }

    public void Withdraw(decimal amount)
    {
        if (amount > _balance)
        {
            throw new InvalidOperationException("Insufficient funds");
        }

        _balance -= amount;
        _transactions.Add(new Transaction(TransactionType.Withdrawal, amount));
    }
}

// Transaction = Entity (НЕ aggregate!)
public class Transaction
{
    private TransactionId _id;
    private TransactionType _type;
    private decimal _amount;
    private DateTime _timestamp;

    internal Transaction(TransactionType type, decimal amount)
    {
        _id = TransactionId.New();
        _type = type;
        _amount = amount;
        _timestamp = DateTime.UtcNow;
    }
}

// ✅ Project = Aggregate
public class Project
{
    private ProjectId _id;
    private List<SprintId> _sprints; // Посилання по ID
    private List<TaskId> _backlog;   // Посилання по ID
}

// ✅ Sprint = Aggregate
public class Sprint
{
    private SprintId _id;
    private ProjectId _project;
    private List<TaskId> _tasks; // Посилання по ID
    private DateTime _startDate;
    private DateTime _endDate;
    private SprintStatus _status;

    public void Start()
    {
        if (_tasks.Count == 0)
        {
            throw new InvalidOperationException("Cannot start empty sprint");
        }
        _status = SprintStatus.Active;
    }
}

// ✅ Task = Aggregate!
public class Task
{
    private TaskId _id;
    private SprintId _sprint; // Може бути null (backlog)
    private UserId _assignee;
    private TaskStatus _status;
    private List<SubTask> _subTasks; // Entities всередині
    private List<Comment> _comments; // Entities всередині

    public void Start()
    {
        if (_status != TaskStatus.ToDo)
        {
            throw new InvalidOperationException("Can only start ToDo tasks");
        }
        _status = TaskStatus.InProgress;
    }

    public void AddSubTask(string description)
    {
        _subTasks.Add(new SubTask(description));
    }
}

// SubTask = Entity (всередині Task)
public class SubTask
{
    private SubTaskId _id;
    private string _description;
    private bool _completed;
}