using Tiger.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using Tiger.IBusiness;
using System.Threading.Tasks;
using Rhea.Common;
using System.Net;
using System.Linq;
using Newtonsoft.Json;

namespace Tiger.Business
{
    public partial class Biz
    {
        /// <summary>
        /// 保存角色
        /// </summary>
        /// <param name="action"></param>
        /// <param name="Async"></param>
        /// <returns></returns>
        public async Task<ApiAction> SaveRole(ApiAction<SaveRoleStrictlyParams> action)
        {
            var apiAction = new ApiAction();
            try
            {
                SaveRoleStrictlyParams data = action.Data;
                SYS_ROLE func = Biz.Db.Queryable<SYS_ROLE>().Where(x => x.ID == data.ID).First();
                if (func != null)
                {
                    func.ROLE_CODE = data.ROLE_CODE;
                    func.ROLE_DESC = data.ROLE_DESC;
                    func.IS_ACTIVE = data.IS_ACTIVE;
                }
                else
                {
                    func = new()
                    {
                        ID = Guid.NewGuid().ToString("N"),
                        ROLE_CODE = data.ROLE_CODE,
                        ROLE_DESC = data.ROLE_DESC,
                        IS_ACTIVE = data.IS_ACTIVE
                    };
                }
                //保存角色菜单
                List<SYS_ROLE_MENU> roleMenuList = new List<SYS_ROLE_MENU>();
                if (data.menu.Checked != null)
                {
                    foreach (var item in data.menu.Checked)
                    {
                        SYS_ROLE_MENU roleMenu = new()
                        {
                            ROLE_CODE = func.ID,
                            FUNC_CODE = item,
                            HALF_CHECK = "N"
                        };
                        roleMenuList.Add(roleMenu);
                    }
                }
                if (data.menu.halfChecked != null)
                {
                    foreach (var item in data.menu.halfChecked)
                    {
                        SYS_ROLE_MENU roleMenu = new()
                        {
                            ROLE_CODE = func.ID,
                            FUNC_CODE = item,
                            HALF_CHECK = "Y"
                        };
                        roleMenuList.Add(roleMenu);
                    }
                }
                //保存角色组织
                List<SYS_ROLE_ORG> roleOrgList = new List<SYS_ROLE_ORG>();
                if (data.org.Checked != null)
                {
                    foreach (var item in data.org.Checked)
                    {
                        SYS_ROLE_ORG roleOrg = new()
                        {
                            ROLE_CODE = func.ID,
                            ORG_CODE = item,
                            HALF_CHECK = "N"
                        };
                        roleOrgList.Add(roleOrg);
                    }
                }
                if (data.org.halfChecked != null)
                {
                    foreach (var item in data.org.halfChecked)
                    {
                        SYS_ROLE_ORG roleOrg = new()
                        {
                            ROLE_CODE = func.ID,
                            ORG_CODE = item,
                            HALF_CHECK = "Y"
                        };
                        roleOrgList.Add(roleOrg);
                    }
                }

                //保存角色仓库
                List<SYS_ROLE_WH> roleWhList = new List<SYS_ROLE_WH>();
                if (data.wh.Checked != null)
                {
                    foreach (var item in data.wh.Checked)
                    {
                        SYS_ROLE_WH roleWh = new()
                        {
                            ROLE_CODE = func.ID,
                            WH_CODE = item,
                            HALF_CHECK = "N"
                        };
                        roleWhList.Add(roleWh);
                    }
                }
                if (data.wh.halfChecked != null)
                {
                    foreach (var item in data.wh.halfChecked)
                    {
                        SYS_ROLE_WH roleWh = new()
                        {
                            ROLE_CODE = func.ID,
                            WH_CODE = item,
                            HALF_CHECK = "Y"
                        };
                        roleWhList.Add(roleWh);
                    }
                }

                //保存角色工厂
                List<SYS_ROLE_PROD> rolePrdList = new List<SYS_ROLE_PROD>();
                if (data.fty.Checked != null)
                {
                    foreach (var item in data.fty.Checked)
                    {
                        SYS_ROLE_PROD roleFty = new()
                        {
                            ROLE_CODE = func.ID,
                            PROD_CODE = item,
                            HALF_CHECK = "N"
                        };
                        rolePrdList.Add(roleFty);
                    }
                }
                if (data.fty.halfChecked != null)
                {
                    foreach (var item in data.fty.halfChecked)
                    {
                        SYS_ROLE_PROD roleFty = new()
                        {
                            ROLE_CODE = func.ID,
                            PROD_CODE = item,
                            HALF_CHECK = "Y"
                        };
                        rolePrdList.Add(roleFty);
                    }
                }

                //保存到数据库
                var db = Business.Biz.Db;
                var dbTran = db.UseTran(() =>
                {
                    //更新
                    if (data != null && data.isUpdate)
                    {
                        db.Updateable(func, "system").ExecuteCommand();
                    }
                    //新增
                    else
                    {
                        db.Insertable(func, "system").ExecuteCommand();
                    }

                    if (roleMenuList.Count > 0)
                    {
                        if (!string.IsNullOrEmpty(data.ID))
                        {
                            db.Deleteable<SYS_ROLE_MENU>().Where(x => x.ROLE_CODE == data.ID).ExecuteCommand();
                        }
                        db.Storageable(roleMenuList, "system").ExecuteCommand();
                    }
                    if (roleOrgList.Count > 0)
                    {
                        if (!string.IsNullOrEmpty(data.ID))
                        {
                            db.Deleteable<SYS_ROLE_ORG>().Where(x => x.ROLE_CODE == data.ID).ExecuteCommand();
                        }
                        db.Storageable(roleOrgList, "system").ExecuteCommand();
                    }
                    if (rolePrdList.Count > 0)
                    {
                        if (!string.IsNullOrEmpty(data.ID))
                        {
                            db.Deleteable<SYS_ROLE_PROD>().Where(x => x.ROLE_CODE == data.ID).ExecuteCommand();
                        }
                        db.Storageable(rolePrdList, "system").ExecuteCommand();
                    }
                    if (roleWhList.Count > 0)
                    {
                        if (!string.IsNullOrEmpty(data.ID))
                        {
                            db.Deleteable<SYS_ROLE_WH>().Where(x => x.ROLE_CODE == data.ID).ExecuteCommand();
                        }
                        db.Storageable(roleWhList, "system").ExecuteCommand();
                    }
                });
                if (!dbTran.IsSuccess)
                {
                    apiAction.Data = null;
                    apiAction.IsSuccessed = false;
                    apiAction.Message += $"保存数据失败：{dbTran.ErrorMessage}";
                    return apiAction;
                }
            }
            catch (System.Exception ex)
            {

            }
            return apiAction;
        }

        /// <summary>
        /// 用户组关联角色保存方法
        /// </summary>
        /// <param name="roleIdIn"></param>
        /// <param name="userGroupId"></param>
        /// <returns></returns>
        public async Task<ApiAction> SetRoleToGroupAsync( string roleIdIn, string userGroupId)
        {
            var action = new ApiAction();
            try
            {
                var userIds = roleIdIn.Split(',').ToList();
                List<SYS_ROLE> list = await Biz.Db.Queryable<SYS_ROLE>().Where(x => userIds.Contains(x.ROLE_CODE)).ToListAsync();

                //保存到数据库
                var db = Business.Biz.Db;
                var dbTran = db.UseTran(() =>
                {
                    List<SYS_USERGROUP_ROLE> roleingroupList = new();
                    db.Deleteable<SYS_USERGROUP_ROLE>().Where(x => x.USERGROUP_CODE == userGroupId).ExecuteCommand();
                    if (list != null && list.Count > 0)
                    {
                        foreach (var item in list)
                        {
                            SYS_USERGROUP_ROLE g = new SYS_USERGROUP_ROLE();
                            g.ROLE_CODE = item.ID;
                            g.USERGROUP_CODE = userGroupId;
                            roleingroupList.Add(g);
                        }
                        db.Insertable(roleingroupList, "admin").ExecuteCommand();
                    }
                });
                if (!dbTran.IsSuccess)
                {
                    throw dbTran.ErrorException;
                }
                action.IsSuccessed = true;
                action.Message = $"保存用户组中的角色列表成功。";
            }
            catch (Exception ex)
            {
                action.CatchExceptionWithLog(ex, $"保存用户组中的角色列表异常");
            }
            return action;
        }
    }
}