using Cosmos.Common.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

var cs = builder.Configuration.GetConnectionString("ApplicationDbContextConnection")
         ?? builder.Configuration.GetConnectionString("DefaultConnection")!;

// Choose one based on your connection string/provider
if (cs.Contains("AccountEndpoint="))
{
    // Cosmos DB
    builder.Services.AddDbContext<ApplicationDbContext>(o => o.UseCosmos(cs, databaseName: "SkyCms"));
}
else if (cs.Contains("Server=") || cs.Contains("Data Source="))
{
    // SQL Server
    builder.Services.AddDbContext<ApplicationDbContext>(o => o.UseSqlServer(cs));
}
else if (cs.Contains("server=") || cs.Contains("Server="))
{
    // MySQL
    builder.Services.AddDbContext<ApplicationDbContext>(o => o.UseMySQL(cs));
}

using Cosmos.Common.Data;
using Microsoft.EntityFrameworkCore;

// Register ApplicationDbContext with your chosen provider (see example above)
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString)); // Or UseCosmos / UseMySQL

// Register other common services
builder.Services.AddScoped<ArticleLogic>();
builder.Services.AddScoped<ContactManagementService>();

using Cosmos.Common;
using Cosmos.Common.Data;
using Cosmos.Common.Data.Logic;

public class HomeController : HomeControllerBase
{
    public HomeController(
        ArticleLogic articleLogic,
        ApplicationDbContext dbContext,
        StorageContext storageContext,
        ILogger<HomeController> logger,
        IEmailSender emailSender)
        : base(articleLogic, dbContext, storageContext, logger, emailSender)
    {
    }

    public async Task<IActionResult> Index()
    {
        // Use inherited functionality from HomeControllerBase
        var toc = await GetTOC("/", false, 0, 10);
        return View(toc);
    }
}

using Cosmos.Common;
using Cosmos.Common.Data;

public class FileController : PubControllerBase
{
    public FileController(
        ApplicationDbContext dbContext,
        StorageContext storageContext,
        bool requiresAuthentication = false)
        : base(dbContext, storageContext, requiresAuthentication)
    {
    }

    // Inherits secure file serving functionality
}

public class ArticleService
{
    private readonly ApplicationDbContext _context;

    public ArticleService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Article> CreateArticleAsync(string title, string content)
    {
        var article = new Article
        {
            Title = title,
            Content = content,
            Published = DateTimeOffset.UtcNow,
            Updated = DateTimeOffset.UtcNow
        };

        _context.Articles.Add(article);
        await _context.SaveChangesAsync();
        return article;
    }

    public async Task<List<PublishedPage>> GetPublishedPagesAsync()
    {
        return await _context.Pages
            .Where(p => p.Published.HasValue)
            .OrderByDescending(p => p.Published)
            .ToListAsync();
    }
}

public class AuthService
{
    private readonly ApplicationDbContext _context;

    public AuthService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<bool> CanUserAccessArticle(ClaimsPrincipal user, int articleNumber)
    {
        return await CosmosUtilities.AuthUser(_context, user, articleNumber);
    }

    public async Task<List<TableOfContentsItem>> GetUserArticles(ClaimsPrincipal user)
    {
        return await CosmosUtilities.GetArticlesForUser(_context, user);
    }
}

public class ContactController : Controller
{
    private readonly ContactManagementService _contactService;

    public ContactController(ContactManagementService contactService)
    {
        _contactService = contactService;
    }

    [HttpPost]
    public async Task<IActionResult> SubmitContact(ContactViewModel model)
    {
        if (ModelState.IsValid)
        {
            var result = await _contactService.AddContactAsync(model);
            return Json(result);
        }
        return BadRequest(ModelState);
    }
}

public class FileService
{
    private readonly StorageContext _storageContext;

    public FileService(StorageContext storageContext)
    {
        _storageContext = storageContext;
    }

    public async Task<List<FileManagerEntry>> GetArticleFiles(int articleNumber, string path = "")
    {
        return await CosmosUtilities.GetArticleFolderContents(_storageContext, articleNumber, path);
    }
}

// Cosmos DB detection
if (connectionString.Contains("AccountEndpoint"))
{
    // Configure for Cosmos DB
}
// SQL Server detection
else if (connectionString.Contains("Server=") || connectionString.Contains("Data Source="))
{
    // Configure for SQL Server
}
// MySQL detection
else if (connectionString.Contains("server="))
{
    // Configure for MySQL
}

using Cosmos.Cms.Common.Services.Configurations;
using SendGrid;
using SendGrid.Helpers.Mail;

public class EmailService
{
    private readonly SendGridConfig _config;
    
    public EmailService(IOptions<SendGridConfig> config)
    {
        _config = config.Value;
    }
    
    public async Task SendEmailAsync(string toEmail, string subject, string htmlContent)
    {
        var client = new SendGridClient(_config.ApiKey);
        var from = new EmailAddress(_config.SenderEmail, _config.SenderName);
        var to = new EmailAddress(toEmail);
        var msg = MailHelper.CreateSingleEmail(from, to, subject, null, htmlContent);
        
        var response = await client.SendEmailAsync(msg);
    }
}

using Cosmos.Common.Services.Configurations;
using MailChimp.Net;
using MailChimp.Net.Interfaces;

public class NewsletterService
{
    private readonly MailChimpConfig _config;
    private readonly IMailChimpManager _mailChimpManager;
    
    public NewsletterService(IOptions<MailChimpConfig> config)
    {
        _config = config.Value;
        _mailChimpManager = new MailChimpManager(_config.ApiKey);
    }
    
    public async Task SubscribeToNewsletterAsync(string email, string firstName, string lastName)
    {
        var member = new Member
        {
            EmailAddress = email,
            StatusIfNew = Status.Subscribed,
            MergeFields = new Dictionary<string, object>
            {
                { "FNAME", firstName },
                { "LNAME", lastName }
            }
        };
        
        await _mailChimpManager.Members.AddOrUpdateAsync(
            _config.ListId,
            member);
    }
}

using Cosmos.Cms.Common.Services.Configurations;

public class ProxyMiddleware
{
    private readonly ProxyConfig _config;
    private readonly HttpClient _httpClient;
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (!_config.EnableProxy || _config.BypassPaths.Contains(context.Request.Path))
        {
            await _next(context);
            return;
        }
        
        var targetUri = new Uri(_config.ProxyUrl + context.Request.Path + context.Request.QueryString);
        var proxyRequest = new HttpRequestMessage(new HttpMethod(context.Request.Method), targetUri);
        
        var response = await _httpClient.SendAsync(proxyRequest);
        context.Response.StatusCode = (int)response.StatusCode;
        await response.Content.CopyToAsync(context.Response.Body);
    }
}

public class PublisherService
{
    private readonly string _editorUrl;
    
    public PublisherService(IConfiguration configuration)
    {
        _editorUrl = configuration["EditorUrl"];
    }
    
    public async Task<string> FetchContentFromEditorAsync(string contentId)
    {
        using var client = new HttpClient();
        var response = await client.GetAsync($"{_editorUrl}/api/content/{contentId}");
        return await response.Content.ReadAsStringAsync();
    }
}

using Cosmos.Common.Services;
using Microsoft.AspNetCore.Identity;

public class AccountService
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly OneTimeTokenProvider<IdentityUser> _tokenProvider;
    
    public async Task<string> GeneratePasswordResetTokenAsync(IdentityUser user)
    {
        // Token valid for 1 hour by default
        var token = await _tokenProvider.GenerateAsync(
            "PasswordReset",
            _userManager,
            user);
        
        return token;
    }
    
    public async Task<bool> ValidatePasswordResetTokenAsync(
        IdentityUser user,
        string token)
    {
        var isValid = await _tokenProvider.ValidateAsync(
            "PasswordReset",
            token,
            _userManager,
            user);
        
        return isValid;
    }
}

using Cosmos.Common.Services;

public class SecureDataService
{
    public string DecryptClientData(string encryptedData, string passphrase)
    {
        // Decrypt data sent from JavaScript CryptoJS.AES.encrypt()
        var decrypted = CryptoJsDecryption.Decrypt(encryptedData, passphrase);
        return decrypted;
    }
}

using Cosmos.Common.Models;

public class EventModel
{
    [DateTimeUtcKind(ErrorMessage = "Event time must be in UTC")]
    public DateTime EventTime { get; set; }
}

using Cosmos.Common.Models;

public class LoginViewModel
{
    [RedirectUrl(ErrorMessage = "Invalid redirect URL")]
    public string ReturnUrl { get; set; }
}

using Cosmos.Cms.Common.Services;

// In Program.cs
builder.Services.AddMemoryCache();
builder.Services.AddSingleton<CosmosMemoryCache>();

public class ContentService
{
    private readonly CosmosMemoryCache _cache;
    
    public async Task<Article> GetArticleAsync(int id)
    {
        var cacheKey = $"article_{id}";
        
        if (_cache.TryGetValue(cacheKey, out Article cached))
        {
            return cached;
        }
        
        var article = await _dbContext.Articles.FindAsync(id);
        
        // Cache for 10 minutes
        _cache.Set(cacheKey, article, TimeSpan.FromMinutes(10));
        
        return article;
    }
}

public async Task UpdateArticleAsync(Article article)
{
    await _dbContext.SaveChangesAsync();
    
    // Invalidate related caches
    _cache.Remove($"article_{article.Id}");
    _cache.Remove("articles_list");
    _cache.Remove("menu_main");
}

// Configure cache size limits
builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 1024; // 1024 items max
    options.CompactionPercentage = 0.25; // Remove 25% when limit reached
});

using Cosmos.Common.Models;
using Microsoft.PowerBI.Api;
using Microsoft.PowerBI.Api.Models;

public class PowerBiService
{
    public async Task<string> GetEmbedTokenAsync(string reportId)
    {
        var tokenRequest = new PowerBiTokenRequest
        {
            ReportId = reportId,
            AccessLevel = "View",
            AllowEdit = false
        };
        
        // Authenticate with Azure AD
        var authToken = await GetAzureAdTokenAsync();
        
        // Get Power BI embed token
        using var client = new PowerBIClient(new Uri("https://api.powerbi.com"), 
            new TokenCredentials(authToken));
        
        var embedToken = await client.Reports.GenerateTokenAsync(
            new Guid(tokenRequest.ReportId),
            new GenerateTokenRequest(accessLevel: "View"));
        
        return embedToken.Token;
    }
}