using Admin.NET.Core;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;

namespace Admin.NET.Plugin.AiDOP.Infrastructure;

/// <summary>
/// 将 Ai-DOP 种子菜单 Id 补写到 <c>sys_tenant_menu</c> / <c>sys_role_menu</c>。
/// 解决：<c>SysTenantMenuSeedData</c> 带 IgnoreUpdateSeed，库已存在时新增菜单不会自动进租户/角色；多租户下仅补默认租户会导致其它租户侧栏与菜单管理不可见。
/// </summary>
public static class AidopMenuLinkSync
{
    /// <summary>与框架种子中首条「系统管理员」角色 Id 一致。</summary>
    private const long SysAdminRoleId = 1300000000101L;
    private const long LegacyMaterialSubstitutionMenuId = 1329003000005L;
    private const long DeprecatedMaterialSubstitutionMenuId = 1329002000004L;
    private const long DeprecatedS8DashboardChildMenuId = 1329008000001L;
    private const long S8DirMenuId = 1321000009000L;

    public static void EnsureLinked(IServiceProvider services)
    {
        using var scope = services.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<ISqlSugarClient>();
        NormalizeMaterialSubstitutionMenu(db);
        NormalizeS1OrderWorkOrderParents(db);
        EnsureLinkagePlanMenu(db);
        RemoveDeprecatedS8DashboardChildMenu(db);
        NormalizeS8MenuParents(db);
        var seedMenus = new global::Admin.NET.Plugin.AiDOP.SysMenuSeedData().HasData().ToList();
        var seedMenuIds = seedMenus.Select(m => m.Id).ToHashSet();

        var existingMenuIds = db.Queryable<SysMenu>()
            .Where(m => seedMenuIds.Contains(m.Id))
            .Select(m => m.Id)
            .ToList()
            .ToHashSet();

        if (existingMenuIds.Count == 0)
            return;

        var tenantIds = db.Queryable<SysTenant>().Select(t => t.Id).ToList();
        if (tenantIds.Count == 0)
            return;

        var tenantMenuPairs = db.Queryable<SysTenantMenu>()
            .Where(tm => tenantIds.Contains(tm.TenantId) && seedMenuIds.Contains(tm.MenuId))
            .Select(tm => new { tm.TenantId, tm.MenuId })
            .ToList()
            .Select(x => (x.TenantId, x.MenuId))
            .ToHashSet();

        var tenantRows = new List<SysTenantMenu>();
        foreach (var tid in tenantIds)
        {
            foreach (var menu in seedMenus)
            {
                if (!existingMenuIds.Contains(menu.Id))
                    continue;
                if (tenantMenuPairs.Contains((tid, menu.Id)))
                    continue;
                tenantRows.Add(new SysTenantMenu
                {
                    Id = CommonUtil.GetFixedHashCode("" + tid + menu.Id, 1300000000000),
                    TenantId = tid,
                    MenuId = menu.Id
                });
            }
        }

        if (tenantRows.Count > 0)
            db.Insertable(tenantRows).ExecuteCommand();

        // 已为任一 Ai-DOP 种子菜单授权的角色，补全新增子菜单；并始终包含默认租户系统管理员角色。
        var roleIdsWithAnyAidop = db.Queryable<SysRoleMenu>()
            .Where(rm => seedMenuIds.Contains(rm.MenuId))
            .Select(rm => rm.RoleId)
            .ToList()
            .Distinct()
            .ToHashSet();
        roleIdsWithAnyAidop.Add(SysAdminRoleId);

        var roleMenuPairs = db.Queryable<SysRoleMenu>()
            .Where(rm => roleIdsWithAnyAidop.Contains(rm.RoleId) && seedMenuIds.Contains(rm.MenuId))
            .Select(rm => new { rm.RoleId, rm.MenuId })
            .ToList()
            .Select(x => (x.RoleId, x.MenuId))
            .ToHashSet();

        var roleRows = new List<SysRoleMenu>();
        foreach (var roleId in roleIdsWithAnyAidop)
        {
            foreach (var menu in seedMenus)
            {
                if (!existingMenuIds.Contains(menu.Id))
                    continue;
                if (roleMenuPairs.Contains((roleId, menu.Id)))
                    continue;
                roleRows.Add(new SysRoleMenu
                {
                    Id = menu.Id + (roleId % 1300000000000),
                    RoleId = roleId,
                    MenuId = menu.Id
                });
            }
        }

        if (roleRows.Count > 0)
            db.Insertable(roleRows).ExecuteCommand();
    }

    /// <summary>
    /// 计划联动看板（Id=1322000000107）：<c>Database.json</c> 常关闭 <c>EnableIncreSeed</c>，种子不会入库，故在启动时补插/纠偏。
    /// 父级为产销协同看板目录 1322000000005。
    /// </summary>
    private static void EnsureLinkagePlanMenu(ISqlSugarClient db)
    {
        const long menuId = 1322000000107L;
        const long salesKanBanDirId = 1322000000005L;
        if (!db.Queryable<SysMenu>().Any(m => m.Id == salesKanBanDirId))
            return;

        var ct = DateTime.Parse("2022-02-10 00:00:00");
        if (!db.Queryable<SysMenu>().Any(m => m.Id == menuId))
        {
            db.Insertable(new SysMenu
            {
                Id = menuId,
                Pid = salesKanBanDirId,
                Title = "计划联动看板",
                Path = "/aidop/s1/SalesKanBan/linkage-plan",
                Name = "aidopS1LinkagePlan",
                Component = "/aidop/business/linkagePlanList",
                Icon = "ele-DataBoard",
                Type = MenuTypeEnum.Menu,
                CreateTime = ct,
                OrderNo = 30,
                Status = StatusEnum.Enable,
                Remark = "S1 计划联动看板（LinkagePlan）"
            }).ExecuteCommand();
            return;
        }

        var row = db.Queryable<SysMenu>().First(m => m.Id == menuId);
        if (row.Pid != salesKanBanDirId
            || row.Path != "/aidop/s1/SalesKanBan/linkage-plan"
            || row.Component != "/aidop/business/linkagePlanList")
        {
            row.Pid = salesKanBanDirId;
            row.Path = "/aidop/s1/SalesKanBan/linkage-plan";
            row.Name = "aidopS1LinkagePlan";
            row.Component = "/aidop/business/linkagePlanList";
            row.Title = "计划联动看板";
            row.Icon = "ele-DataBoard";
            row.OrderNo = 30;
            row.Type = MenuTypeEnum.Menu;
            db.Updateable(row)
                .UpdateColumns(m => new { m.Pid, m.Path, m.Name, m.Component, m.Title, m.Icon, m.OrderNo, m.Type })
                .ExecuteCommand();
        }
    }

    private static void NormalizeMaterialSubstitutionMenu(ISqlSugarClient db)
    {
        var deprecatedMenuId = DeprecatedMaterialSubstitutionMenuId;
        var legacyMenuId = LegacyMaterialSubstitutionMenuId;

        var legacyMenu = db.Queryable<SysMenu>()
            .First(m => m.Id == legacyMenuId);
        if (legacyMenu != null)
        {
            legacyMenu.Title = "物料替代";
            legacyMenu.Path = "/aidop/s0/manufacturing/material-substitution";
            legacyMenu.Name = "aidopS0MfgMaterialSubstitution";
            legacyMenu.Component = "/aidop/s0/manufacturing/MaterialSubstitutionList";
            legacyMenu.Remark = "S0 物料替代";
            db.Updateable(legacyMenu)
                .UpdateColumns(m => new { m.Title, m.Path, m.Name, m.Component, m.Remark })
                .ExecuteCommand();
        }

        var deprecatedExists = db.Queryable<SysMenu>().Any(m => m.Id == deprecatedMenuId);
        if (!deprecatedExists)
            return;

        db.Deleteable<SysUserMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysRoleMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysTenantMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysMenu>().Where(x => x.Id == deprecatedMenuId).ExecuteCommand();
    }

    private static void RemoveDeprecatedS8DashboardChildMenu(ISqlSugarClient db)
    {
        const long deprecatedMenuId = DeprecatedS8DashboardChildMenuId;
        var deprecatedExists = db.Queryable<SysMenu>().Any(m => m.Id == deprecatedMenuId);
        if (!deprecatedExists)
            return;

        db.Deleteable<SysUserMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysRoleMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysTenantMenu>().Where(x => x.MenuId == deprecatedMenuId).ExecuteCommand();
        db.Deleteable<SysMenu>().Where(x => x.Id == deprecatedMenuId).ExecuteCommand();
    }

    private static void NormalizeS8MenuParents(ISqlSugarClient db)
    {
        var s8MenuIds = new long[]
        {
            1329008000002L,
            1329008000003L,
            1329008000004L,
            1329008000010L,
            1329008000011L,
            1329008000012L,
            1329008000013L,
            1329008000014L,
            1329008000015L,
            1329008000016L,
            1329008000020L
        };

        db.Updateable<SysMenu>()
            .SetColumns(x => x.Pid == S8DirMenuId)
            .Where(x => s8MenuIds.Contains(x.Id) && x.Pid != S8DirMenuId)
            .ExecuteCommand();
    }

    /// <summary>
    /// 将 S1「订单管理」「工单管理」升级为目录并修正 path/name；
    /// 「产销协同看板」单独菜单路径为 /aidop/s1/SalesKanBan；
    /// 「工单下达」父级须为工单管理目录 1322000000004（历史错误曾挂到 0005）。
    /// </summary>
    private static void NormalizeS1OrderWorkOrderParents(ISqlSugarClient db)
    {
        const long orderMgmtId = 1322000000003L;
        const long workOrderMgmtId = 1322000000004L;
        const long salesKanBanMenuId = 1322000000005L;
        const long workOrderDispatchMenuId = 1322000000106L;

        var orderMgmt = db.Queryable<SysMenu>().First(m => m.Id == orderMgmtId);
        if (orderMgmt != null)
        {
            orderMgmt.Type = MenuTypeEnum.Dir;
            orderMgmt.Component = "Layout";
            orderMgmt.Path = "/aidop/s1/order-mgmt";
            orderMgmt.Name = "aidopS1OrderMgmt";
            orderMgmt.Icon = "ele-Folder";
            db.Updateable(orderMgmt)
                .UpdateColumns(m => new { m.Type, m.Component, m.Path, m.Name, m.Icon })
                .ExecuteCommand();
        }

        var workOrderMgmt = db.Queryable<SysMenu>().First(m => m.Id == workOrderMgmtId);
        if (workOrderMgmt != null)
        {
            workOrderMgmt.Type = MenuTypeEnum.Dir;
            workOrderMgmt.Component = "Layout";
            workOrderMgmt.Path = "/aidop/s1/workorder-mgmt";
            workOrderMgmt.Name = "aidopS1WorkOrderMgmt";
            workOrderMgmt.Icon = "ele-Folder";
            db.Updateable(workOrderMgmt)
                .UpdateColumns(m => new { m.Type, m.Component, m.Path, m.Name, m.Icon })
                .ExecuteCommand();
        }

        var salesKanBan = db.Queryable<SysMenu>().First(m => m.Id == salesKanBanMenuId);
        if (salesKanBan != null)
        {
            salesKanBan.Type = MenuTypeEnum.Menu;
            salesKanBan.Component = "/aidop/kanban/s1";
            salesKanBan.Path = "/aidop/s1/SalesKanBan";
            salesKanBan.Name = "aidopS1003";
            salesKanBan.Icon = "ele-DataAnalysis";
            db.Updateable(salesKanBan)
                .UpdateColumns(m => new { m.Type, m.Component, m.Path, m.Name, m.Icon })
                .ExecuteCommand();
        }

        var dispatch = db.Queryable<SysMenu>().First(m => m.Id == workOrderDispatchMenuId);
        if (dispatch != null)
        {
            var needFix = dispatch.Pid != workOrderMgmtId
                          || dispatch.Path != "/aidop/s1/workorder-mgmt/dispatch";
            if (needFix)
            {
                dispatch.Pid = workOrderMgmtId;
                dispatch.Path = "/aidop/s1/workorder-mgmt/dispatch";
                db.Updateable(dispatch)
                    .UpdateColumns(m => new { m.Pid, m.Path })
                    .ExecuteCommand();
            }
        }
    }
}