using EntityFrameworkCore.Data;
using EntityFrameworkCore.Domain;
using Microsoft.EntityFrameworkCore;

using var context = new DeadBallZoneLeagueDbContext();

// var teamOne = await context.Teams.FirstAsync(t => t.TeamId == 1);
// var teamTwo = await context.Teams.FirstAsync(t => t.TeamId == 2);
// var teamThree = await context.Teams.SingleAsync(t => t.TeamId == 3);
// var teamFour = await context.Teams.SingleOrDefaultAsync(t => t.TeamId == 3);

// There is no entry for coaches yet, this function will provide a null to coach.
// Rather than raise: "System.InvalidOperationException: Sequence contains no elements."
// var firstCoach = await context.Coaches.FirstOrDefaultAsync();

async Task ExecuteDelete(string name)
{
  // var coaches = await context.Coaches.Where(c => c.Name == name).ToListAsync();
  // context.RemoveRange(coaches);
  // await context.SaveChangesAsync();

  // Simplified:
  await context.Coaches.Where(c => c.Name == name).ExecuteDeleteAsync();
}

async Task ExecuteUpdate(int id)
{
  await context.Coaches
  .Where(c => c.Id == id)
  .ExecuteUpdateAsync(set => set.SetProperty(c => c.CreatedDate, DateTime.UtcNow));
}

async Task DeleteCoach(int id)
{
  var coach = await context.Coaches.FindAsync(id);
  if (coach != null)
  {
    context.Remove(coach);
    // context.Entry(coach).State = EntityState.Deleted;
    await context.SaveChangesAsync();
  }
}

async Task UpdateCoach()
{
  var coach = await context.Coaches.FindAsync(1);
  coach.CreatedDate = DateTime.UtcNow;
  await context.SaveChangesAsync();
}

async Task UpdateCoachNoTracking()
{
  var coach = await context.Coaches
    .AsNoTracking()
    .FirstOrDefaultAsync(c => c.Id == 1);
    // .FindAsync(1); // cannot be used when using no-tracking.
  coach.CreatedDate = DateTime.UtcNow;
  Console.WriteLine(context.ChangeTracker.DebugView.LongView);
  context.Update(coach); // Set Entity state to be updated.
  // Note that also other fields are considered "updated/modified", such as the CreatedDate.
  // You can also use:
  // context.Entry(coach).State = EntityState.Modified;
  Console.WriteLine(context.ChangeTracker.DebugView.LongView);
  await context.SaveChangesAsync();
}

async Task InsertCoach(string name)
{
  var coach = new Coach { Name = name, CreatedDate = DateTime.UtcNow };
  await context.Coaches.AddAsync(coach);
  Console.WriteLine(context.ChangeTracker.DebugView.LongView);
  await context.SaveChangesAsync();

  // If you have a list, you can use a batch insert, instead of a loop:
  // await context.Coaches.AddRangeAsync(coaches);
}

async Task ListVSIQueryableCall()
{
  Console.WriteLine("Enter '1' for team with Id 1 or enter '2' for teams that contain 'Neo'");
  var option = Convert.ToInt32(Console.ReadLine());
  List<Team> teamsAsList = new List<Team>();
  // After executing ToList, the records are stored in memory.
  // Operations after that, are also done in memory.

  teamsAsList = await context.Teams.ToListAsync();
  if (option == 1)
  {
    teamsAsList = teamsAsList.Where(t => t.TeamId == 1).ToList();
  }
  else if (option == 2)
  {
     teamsAsList = teamsAsList.Where(t => t.Name.Contains("Neo")).ToList();
  }
  foreach (var team in teamsAsList)
  {
    Console.WriteLine(team.Name);
  }

  // Records stay as IQueryable until the ToList function is called, then the final query is performed.
  var teamsAsQueryable = context.Teams.AsQueryable();
  if (option == 1)
  {
    teamsAsQueryable = teamsAsQueryable.Where(t => t.TeamId == 1);
  }
  else if (option == 2)
  {
    teamsAsQueryable = teamsAsQueryable.Where(t => t.Name.Contains("Neo"));
  }

  // the actual query:
  teamsAsList = await teamsAsQueryable.ToListAsync();

  foreach (var team in teamsAsList)
  {
    Console.WriteLine(team.Name);
  }
}

async Task TrackedQuery()
{
  // EF Core tracks objects that are returned by queries.
  // This is less useful in disconnected applictations like APIs and Web applications.
  var teams = await context.Teams
    .AsNoTracking()
    .ToListAsync();

  foreach (var team in teams)
  {
    Console.WriteLine(team.Name);
  }
}

async Task SkipAndTakeTeams()
{
  var recordCount = 3;
  var page = 0;
  var next = true;
  while (next)
  {
    var teams = await context.Teams.Skip(page * recordCount).Take(recordCount).ToListAsync();
    foreach (var team in teams)
    {
      Console.WriteLine(team.Name);
    }
    Console.WriteLine("Enter 'true' for next set of records, or 'false to quit.'");
    next = Convert.ToBoolean(Console.ReadLine());

    if (!next) break;
    page += 1;
  }
}

async Task OrderedTeams()
{
  var orderedTeam = await context.Teams
    .OrderByDescending(t => t.Name)
    .ToListAsync();
  foreach (var team in orderedTeam)
  {
    Console.WriteLine(team.Name);
  }
}

async Task GroupedTeams()
{
  var groupedTeams = context.Teams
  .GroupBy(t => t.CreatedDate.Date);

  foreach (var groupedTeam in groupedTeams)
  {
    Console.WriteLine(groupedTeam.Key);
    Console.WriteLine(groupedTeam.Sum(t => t.TeamId));
    foreach (var team in groupedTeam)
    {
      Console.WriteLine(team.Name);
    }
  }
}

async Task CountFunctionsTeams(int id)
{
  var numberOfTeams = await context.Teams.CountAsync(t => t.TeamId > id);
  Console.WriteLine($"Number of teams with ID > {id}: {numberOfTeams}");

  var maxTeams = await context.Teams.MaxAsync(t => t.TeamId);
  Console.WriteLine($"Max teams: {maxTeams}");

  var minTeams = await context.Teams.MinAsync(t => t.TeamId);
  Console.WriteLine($"Min teams: {minTeams}");

  var averageTeams = await context.Teams.AverageAsync(t => t.TeamId);
  Console.WriteLine($"Average teams: {averageTeams}");

  var sumTeams = await context.Teams.SumAsync(t => t.TeamId);
  Console.WriteLine($"Sum team IDs: {sumTeams}");
}

async Task GetAllTeamsQuerySyntax(string searchTerm)
{
  var teams = await (
    from team in context.Teams
    where EF.Functions.Like(team.Name, $"%{searchTerm}%")
    select team)
    .ToListAsync();
  foreach (var team in teams)
  {
    Console.WriteLine(team.Name);
  }
}

async Task PrintTeams()
{
  var teams = await context.Teams.ToListAsync();

  foreach (var team in teams)
  {
    Console.WriteLine(team.Name);
  }
}

async Task PrintFilteredTeams()
{
  Console.WriteLine("Enter search term: ");
  var searchTerm = Console.ReadLine();

  // var filteredTeams = await context.Teams.Where(t => t.Name.Contains(searchTerm)).ToListAsync();
  var filteredTeams = await context.Teams.Where(t => EF.Functions.Like(t.Name, $"%{searchTerm}%")).ToListAsync();
  foreach (var team in filteredTeams)
  {
    Console.WriteLine(team.Name);
  }
}

async Task PrintTeamById(int id)
{
  // Selection based on finding the Primary Key.
  var teamBasedOnId = await context.Teams.FindAsync(id);
  if (teamBasedOnId != null)
  {
    Console.WriteLine(teamBasedOnId.Name);
  }
}

async Task SelectQuery()
{
  var items = await context.Teams
    .Select(t => new { t.Name, t.CreatedDate })
    .ToListAsync();
  foreach (var item in items)
  {
    Console.WriteLine($"{item.Name} - {item.CreatedDate}");
  }
}

async Task SelectQueryDTO()
{
  var items = await context.Teams
    .Select(t => new TeamInfoDTO { Name = t.Name, Created = t.CreatedDate })
    .ToListAsync();
  foreach (var item in items)
  {
    Console.WriteLine($"{item.Name} - {item.Created}");
  }
}

class TeamInfoDTO
{
  public DateTime Created { get; set; }
  public string Name { get; set; }
}