using ClearTools.Extensions;
using Clear.Tools;

// String extensions
string text = "Hello 123 World!";
int number = text.ToInt32(); // Extracts numbers: 123
string cleaned = StringUtility.StripSymbols(text); // Removes symbols, preserves spaces: "Hello 123 World"

// Image processing
var scaledImage = ImageUtility.ScaleImage(originalImage, 800, 600);

// Cryptography
string salt = Crypto.CreateSalt();
string hash = Crypto.EncodeSHA256("password", salt);

// OTP generation
var otpResult = OtpUtility.GenerateCode("user@example.com", 12345, TimeSpan.FromMinutes(5));

using ClearTools.Configuration.BuiltIn;
using ClearTools.Extensions;

// Parse SQL Server connection string
var sqlConfig = new SqlServerConnectionString(
    "Server=localhost;Database=MyDb;User Id=sa;Password=mypass");

Console.WriteLine(sqlConfig.Server);   // "localhost"
Console.WriteLine(sqlConfig.Database); // "MyDb"

// Register with DI
services.AddConnectionString<SqlServerConnectionString>(
    configuration, "ConnectionStrings:MyDatabase");

// Inject into services
public class MyService
{
    public MyService(SqlServerConnectionString config)
    {
        _connectionString = config.ToString();
    }
}

public class MyServiceConfig : ConnectionStringBase
{
    [ConnectionStringKey("ApiUrl")]
    [Required]
    public string? ApiUrl { get; set; }
    
    [ConnectionStringKey("ApiKey")]
    [Required]
    public string? ApiKey { get; set; }
    
    [ConnectionStringKey("Timeout")]
    public int? Timeout { get; set; }
    
    public MyServiceConfig(string connectionString) 
        : base(connectionString) { }
}

// Store in Key Vault as single string
// "ApiUrl=https://api.example.com;ApiKey=secret123;Timeout=30"

// Use with DI
services.AddConnectionString<MyServiceConfig>(keyVaultSecret);

// URL and SEO-friendly string generation
string urlKey = StringUtility.GenerateUrlKey("My Blog Post Title!"); // "my-blog-post-title"

// HTML and symbol stripping
string cleanText = StringUtility.StripHTML("<p>Hello <b>World</b></p>"); // "Hello World"
string alphanumeric = StringUtility.StripSymbols("Hello @World! 123"); // "Hello World 123"

// Date-based unique identifiers
string dateCode = StringUtility.GetDateCode(); // File time-based code
string updateId = StringUtility.AddUpDate(); // Timestamp-based ID

// Tag generation
string tags = StringUtility.GenerateTags("tag1", "tag2", "tag3"); // "tag1,tag2,tag3"

// Image scaling with aspect ratio preservation
Image scaledImage = ImageUtility.ScaleImage(sourceImage, 800, 600, ImageSizePreference.Width);

// Image cropping and resizing
Image croppedImage = ImageUtility.CropImage(sourceBitmap, 300, 300);
Bitmap resizedImage = ImageUtility.ResizeImage(sourceImage, 400, 300);

// Format conversion
byte[] imageBytes = ImageUtility.ConvertBitmapToBytes(bitmap, ImageFormat.Jpeg);
string base64Image = ImageUtility.ConvertImageToBase64(image, ImageFormat.Png);

// High-quality JPEG saving
ImageUtility.SaveJpegToFile("output.jpg", image, quality: 85);

string key = "MySecretEncryptionKeyThatIsLongEnough123"; // 32+ chars required
string encrypted = Encryption.Encrypt("sensitive data", key);
string decrypted = Encryption.Decrypt(encrypted, key);

// Hashing algorithms
string salt = Crypto.CreateSalt(128);
string sha256Hash = Crypto.EncodeSHA256("password", salt);
string sha512Hash = Crypto.EncodeSHA512("password", salt);
string sha1Hash = Crypto.EncodeSHA1("password");

// Base64 encoding/decoding
string encoded = Crypto.EncodeBase64("text to encode");
string decoded = Crypto.DecodeBase64(encoded);

// Generate OTP with custom expiry
var otpResult = OtpUtility.GenerateCode("user@example.com", 12345, TimeSpan.FromMinutes(5));
Console.WriteLine($"Code: {otpResult.Code}, Expires: {otpResult.ExpiryTime}");

// Validate OTP
bool isValid = OtpUtility.ValidateCode("user@example.com", 12345, "123456", otpResult.ExpiryTime);

// Convert from any base to decimal
long decimal = BaseConverter.ConvertToDecimal("1010", 2); // Binary to decimal: 10
long hexDecimal = BaseConverter.ConvertToDecimal("FF", 16); // Hex to decimal: 255

// Convert decimal to any base
string binary = BaseConverter.ConvertFromDecimal(10, 2); // "1010"
string hex = BaseConverter.ConvertFromDecimal(255, 16); // "FF"

// Convert to alphabetic representation
string alpha = BaseConverter.ConvertToAlpha(26); // "BA"

// Parse EditorJS JSON to HTML
string html = EditorJS.Parse(editorJsJsonString);

// Supports: headers, paragraphs, lists, images, embeds (YouTube, Vimeo)

// Value toggling
string toggled = "active".Toggle("inactive"); // "inactive"

// Case-insensitive operations  
bool contains = "Hello World".Search("WORLD"); // true
bool equals = "Hello".EqualsNoCase("HELLO"); // true

// Number and symbol extraction
string numbers = "abc123def456".ExtractNumbers(); // "123456"
string clean = "Hello;World*".StripSymbols(); // "HelloWorld" (removes specific symbols)

// Type conversions
int number = "abc123".ToInt32(); // 123
decimal price = "Price: $29.99".ToDecimal(); // 29.99

// CSV processing
List<string> items = "apple,banana,cherry".ToListFromCsv();
HashSet<string> uniqueItems = "apple,banana,apple".ToHashSetFromCsv();

DateTime now = DateTime.Now;
string dateStr = now.ToDateString(); // "15/Aug/2025"
string dateTimeStr = now.ToDateTimeString(); // "15/Aug/2025 14:30:15"

using System.Text;
using ClearTools.Extensions;

var sb = new StringBuilder();

// Conditionally append content based on boolean conditions
sb.AppendIfTrue(isActive, "Active")
  .AppendIfTrue(hasWarnings, " (warnings)")
  .AppendLineIfTrue(isComplete, "Process complete");

// Example: Build dynamic messages
bool isAdmin = true;
bool hasErrors = false;
string message = new StringBuilder()
    .Append("User logged in")
    .AppendIfTrue(isAdmin, " with admin privileges")
    .AppendIfTrue(hasErrors, " - errors detected")
    .ToString();
// Result: "User logged in with admin privileges"

// Example: Conditional HTML generation
var html = new StringBuilder()
    .Append("<div class='user'")
    .AppendIfTrue(isPremium, " premium")
    .AppendIfTrue(isVerified, " verified")
    .AppendLine(">")
    .AppendLineIfTrue(showDetails, "<p>User details...</p>")
    .Append("</div>");

// Define settings class with regular config and feature flags
public class AppSettings
{
    public string DatabaseConnectionString { get; set; }
    
    [AppConfigurationKey("MyApp:ApiKey")]
    public string ApiKey { get; set; }
    
    public int MaxRetries { get; set; }
    
    // Feature flags (bool/bool? only)
    [FeatureFlag("enable-new-ui")]
    public bool NewUiEnabled { get; set; }
    
    [FeatureFlag("beta-features")]
    public bool? BetaFeaturesEnabled { get; set; }
}

// Web Applications - Using Managed Identity (recommended for Azure)
var builder = WebApplication.CreateBuilder(args);
builder.AddAppConfigurationForWebApplication<AppSettings>(
    appConfigEndpoint: new Uri("https://myapp.azconfig.io/"),
    out AppSettings settings,
    label: "Production",           // Environment-specific config
    keyFilter: "MyApp:*",          // Filter keys by prefix
    credential: new DefaultAzureCredential()
);

// Web Applications - Using Connection String (flexible)
builder.AddAppConfigurationForWebApplication<AppSettings>(
    connectionString: Environment.GetEnvironmentVariable("AppConfigConnectionString"),
    out AppSettings settings,
    label: "Staging"
);

// Azure Functions - Direct client access with environment fallback
hostBuilder.AddAppConfigurationForAzureFunctions<AppSettings>(
    appConfigEndpoint: new Uri("https://myapp.azconfig.io/"),
    out AppSettings functionSettings,
    skipDevelopment: true          // Uses environment variables in dev
);

// Optional: Configuration refresh with sentinel keys
var refreshOptions = new AppConfigurationRefreshOptions
{
    EnableRefresh = true,
    RefreshInterval = TimeSpan.FromMinutes(5),      // Minimum 30s recommended
    SentinelKeys = new[] { "AppSettings:Version" }, // Trigger refresh
    OnRefreshError = ex => logger.LogWarning(ex, "Config refresh failed")
};

builder.AddAppConfigurationForWebApplication<AppSettings>(
    appConfigEndpoint: new Uri("https://myapp.azconfig.io/"),
    out AppSettings settings,
    refreshOptions: refreshOptions
);

// Define your settings class
public class AppSettings
{
    public string DatabaseConnectionString { get; set; }
    
    [KeyVaultKey("api-key")]
    public string ApiKey { get; set; }
}

// For ASP.NET Web Applications
var builder = WebApplication.CreateBuilder(args);
builder.AddKeyVaultForWebApplication<AppSettings>(
    keyVaultUri: "https://your-keyvault.vault.azure.net/",
    out AppSettings settings
);

// For Azure Functions
hostBuilder.AddKeyVaultForAzureFunctions<AppSettings>(
    keyVaultUri: "https://your-keyvault.vault.azure.net/",
    out AppSettings functionSettings
);

string connectionString = "DefaultEndpointsProtocol=https;AccountName=...";

// Upload operations
AzureStorageManager.UploadToAzure(connectionString, "container", stream, "application/pdf", "file.pdf", "folder");

// Download operations  
AzureStorageManager.DownloadFromAzure(connectionString, "container", fileInfo, "folder");

// Check folder existence
bool exists = AzureStorageManager.AzureFolderExists(connectionString, "container", "folder");

// Register all services implementing IService
services.AddScopedServicesByInterface<IService>();
services.AddSingletonServicesByInterface<IRepository>();
services.AddTransientServicesByInterface<IValidator>();

// Initialize
var apiClient = new ApiClient(httpClient);

// GET with various options
var user = await apiClient.GetAsync<User>("https://api.example.com/users/1");
var userWithAuth = await apiClient.GetAsync<User>("https://api.example.com/users/1", bearerToken);

// POST operations
var response = await apiClient.PostAsync("https://api.example.com/users", newUser);
var createdUser = await apiClient.PostAsync<User, User>("https://api.example.com/users", newUser);

// reCAPTCHA validation
var captchaResult = await apiClient.ValidateGoogleCaptcharAsync(secretKey, response, remoteIp);

// Basic setup
services.AddRequestValidation("your_secret_api_key", skipForDevelopment: true);
app.UseRequestValidation();

// With excluded paths (e.g., health checks, public endpoints)
services.AddRequestValidation(
    "your_secret_api_key", 
    skipForDevelopment: true,
    skipRootEndPoint: true,
    excludedPaths: new[] { "/health", "/api/public", "/webhooks" }
);
app.UseRequestValidation();

// Using RequestValidationOption for more control
var options = new RequestValidationOption(
    validationKey: "your_secret_api_key",
    skipForDevelopment: true,
    skipForRootEndPoint: true,
    excludedPaths: new[] { "/health", "/metrics", "/api/public" }
);
services.AddSingleton(new RequestValidationMiddleware(options));
app.UseRequestValidation();

// Client usage - include key in headers
client.DefaultRequestHeaders.Add("key", "your_secret_api_key");

// Define your SmartEnum
public class OrderStatus : SmartEnum<OrderStatus>
{
    public static readonly OrderStatus Pending = new OrderStatus("Pending", 1);
    public static readonly OrderStatus Processing = new OrderStatus("Processing", 2);
    public static readonly OrderStatus Shipped = new OrderStatus("Shipped", 3);
    public static readonly OrderStatus Delivered = new OrderStatus("Delivered", 4);
    
    private OrderStatus(string name, int value) : base(name, value) { }
}

// Usage examples
var status = OrderStatus.Parse(2); // Get by value: Processing
var statusByName = OrderStatus.Parse("Shipped"); // Get by name: Shipped

// List all values
foreach (var status in OrderStatus.List())
{
    Console.WriteLine($"{status.Name}: {status.Value}");
}

// Type-safe comparisons
OrderStatus current = OrderStatus.Processing;
if (current.Equals(OrderStatus.Processing))
{
    Console.WriteLine("Order is being processed");
}

using Clear;

// Create and populate in one fluent chain
var config = new FluentDictionary<string, string>()
    .Add("host", "localhost")
    .Add("port", "5432")
    .Add("database", "mydb")
    .Add("username", "admin");

// Use the static factory method
var settings = FluentDictionary<string, int>.Create("timeout", 30)
    .Add("retries", 3)
    .Add("maxConnections", 100);

// Chain Add and Remove operations
var userPrefs = new FluentDictionary<string, bool>()
    .Add("darkMode", true)
    .Add("notifications", true)
    .Add("autoSave", false)
    .Remove("autoSave")
    .Add("autoSave", true);

// All Dictionary<TKey, TValue> methods available
bool hasKey = config.ContainsKey("host");
bool hasValue = config.TryGetValue("port", out string portValue);

public class ImageProcessor
{
    public async Task<string> ProcessAndUploadImage(IFormFile file)
    {
        using var stream = file.OpenReadStream();
        var image = Image.FromStream(stream);
        
        // Process image
        var scaledImage = ImageUtility.ScaleImage(image, 800, 600);
        var imageBytes = ImageUtility.ConvertBitmapToBytes((Bitmap)scaledImage, ImageFormat.Jpeg);
        
        // Generate unique filename
        var fileName = StringUtility.GenerateFileName(file.FileName, "jpg");
        
        // Upload to Azure
        using var uploadStream = new MemoryStream(imageBytes);
        AzureStorageManager.UploadToAzure(connectionString, "images", uploadStream, "image/jpeg", fileName, "uploads");
        
        return fileName;
    }
}

public class OtpService
{
    private readonly int _secretKey = 123456;

    public ValidationCodeResult GenerateOtp(string email)
    {
        return OtpUtility.GenerateCode(email, _secretKey, TimeSpan.FromMinutes(5));
    }

    public bool ValidateOtp(string email, string code, DateTime expiry)
    {
        return OtpUtility.ValidateCode(email, _secretKey, code, expiry);
    }
}