using System.ComponentModel;

namespace MyCompanyName.MyProjectName.Api.Core.Consts;

/// <summary>
/// 数据库键名
/// </summary>
public class DbKeys
{
    /// <summary>
    /// 模块库注册键
    /// </summary>
    [Description("模块库注册键")]
    public static string ModuleDb { get; set; } = "moduledb";
}

using MyCompanyName.MySys.Api.Core.Consts;
using ZhonTai.Admin.Core.Db.Transaction;
using ZhonTai.Admin.Core.Repositories;

namespace MyCompanyName.MySys.Api.Core.Repositories;

/// <summary>
/// 模块库基础仓储
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public class ModuleRepositoryBase<TEntity> : RepositoryBase<TEntity> where TEntity : class
{
    public ModuleRepositoryBase(UnitOfWorkManagerCloud uowm) : base(DbKeys.ModuleDb, uowm)
    {
    }
}

// 宿主应用实例
new HostApp(new HostAppOptions
{
    // 配置前置服务
    ConfigurePreServices = context =>
    {
        // 设置模块库注册键
        DbKeys.ModuleDb = "moduledb";
    },

    // 配置 Autofac 容器
    ConfigureAutofacContainer = (builder, context) =>
    {
        // 注册泛型模块基础仓储类
        builder.RegisterGeneric(typeof(ModuleRepositoryBase<>))
            .InstancePerLifetimeScope()
            .PropertiesAutowired();
    }
});

[Order(1010)]
[DynamicApi(Area = ApiConsts.AreaName)]
public class ModuleService : BaseService, IDynamicApi
{
    private readonly ModuleRepositoryBase<Entity> _moduleRepo;

    public ModuleService(ModuleRepositoryBase<Entity> moduleRepo)
    {
        _moduleRepo = moduleRepo;
    }
}

public class ModuleService : BaseService, IDynamicApi
{
    private readonly FreeSqlCloud _freeSqlCloud;

    public ModuleService(FreeSqlCloud freeSqlCloud)
    {
        _freeSqlCloud = freeSqlCloud;
    }

    public void GetData()
    {
        var fsql = _freeSqlCloud.Use(DbKeys.ModuleDb);
    }
}

using MyCompanyName.MySys.Api.Contracts.Domain.Module;
using ZhonTai.Admin.Core.Repositories;

namespace MyCompanyName.MySys.Api.Contracts;

/// <summary>
/// 模块仓储接口
/// </summary>
public interface IModuleRepository : IRepositoryBase<ModuleEntity>
{
}

using MyCompanyName.MySys.Api.Contracts;
using MyCompanyName.MySys.Api.Contracts.Domain.Module;
using MyCompanyName.MySys.Api.Core.Repositories;
using ZhonTai.Admin.Core.Db.Transaction;

namespace MyCompanyName.MySys.Api.Repositories.Module;

/// <summary>
/// 模块仓储
/// </summary>
public class ModuleRepository : ModuleRepositoryBase<ModuleEntity>, IModuleRepository
{
    public ModuleRepository(UnitOfWorkManagerCloud uowm) : base(uowm)
    {
    }
}

[Order(1010)]
[DynamicApi(Area = ApiConsts.AreaName)]
public class ModuleService : BaseService, IDynamicApi
{
    private readonly IModuleRepository _moduleRepo;

    public ModuleService(IModuleRepository moduleRepo)
    {
        _moduleRepo = moduleRepo;
    }
}

using System.Threading.Tasks;
using ZhonTai.Admin.Core.Configs;
using ZhonTai.Admin.Core.Db.Data;
using MyCompanyName.MySys.Api.Contracts.Domain.Module;

namespace MyCompanyName.MySys.Api.Core.Data;

public class CustomGenerateData : GenerateData, IGenerateData
{
    public virtual async Task GenerateDataAsync(IFreeSql db, AppConfig appConfig)
    {
        var isTenant = appConfig.Tenant;

        var modules = await db.Queryable<ModuleEntity>().ToListAsync();

        SaveDataToJsonFile<ModuleEntity>(modules, isTenant, path: "InitData/App");
    }
}

using System;
using System.Threading.Tasks;
using ZhonTai.Admin.Core.Configs;
using ZhonTai.Admin.Core.Db.Data;
using MyCompanyName.MySys.Api.Contracts.Domain.Module;
using System.Linq;

namespace MyCompanyName.MySys.Api.Core.Data;

public class CustomSyncData : SyncData, ISyncData
{
    public virtual async Task SyncDataAsync(IFreeSql db, DbConfig dbConfig = null, AppConfig appConfig = null)
    {
        using var unitOfWork = db.CreateUnitOfWork();

        try
        {
            var isTenant = appConfig.Tenant;

            await SyncEntityAsync<ModuleEntity>(
                db,
                unitOfWork,
                dbConfig,
                appConfig,
                whereFunc: (select, batchDataList) =>
                {
                    if (appConfig.Tenant)
                    {
                        return select.Where(a =>
                            batchDataList.Any(b =>
                                a.Id == b.Id ||
                                (
                                    a.TenantId == b.TenantId &&
                                    !string.IsNullOrWhiteSpace(a.Name) &&
                                    a.Name == b.Name
                                )
                            )
                        );
                    }

                    return select.Where(a =>
                        batchDataList.Any(b =>
                            a.Id == b.Id ||
                            (
                                !string.IsNullOrWhiteSpace(a.Name) &&
                                a.Name == b.Name
                            )
                        )
                    );
                },
                insertDataFunc: (batchDataList, dbDataList) =>
                {
                    return batchDataList.Where(a => !dbDataList.Any(b => a.Id == b.Id));
                }
            );

            unitOfWork.Commit();
        }
        catch (Exception)
        {
            unitOfWork.Rollback();
            throw;
        }
    }
}

[AppTransaction]
public virtual async Task UpdateAsync(UserUpdateInput input)
{
    if (!(input?.Id > 0))
    {
        // 事务回滚
        throw ResultOutput.Exception("请选择用户");
    }

    // 查询用户
    var user = await _userRepository.GetAsync(input.Id);
    if (!(user?.Id > 0))
    {
        // 事务回滚
        throw ResultOutput.Exception("用户不存在");

        // 也可以使用：
        // throw new AppException("用户不存在");
    }

    // 数据映射
    _mapper.Map(input, user);

    // 更新用户
    await _userRepository.UpdateAsync(user);

    // 删除用户角色
    await _userRoleRepository.DeleteAsync(a => a.UserId == user.Id);

    if (input.RoleIds != null && input.RoleIds.Any())
    {
        var roles = input.RoleIds.Select(a => new UserRoleEntity
        {
            UserId = user.Id,
            RoleId = a
        });

        // 批量插入用户角色
        await _userRoleRepository.InsertAsync(roles);
    }
}

throw ResultOutput.Exception(msg);

throw new AppException(msg);

/// <summary>
/// 缓存键定义
/// </summary>
public static partial class CacheKeys
{
    /// <summary>
    /// 模块缓存键，格式：module:action:{id}
    /// </summary>
    [Description("模块缓存键")]
    public const string ModuleActionKey = "module:action:";

    /// <summary>
    /// 根据模块 ID 生成缓存键
    /// </summary>
    /// <param name="id">模块 ID</param>
    public static string GetModuleActionKey(long id) => $"{ModuleActionKey}{id}";
}

/// <summary>
/// 模块服务
/// </summary>
[Order(1010)]
[DynamicApi(Area = ApiConsts.AreaName)]
public class ModuleService : IDynamicApi
{
    private readonly AppRepositoryBase<ModuleEntity> _moduleRep;
    private readonly ICacheTool _cache;

    public ModuleService(AppRepositoryBase<ModuleEntity> moduleRep, ICacheTool cache)
    {
        _moduleRep = moduleRep;
        _cache = cache;
    }

    /// <summary>
    /// 查询模块
    /// </summary>
    public async Task<ModuleGetOutput> GetAsync(long id)
    {
        var cacheKey = CacheKeys.GetModuleActionKey(id);

        // 优先从缓存获取
        var module = await _cache.GetAsync<ModuleGetOutput>(cacheKey);
        if (module == null)
        {
            // 缓存未命中，从数据库查询
            module = await _moduleRep.GetAsync<ModuleGetOutput>(id);
            // 并写入缓存，过期时间 5 分钟
            await _cache.SetAsync(cacheKey, module, TimeSpan.FromMinutes(5));
        }

        return module;
    }

    /// <summary>
    /// 修改模块
    /// </summary>
    public async Task UpdateAsync(ModuleUpdateInput input)
    {
        var entity = await _moduleRep.GetAsync(input.Id);
        if (entity?.Id is not > 0)
            throw ResultOutput.Exception("模块不存在");

        Mapper.Map(input, entity);
        await _moduleRep.UpdateAsync(entity);

        // 同步更新缓存
        var cacheKey = CacheKeys.GetModuleActionKey(input.Id);
        await _cache.SetAsync(cacheKey, Mapper.Map<ModuleGetOutput>(entity), TimeSpan.FromMinutes(5));
    }

    /// <summary>
    /// 彻底删除模块
    /// </summary>
    public async Task DeleteAsync(long id)
    {
        await _moduleRep.DeleteAsync(m => m.Id == id);

        // 删除缓存，避免脏数据
        var cacheKey = CacheKeys.GetModuleActionKey(id);
        await _cache.DelAsync(cacheKey);
    }
}

using ZhonTai.Common.Helpers;

// 手机号脱敏（中间4位替换为 ****）
var phone = DataMaskHelper.PhoneMask("13812345678");
// "138****5678"

// 自定义脱敏字符
var phone2 = DataMaskHelper.PhoneMask("13812345678", "***");
// "138***5678"

// 邮箱脱敏
var email = DataMaskHelper.EmailMask("zhangsan@example.com");
// "zh****@example.com"

// IP 地址脱敏
var ip = DataMaskHelper.IPMask("192.168.1.100");
// "192.*.*.100"

// 自定义 IP 脱敏字符
var ip2 = DataMaskHelper.IPMask("192.168.1.100", "x");
// "192.x.x.100"

using ZhonTai.Common.Helpers;

// 校验 IP 格式
IPHelper.IsIP("192.168.1.1");    // true
IPHelper.IsIP("256.1.1.1");      // false

// 从 HttpRequest 获取真实 IP（支持代理场景）
var ip = IPHelper.GetIP(HttpContext.Request);

using ZhonTai.Common.Helpers;

// 校验密码
PasswordHelper.Verify("abc123");           // true
PasswordHelper.Verify("Abc@123");          // true
PasswordHelper.Verify("123456");            // false（缺少字母）
PasswordHelper.Verify("abcdef");            // false（缺少数字）
PasswordHelper.Verify("12345");             // false（少于 6 位）
PasswordHelper.Verify("12345678901234567"); // false（超过 16 位）

// 使用内置正则
var isValid = System.Text.RegularExpressions.Regex.IsMatch(
    "Abc@123",
    PasswordHelper.PasswordRegex
);

new HostApp(new HostAppOptions
{
    ConfigurePostServices = context =>
    {
        // 加载应用配置和程序集
        var appConfig = AppInfo.GetRequiredService<AppConfig>(false);
        var assemblies = AssemblyHelper.GetAssemblyList(appConfig.AssemblyNames);

        // 获取数据库和 RabbitMQ 配置
        var dbConfig = AppInfo.GetRequiredService<DbConfig>(false);
        var rabbitMQ = context.Configuration.GetSection("CAP:RabbitMq").Get<RabbitMQOptions>();

        // 配置 CAP
        context.Services.AddCap(config =>
        {
            config.Version = "v1"; // 环境隔离标识
            config.UseSqlServer(dbConfig.ConnectionString); // SQL Server 存储
            config.UseRabbitMQ(mqConfig => // RabbitMQ 传输
            {
                mqConfig.HostName = rabbitMQ.HostName;
                mqConfig.Port = rabbitMQ.Port;
                mqConfig.UserName = rabbitMQ.UserName;
                mqConfig.Password = rabbitMQ.Password;
                mqConfig.ExchangeName = rabbitMQ.ExchangeName;
            });
            config.UseDashboard(); // 启用监控面板
        }).AddSubscriberAssembly(assemblies); // 自动注册订阅者
    }
}).Run(args, typeof(Program).Assembly);

/// <summary>
/// 订阅命名常量（确保全局唯一）
/// </summary>
public class SubscribeNames
{
    [Description("模块操作事件")]
    public const string ModuleAdd = "zhontai.admin.module.add";
}

/// <summary>
/// 模块新增事件（约定以 Event 作为后缀名，需支持序列化）
/// </summary>
public class ModuleAddEvent
{
    public long ModuleId { get; set; }
    public string ModuleName { get; set; }
    // 其他业务字段...
}

[Order(1010)]
[DynamicApi(Area = ApiConsts.AreaName)]
public class ModuleService : IDynamicApi
{
    private readonly AppRepositoryBase<ModuleEntity> _moduleRep;
    private readonly ICapPublisher _capPublisher;

    public ModuleService(
        AppRepositoryBase<ModuleEntity> moduleRep,
        ICapPublisher capPublisher)
    {
        _moduleRep = moduleRep;
        _capPublisher = capPublisher;
    }

    /// <summary>
    /// 新增模块并发布事件
    /// </summary>
    public async Task<long> AddAsync(ModuleAddInput input)
    {
        var entity = Mapper.Map<ModuleEntity>(input);
        await _moduleRep.InsertAsync(entity);

        // 发布 CAP 消息
        var moduleAddEvent = input.Adapt<ModuleAddEvent>();
        await _capPublisher.PublishAsync(
            SubscribeNames.ModuleAdd,
            moduleAddEvent
        );

        return entity.Id;
    }
}

public class ModuleSubscribeService : ICapSubscribe
{
    /// <summary>
    /// 处理模块新增事件
    /// </summary>
    [NonAction] // 防止被暴露为 API 端点
    [CapSubscribe(SubscribeNames.ModuleAdd)]
    public async Task HandleModuleAddAsync(ModuleAddEvent @event)
    {
        // 业务逻辑：发送通知、更新缓存等
    }
}