// 이렇게 코드를 작성하면...
var posts = context.Posts.ToList();

foreach(var post in posts)
{
    Console.WriteLine($"제목: {post.Title}");
    Console.WriteLine($"댓글 수: {post.Comments.Count}"); // 🚨 여기서 문제 발생!
}

// Include를 사용한 Eager Loading
var posts = context.Posts
    .Include(p => p.Comments)  // 댓글도 함께 가져와!
    .ToList();

foreach(var post in posts)
{
    Console.WriteLine($"제목: {post.Title}");
    Console.WriteLine($"댓글 수: {post.Comments.Count}"); // ✅ 추가 쿼리 없음!
}

// 다단계 Include - ThenInclude 사용
var posts = context.Posts
    .Include(p => p.Comments)
        .ThenInclude(c => c.Author)  // 댓글 작성자 정보도!
    .Include(p => p.Category)  // 카테고리 정보도!
    .ToList();

// 전체 엔티티 대신 필요한 필드만 선택
var postSummaries = context.Posts
    .Select(p => new 
    {
        p.Id,
        p.Title,
        CommentCount = p.Comments.Count,
        LatestComment = p.Comments
            .OrderByDescending(c => c.CreatedAt)
            .Select(c => c.Content)
            .FirstOrDefault()
    })
    .ToList();

// 이렇게 하면 문제가 생길 수 있어
var authors = context.Authors
    .Include(a => a.Books)      // 책 10권
    .Include(a => a.Articles)   // 기사 20개
    .ToList();

// 실제로는 10 × 20 = 200개의 행이 반환돼!
// 중복 데이터가 엄청나게 많아져

// Split Query 사용
var authors = context.Authors
    .Include(a => a.Books)
    .Include(a => a.Articles)
    .AsSplitQuery()  // 여러 개의 쿼리로 분리!
    .ToList();

// 이제 3개의 쿼리로 실행돼:
// 1. SELECT * FROM Authors
// 2. SELECT * FROM Books WHERE AuthorId IN (...)
// 3. SELECT * FROM Articles WHERE AuthorId IN (...)

// SQL 로깅 활성화 (개발 환경)
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .LogTo(Console.WriteLine, LogLevel.Information)
        .EnableSensitiveDataLogging();  // 파라미터 값도 보여줘
}

// 쿼리 실행 시간 측정
var stopwatch = Stopwatch.StartNew();

var posts = context.Posts
    .Include(p => p.Comments)
    .ToList();

stopwatch.Stop();
Console.WriteLine($"쿼리 실행 시간: {stopwatch.ElapsedMilliseconds}ms");

// ❌ 나쁜 예: 전체 데이터를 한 번에
var allPosts = context.Posts.ToList();  // 100만 개면? 💀

// ✅ 좋은 예: 페이징 처리
int pageSize = 100;
int pageNumber = 1;

var pagedPosts = context.Posts
    .OrderBy(p => p.Id)
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .AsNoTracking()
    .ToList();

// 더 나은 방법: Keyset Pagination
int lastId = 0;
while (true)
{
    var batch = context.Posts
        .Where(p => p.Id > lastId)
        .OrderBy(p => p.Id)
        .Take(100)
        .AsNoTracking()
        .ToList();
    
    if (!batch.Any()) break;
    
    // 배치 처리
    ProcessBatch(batch);
    
    lastId = batch.Last().Id;
}

// Lazy Loading 활성화
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .UseLazyLoadingProxies();  // 프록시 기반 Lazy Loading
}

// 엔티티 설정
public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    
    // virtual 키워드가 중요!
    public virtual ICollection<Comment> Comments { get; set; }
}

// 사용 시 자동으로 로딩됨
var post = context.Posts.First();
var count = post.Comments.Count;  // 여기서 자동으로 쿼리 실행!

// Fluent API로 인덱스 설정
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasIndex(p => p.CreatedAt)
        .HasDatabaseName("IX_Post_CreatedAt");
    
    // 복합 인덱스
    modelBuilder.Entity<Comment>()
        .HasIndex(c => new { c.PostId, c.CreatedAt })
        .HasDatabaseName("IX_Comment_PostId_CreatedAt");
    
    // 필터링된 인덱스 (SQL Server)
    modelBuilder.Entity<Post>()
        .HasIndex(p => p.Status)
        .HasFilter("[Status] = 'Published'")
        .HasDatabaseName("IX_Post_PublishedStatus");
}

// Data Annotation으로도 가능
public class Post
{
    public int Id { get; set; }
    
    [Index]
    public DateTime CreatedAt { get; set; }
}

// FromSqlRaw 사용
var posts = context.Posts
    .FromSqlRaw(@"
        SELECT p.* 
        FROM Posts p
        INNER JOIN Comments c ON p.Id = c.PostId
        WHERE c.CreatedAt > {0}
        GROUP BY p.Id, p.Title, p.Content
        HAVING COUNT(c.Id) > 5", 
        DateTime.Now.AddDays(-7))
    .Include(p => p.Author)  // LINQ와 조합 가능!
    .ToList();

// Stored Procedure 실행
var results = context.PostStatistics
    .FromSqlRaw("EXEC GetPostStatistics @StartDate, @EndDate",
        new SqlParameter("@StartDate", startDate),
        new SqlParameter("@EndDate", endDate))
    .ToList();

// 파라미터화된 쿼리 (SQL Injection 방지)
var searchTerm = "Entity Framework";
var posts = context.Posts
    .FromSqlInterpolated($@"
        SELECT * FROM Posts 
        WHERE CONTAINS(Title, {searchTerm})")
    .ToList();

// ASP.NET Core에서 DbContext 등록
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BlogContext>(options =>
    {
        options.UseSqlServer(connectionString)
            .EnableSensitiveDataLogging(isDevelopment)  // 개발 환경에서만
            .ConfigureWarnings(warnings =>
                warnings.Throw(RelationalEventId.QueryPossibleUnintendedUseOfEqualsWarning));
        
        // 쿼리 추적 기본값 설정
        options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
    });
}

// DbContext 풀링으로 성능 향상
services.AddDbContextPool<BlogContext>(options =>
    options.UseSqlServer(connectionString),
    poolSize: 128);  // 풀 크기 설정

// 사용
public class PostService
{
    private readonly BlogContext _context;
    
    public PostService(BlogContext context)
    {
        _context = context;
    }
    
    public async Task<List<Post>> GetRecentPostsAsync()
    {
        // DbContext는 요청당 하나씩 자동 관리됨
        return await _context.Posts
            .OrderByDescending(p => p.CreatedAt)
            .Take(10)
            .ToListAsync();
    }
}

// 1. 쿼리 실행 계획 확인
var query = context.Posts
    .Include(p => p.Comments)
    .Where(p => p.CreatedAt > DateTime.Now.AddDays(-7));

var sql = query.ToQueryString();  // EF Core 5.0+
Console.WriteLine(sql);

// 2. 실행 시간 측정 확장 메서드
public static class QueryExtensions
{
    public static async Task<T> WithTimingAsync<T>(
        this Task<T> task, 
        string queryName)
    {
        var sw = Stopwatch.StartNew();
        var result = await task;
        sw.Stop();
        
        Console.WriteLine($"{queryName}: {sw.ElapsedMilliseconds}ms");
        return result;
    }
}

// 사용
var posts = await context.Posts
    .Include(p => p.Comments)
    .ToListAsync()
    .WithTimingAsync("GetPosts");

// 3. 쿼리 태그로 SQL 추적
var posts = context.Posts
    .TagWith("GetRecentPosts - Dashboard")
    .Where(p => p.CreatedAt > DateTime.Now.AddDays(-7))
    .ToList();

// SQL에 주석으로 표시됨:
// -- GetRecentPosts - Dashboard
// SELECT * FROM Posts WHERE ...

// ❌ 최적화 전
public async Task<List<PostViewModel>> GetPostsAsync()
{
    var posts = await _context.Posts.ToListAsync();
    
    var viewModels = new List<PostViewModel>();
    foreach (var post in posts)
    {
        viewModels.Add(new PostViewModel
        {
            Id = post.Id,
            Title = post.Title,
            AuthorName = post.Author.Name,  // N+1!
            CommentCount = post.Comments.Count,  // N+1!
            CategoryName = post.Category.Name  // N+1!
        });
    }
    
    return viewModels;
}

// ✅ 최적화 후
public async Task<List<PostViewModel>> GetPostsOptimizedAsync(
    int page = 1, 
    int pageSize = 20)
{
    return await _context.Posts
        .AsNoTracking()  // 읽기 전용
        .OrderByDescending(p => p.CreatedAt)
        .Skip((page - 1) * pageSize)
        .Take(pageSize)
        .Select(p => new PostViewModel  // Projection
        {
            Id = p.Id,
            Title = p.Title,
            AuthorName = p.Author.Name,
            CommentCount = p.Comments.Count,
            CategoryName = p.Category.Name,
            CreatedAt = p.CreatedAt
        })
        .ToListAsync();
}

// 더 나은 버전: 캐싱 추가
public async Task<List<PostViewModel>> GetPostsCachedAsync(
    int page = 1, 
    int pageSize = 20)
{
    var cacheKey = $"posts_page_{page}_size_{pageSize}";
    
    if (!_cache.TryGetValue(cacheKey, out List<PostViewModel> posts))
    {
        posts = await _context.Posts
            .AsNoTracking()
            .OrderByDescending(p => p.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .Select(p => new PostViewModel
            {
                Id = p.Id,
                Title = p.Title,
                AuthorName = p.Author.Name,
                CommentCount = p.Comments.Count,
                CategoryName = p.Category.Name,
                CreatedAt = p.CreatedAt
            })
            .ToListAsync();
        
        _cache.Set(cacheKey, posts, TimeSpan.FromMinutes(5));
    }
    
    return posts;
}