using EncryptFileTool.Entity;
using HandyControl.Controls;
using log4net;
using Newtonsoft.Json;
using SparkClient.Model.Helper;
using SparkClient.ViewModel.Grading;
using System.Data;
using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using MessageBox = SparkClient.Views.Dialog.MessageBox;

namespace SparkClient.ViewModel.Configuration;

/// <summary>
/// 定级配置VM
/// </summary>
public class LevelConfigVM : BaseViewModel
{
    private static readonly ILog Logger = LogManager.GetLogger(typeof(LevelConfigVM));
    public ICommand ChangeShapeModelCommand { get; }
    public ICommand ChangeInstituteModelCommand { get; }
    public ICommand LoadLevelConfigCommand { get; }
    public ICommand DelLevelConfigCommand { get; }
    public ICommand SaveLevelConfigCommand { get; }

    private DataTable _institutes;
    /// <summary>
    /// 规则下拉列表
    /// </summary>
    public DataTable Institutes { get { return _institutes; } set { _institutes = value; OnPropertyChanged("Institutes"); } }
    private DataTable _shapes;
    /// <summary>
    /// 形状下拉列表
    /// </summary>
    public DataTable Shapes { get { return _shapes; } set { _shapes = value; OnPropertyChanged("Shapes"); } }

    private string _instituteId;
    /// <summary>
    /// 规则id
    /// </summary>
    public string InstituteId { get { return _instituteId; } set { _instituteId = value; OnPropertyChanged("InstituteId"); } }

    private string _shapeId;
    /// <summary>
    /// 形状id
    /// </summary>
    public string ShapeId { get { return _shapeId; } set { _shapeId = value; OnPropertyChanged("ShapeId"); } }

    private DataTable _standardList;
    /// <summary>
    /// 定级配置数据
    /// </summary>
    public DataTable StandardList { get { return _standardList; } set { _standardList = value; OnPropertyChanged("StandardList"); } }
    DataGrid dataGrid;
    private bool _institutesEnabled = true;
    /// <summary>
    /// 规则下拉列表可用性
    /// </summary>
    public bool InstitutesEnabled { get { return _institutesEnabled; } set { _institutesEnabled = value; OnPropertyChanged("InstitutesEnabled"); } }
    private bool _shapesEnabled = true;
    /// <summary>
    /// 形状下拉列表可用性
    /// </summary>
    public bool ShapesEnabled { get { return _shapesEnabled; } set { _shapesEnabled = value; OnPropertyChanged("ShapesEnabled"); } }
    private bool _isUpdateButtonEnabled;
    /// <summary>
    /// 保存按钮可用性
    /// </summary>
    public bool IsUpdateButtonEnabled { get { return _isUpdateButtonEnabled; } set { _isUpdateButtonEnabled = value; OnPropertyChanged("IsUpdateButtonEnabled"); } }
    /// <summary>
    /// 导入文件数据
    /// </summary>
    JsonEntity jsonEntity = new JsonEntity();

    private string Save_successful_message = MultilingualHelper.getString("Save_successful_message");
    private string save_fail_message = MultilingualHelper.getString("save_fail_message");
    private string no_data_message = MultilingualHelper.getString("no_data_message");
    private string grade_config_left_top = MultilingualHelper.getString("grade_config_left_top");
    private string GRADE_NAME = MultilingualHelper.getString("GRADE_NAME");
    private string STANDARD_NAME = MultilingualHelper.getString("STANDARD_NAME");
    public LevelConfigVM(DataGrid dataGrid)
    {
        try
        {
            if (dataGrid == null) return;
            this.dataGrid = dataGrid;
            ChangeShapeModelCommand = new RelayCommand(ChangeShapeModel);
            ChangeInstituteModelCommand = new RelayCommand(ChangeInstituteModel);
            LoadLevelConfigCommand = new RelayCommand(LoadLevelConfig);
            DelLevelConfigCommand = new RelayCommand(DelLevelConfig);
            SaveLevelConfigCommand = new RelayCommand(SaveLevelConfig);
            InitLevelConfig(null);
            InitData();
            IsUpdateButtonEnabled = false;
        }
        catch (Exception ex)
        {
            new MessageBox().Show($"{MultilingualHelper.getString("ApplicationError")}{ex.Message}");
            Logger.Error($"全局异常捕获：{ex.Message}", ex);
        }
    }

    /// <summary>
    /// 加载顶级配置的数据
    /// </summary>
    /// <param name="param"></param>
    public void InitLevelConfig(object param)
    {
        try
        {
            Save_successful_message = MultilingualHelper.getString("Save_successful_message");
            save_fail_message = MultilingualHelper.getString("save_fail_message");
            no_data_message = MultilingualHelper.getString("no_data_message");
            grade_config_left_top = MultilingualHelper.getString("grade_config_left_top");
            GRADE_NAME = MultilingualHelper.getString("GRADE_NAME");
            STANDARD_NAME = MultilingualHelper.getString("STANDARD_NAME");
        }
        catch (Exception ex)
        {
            new MessageBox().Show($"{MultilingualHelper.getString("ApplicationError")}{ex.Message}");
            Logger.Error($"全局异常捕获：{ex.Message}", ex);
        }
    }
    /// <summary>
    /// 初始化数据（形状列表检索）
    /// </summary>
    private void InitData()
    {
        dataGrid.Columns.Clear();
        string shapeSql = @"SELECT * FROM SHAPE WHERE PARENT_ID IS NULL OR TRIM(PARENT_ID) = '' ;";
        Shapes = DataBaseHelper.ExecuteQuery(shapeSql);
        if (Shapes != null)
        {
            ShapeId = Shapes.AsEnumerable().FirstOrDefault()["SHAPE_ID"].ToString();
        }
    }
    /// <summary>
    /// 初始化数据（规则列表检索）
    /// </summary>
    private string setInstitutes(string id)
    {
        string insituteSql = $"SELECT RULE_ID,RULE_NAME,RULE_EN_NAME FROM RULE WHERE RULE_ID NOT LIKE '%_TA_%';";
        Institutes = DataBaseHelper.ExecuteQuery(insituteSql);
        return Institutes.AsEnumerable().FirstOrDefault()["RULE_ID"].ToString();
    }
    /// <summary>
    /// 页面数据初始化(检索)
    /// </summary>
    /// <param name="shapeId"></param>
    /// <param name="ruleId"></param>
    private void setDataGrid(string shapeId, string ruleId)
    {
        string gradeSql = $"SELECT GRADE_NAME,GRADE_EN_NAME,GRADE_ORDER  FROM GRADE WHERE SHAPE_ID = '{shapeId}' AND RULE_ID LIKE '{ruleId}%' GROUP BY GRADE_NAME,GRADE_EN_NAME,GRADE_ORDER ORDER BY GRADE_ORDER;";
        DataTable columnInfos = DataBaseHelper.ExecuteQuery(gradeSql);

        string standardSql = $"SELECT * FROM STANDARD WHERE SHAPE_ID = '{shapeId}' AND RULE_ID like '{ruleId}%' ORDER BY RULE_ID, SUBSTR(0 || SORT, - 2), GRADE_ORDER;";
        DataTable rowInfos = DataBaseHelper.ExecuteQuery(standardSql);
        setStandardList(columnInfos, rowInfos);
    }
    /// <summary>
    /// 页面数据初始化（页面值设定）
    /// </summary>
    /// <param name="gradeList"></param>
    /// <param name="standardList"></param>
    private void setStandardList(DataTable gradeList, DataTable standardList)
    {
        try
        {
            // 定义单元格样式
            Style cellStyle = new Style(typeof(TextBlock));
            Setter setSellStyle = new Setter(TextBlock.HorizontalAlignmentProperty, HorizontalAlignment.Center);
            cellStyle.Setters.Add(setSellStyle);
            Setter setSellStyle1 = new Setter(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
            cellStyle.Setters.Add(setSellStyle1);
            // 清空datagrid中的数据
            dataGrid.Columns.Clear();
            if (gradeList != null)
            {
                
                StandardList = new DataTable();
                List<DataColumn> columns = new List<DataColumn>();
                // 循环等级列表,设定datagrid中的列
                foreach (DataRow columnInfo in gradeList.Rows)
                {
                    // 最高等的情况列放置于中间
                    if ("1".Equals(columnInfo["GRADE_ORDER"].ToString()))
                    {
                        columns.Add(new DataColumn(columnInfo["GRADE_EN_NAME"].ToString()));
                        columns.Add(new DataColumn(columnInfo["GRADE_EN_NAME"].ToString() + "_" + 1));
                        //this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = columnInfo[GRADE_NAME].ToString(), Binding = new Binding(columnInfo["GRADE_EN_NAME"].ToString()),ElementStyle = cellStyle });
                        this.dataGrid.Columns.Add(GetDataGridColumn(columnInfo[GRADE_NAME].ToString() ?? "", columnInfo["GRADE_EN_NAME"].ToString() ?? ""));
                    }
                    // 最高等级以外情况的列放置于两侧
                    else
                    {
                        //this.dataGrid.Columns.Insert(0, new DataGridTextColumn() { Header = columnInfo[GRADE_NAME].ToString(), Binding = new Binding(columnInfo["GRADE_EN_NAME"].ToString() + "_MIN"), ElementStyle = cellStyle });
                        //this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = columnInfo[GRADE_NAME].ToString(), Binding = new Binding(columnInfo["GRADE_EN_NAME"].ToString() + "_MAX"), ElementStyle = cellStyle });
                        this.dataGrid.Columns.Insert(0, GetDataGridColumn(columnInfo[GRADE_NAME].ToString() ?? "", (columnInfo["GRADE_EN_NAME"].ToString() ?? "") + "_MIN"));
                        this.dataGrid.Columns.Add(GetDataGridColumn(columnInfo[GRADE_NAME].ToString() ?? "", (columnInfo["GRADE_EN_NAME"].ToString() ?? "") + "_MAX"));
                        columns.Insert(0, new DataColumn(columnInfo["GRADE_EN_NAME"].ToString() + "_MIN"));
                        columns.Insert(0, new DataColumn(columnInfo["GRADE_EN_NAME"].ToString() + "_MIN" + "_" + 1));
                        columns.Add(new DataColumn(columnInfo["GRADE_EN_NAME"].ToString() + "_MAX"));
                        columns.Add(new DataColumn(columnInfo["GRADE_EN_NAME"].ToString() + "_MAX" + "_" + 1));
                    }
                }
                // 在最左侧放置测试项目列
                columns.Insert(0, new DataColumn("title"));
                this.dataGrid.Columns.Insert(0, new DataGridTextColumn() { Header = grade_config_left_top, Binding = new Binding("title"), ElementStyle = cellStyle });
                StandardList.Columns.AddRange(columns.ToArray());
                
                if (standardList != null)
                {
                    // 以规则id分组(国标时会有多中规则id的情况)
                    var standardRules = standardList.AsEnumerable().GroupBy(r => r["RULE_ID"].ToString());
                    foreach (var ruleStandardList in standardRules)
                    {
                        // 以测试项目名分组表示每一行
                        var standards = ruleStandardList.AsEnumerable().GroupBy(r => r[STANDARD_NAME].ToString());
                        foreach (var standard in standards)
                        {
                            List<string> rowInfo = new List<string>();
                            foreach (DataRow columnInfo in gradeList.Rows)
                            {
                                // 每一行单元格内数据
                                var row = standard.Where(s => s["GRADE_ORDER"].ToString() == columnInfo["GRADE_ORDER"].ToString()).FirstOrDefault();
                                string value = "";
                                // 国标时有空场合,为空时做以下处理
                                if (row == null)
                                {
                                    if ("1".Equals(columnInfo["GRADE_ORDER"].ToString()))
                                    {
                                        rowInfo.Add("-");
                                        rowInfo.Add("");
                                    }
                                    else
                                    {
                                        rowInfo.Insert(0, "-");
                                        rowInfo.Insert(0, "");
                                        rowInfo.Add("-");
                                        rowInfo.Add("");
                                    }
                                    continue;
                                }
                                // 把获取的数据按照定级排序放置与单元格中
                                // 最高等级放中间,其他的依次往两侧排列
                                // 最高等级
                                if ("1".Equals(row["GRADE_ORDER"].ToString()))
                                {
                                    string Min = row["STANDARD_MIN"].ToString();
                                    string Max = row["STANDARD_MAX"].ToString();
                                    // 最大值并且最小值不为空时 以最小值-最大值显示
                                    if (!string.IsNullOrEmpty(Min) && !string.IsNullOrEmpty(Max))
                                    {
                                        value = getFix(row, "MIN_PREFIX") +
                                        Min + row["UNIT"].ToString() + "-"
                                        + Max + row["UNIT"].ToString()
                                        + getFix(row, "MIN_SUFFIX")
                                        ;
                                    }
                                    // 最小值不为空,最大值为空时 显示最小值
                                    else if (!string.IsNullOrEmpty(Min))
                                    {
                                        value = getFix(row, "MIN_PREFIX") +
                                         Min + row["UNIT"].ToString()
                                         + getFix(row, "MIN_SUFFIX")
                                         ;
                                    }
                                    // 最大值不为空,最小值为空时 显示最大值
                                    else if (!string.IsNullOrEmpty(Max))
                                    {
                                        value = getFix(row, "MIN_PREFIX") +
                                         Max + row["UNIT"].ToString()
                                         + getFix(row, "MIN_SUFFIX")
                                         ;
                                    }
                                    // 有换行符时 分两行显示
                                    var arr = value.Split("\r\n", 2);
                                    rowInfo.Add(arr[0]);
                                    if (arr.Length > 1)
                                    {
                                        rowInfo.Add(arr[1]);
                                    }
                                    else
                                    {
                                        rowInfo.Add("");
                                    }
                                }
                                // 其他等级 依次放两边
                                else
                                {
                                    // 每一行单元格内数据
                                    if (row["STANDARD_MIN"] == null || row["STANDARD_MIN"].ToString() == "")
                                    {
                                        value = getFix(row, "MIN_PREFIX")
                                             + row["MIN_NULL_REPALCE"].ToString()
                                             + getFix(row, "MIN_SUFFIX");
                                        var arr = value.Split("\r\n", 2);
                                        rowInfo.Insert(0, arr[0]);
                                        if (arr.Length > 1)
                                        {
                                            rowInfo.Insert(0, arr[1]);
                                        }
                                        else
                                        {
                                            rowInfo.Insert(0, "");
                                        }

                                    }
                                    else
                                    {
                                        value = getFix(row, "MIN_PREFIX")
                                            + row["STANDARD_MIN"].ToString()
                                            + row["UNIT"].ToString()
                                            + getFix(row, "MIN_SUFFIX");
                                        var arr = value.Split("\r\n", 2);
                                        rowInfo.Insert(0, arr[0]);
                                        if (arr.Length > 1)
                                        {
                                            rowInfo.Insert(0, arr[1]);
                                        }
                                        else
                                        {
                                            rowInfo.Insert(0, "");
                                        }
                                    }
                                    if (row["STANDARD_MAX"] == null || row["STANDARD_MAX"].ToString() == "")
                                    {
                                        value = getFix(row, "MAX_PREFIX") +
                                            row["MAX_NULL_REPALCE"].ToString()
                                            + getFix(row, "MAX_SUFFIX");
                                        var arr = value.Split("\r\n", 2);
                                        rowInfo.Add(arr[0]);
                                        if (arr.Length > 1)
                                        {
                                            rowInfo.Add(arr[1]);
                                        }
                                        else
                                        {
                                            rowInfo.Add("");
                                        }
                                    }
                                    else
                                    {
                                        value = getFix(row, "MAX_PREFIX") +
                                            row["STANDARD_MAX"].ToString() + row["UNIT"].ToString()
                                            + getFix(row, "MAX_SUFFIX");
                                        var arr = value.Split("\r\n", 2);
                                        rowInfo.Add(arr[0]);
                                        if (arr.Length > 1)
                                        {
                                            rowInfo.Add(arr[1]);
                                        }
                                        else
                                        {
                                            rowInfo.Add("");
                                        }
                                    }
                                }

                            }
                            string ruleId = ruleStandardList.Key;
                            string prefix = "";
                            if (ruleId != null && !string.IsNullOrEmpty(ruleId))
                            {
                                string ta = ruleId.Substring(ruleId.Length - 2);

                                // 国标场合 按照规则id中涵盖信息不同 对测试项目有不同描述
                                string itemName = Name.getNameById("TABLE").Trim();
                                if (ruleId.StartsWith("GB"))
                                {
                                    if ("49".Equals(ta))
                                    {
                                        prefix = $"[{itemName}<" + ruleId.Substring(ruleId.Length - 2) + "] ";
                                    }
                                    else if ("71".Equals(ta))
                                    {
                                        prefix = $"[{itemName}>" + ruleId.Substring(ruleId.Length - 2) + "] ";
                                    }
                                    else
                                    {
                                        prefix = $"[{itemName}=" + ruleId.Substring(ruleId.Length - 2) + "] ";
                                    }
                                }
                            }
                            rowInfo.Insert(0, prefix + standard.Key);
                            var showRow = StandardList.NewRow();
                            showRow.ItemArray = rowInfo.ToArray();
                            StandardList.Rows.Add(showRow);
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            new MessageBox().Show($"{MultilingualHelper.getString("ApplicationError")}{ex.Message}");
            Logger.Error($"全局异常捕获：{ex.Message}", ex);
        }
    }
    /// <summary>
    /// 设置单元格内部元素(现在单元格内部元素为两个textblock)
    /// </summary>
    /// <param name="Header"></param>
    /// <param name="Binding"></param>
    /// <param name="lineCount"></param>
    /// <returns></returns>
    private DataGridColumn GetDataGridColumn(string Header,string Binding,int lineCount = 2)
    {
        //Style cellStyle = new Style(typeof(TextBlock));
        //Setter setSellStyle = new Setter(TextBlock.HorizontalAlignmentProperty, HorizontalAlignment.Center);
        //cellStyle.Setters.Add(setSellStyle);
        //Setter setSellStyle1 = new Setter(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
        //cellStyle.Setters.Add(setSellStyle1);

        DataGridTemplateColumn column = new DataGridTemplateColumn() { Header = Header};
        //column.CellTemplate
        FrameworkElementFactory stackPanelFactory = new FrameworkElementFactory(typeof(StackPanel));
        stackPanelFactory.SetValue(StackPanel.OrientationProperty, Orientation.Vertical);
        stackPanelFactory.SetValue(StackPanel.VerticalAlignmentProperty, VerticalAlignment.Center);
        for (int i = 0; i < lineCount; i++) {
            FrameworkElementFactory TextBlockFactory = new FrameworkElementFactory(typeof(TextBlock));
            if (i == 0) {
                TextBlockFactory.SetBinding(TextBlock.TextProperty, new Binding(Binding));
                //TextBlockFactory.SetValue(TextBlock.TextProperty, "123456");
           
            }
            else
            {
                TextBlockFactory.SetBinding(TextBlock.TextProperty, new Binding(Binding + "_" + i));
                //TextBlockFactory.SetValue(TextBlock.TextProperty, "1");
                TextBlockFactory.SetValue(TextBlock.VisibilityProperty, Visibility.Visible);
            }
            TextBlockFactory.SetValue(TextBlock.HorizontalAlignmentProperty, HorizontalAlignment.Center);
            TextBlockFactory.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
            stackPanelFactory.AppendChild(TextBlockFactory);
        }
        var template = new DataTemplate(typeof(DataRow));
        template.VisualTree = stackPanelFactory;
        column.CellTemplate = template;
        return column;
    }

    private string getFix(DataRow row,string fix){
        string result = "";
        result = row[fix].ToString().Replace("\\n","\r\n");
        return result;
    }
    /// <summary>
    /// 更新保存响应
    /// </summary>
    /// <param name="param"></param>
    public void SaveLevelConfig(object param)
    {
        try {
            string shapeId = jsonEntity.SHAPE_ID;
            string ruleId = jsonEntity.RULE_ID;
            if (jsonEntity != null)
            {
                // 按照形状名查询形状数据，判断是否有该数据
                string shapeSql = $"SELECT * FROM SHAPE WHERE SHAPE_ID = '{shapeId}';";
                DataTable shapes = DataBaseHelper.ExecuteQuery(shapeSql);

                DataBaseHelper.BeginTransaction();
                // 形状表判断是否有数据
                if (shapes == null || shapes.Rows.Count == 0)
                {
                    // 数据登录
                    string shapeInsertSql = $"INSERT INTO SHAPE (SHAPE_ID,SHAPE_NAME,SHAPE_EN_NAME,GUID)VALUES('{shapeId}','{jsonEntity.SHAPE_NAME}','{jsonEntity.SHAPE_EN_NAME}','{Guid.NewGuid().ToString()}');";
                    DataBaseHelper.ExecuteNonQuery(shapeInsertSql);
                }
                string ruleSql = $"SELECT * FROM RULE WHERE RULE_ID = '{ruleId}';";
                DataTable rule = DataBaseHelper.ExecuteQuery(ruleSql);
                if (rule == null || rule.Rows.Count == 0)
                {
                   
                    string ruleInsertSql = $"INSERT INTO RULE (RULE_ID,RULE_NAME,RULE_EN_NAME,GUID)VALUES('{ruleId}','{jsonEntity.RULE_NAME}','{jsonEntity.RULE_EN_NAME}','{Guid.NewGuid().ToString()}');";
                    DataBaseHelper.ExecuteNonQuery(ruleInsertSql);
                }
               
                // 定级数据登录
                string gradeInsSql = "";
                foreach (var gradeInfo in jsonEntity.gradeInfos)
                {
                    if (gradeInsSql.Length == 0)
                    {
                        gradeInsSql += gradeInfo.getDeleteSql();
                    }
                    gradeInsSql += gradeInfo.getInsertSql();
                }
                int count = DataBaseHelper.ExecuteNonQuery(gradeInsSql);
                if (count<0)
                {
                    DataBaseHelper.rollback();
                    Growl.Error(save_fail_message);
                }

                // 标准数据登录
                string gradeConfigSql = "";
                int index = 0;
                foreach (var gradeConfig in jsonEntity.GradeConfigs)
                {
                    if (index == 0)
                    {
                        gradeConfigSql += gradeConfig.getDeleteSql();
                    }
                    gradeConfigSql += gradeConfig.getInsertSql();
                    index++;
                }
                index = 0;
                foreach (var gradeConfigDetail in jsonEntity.GradeConfigDetails)
                {
                    if (index == 0)
                    {
                        gradeConfigSql += gradeConfigDetail.getDeleteSql(shapeId,ruleId);
                    }
                    gradeConfigSql += gradeConfigDetail.getInsertSql();
                    index++;
                }
                index = 0;
                foreach (var gradeConfigParameter in jsonEntity.GradeConfigParameters)
                {
                    if (index == 0)
                    {
                        gradeConfigSql += gradeConfigParameter.getDeleteSql(shapeId, ruleId);
                    }
                    gradeConfigSql += gradeConfigParameter.getInsertSql();
                    index++;
                }
                count = DataBaseHelper.ExecuteNonQuery(gradeConfigSql);
                if (count < 0)
                {
                    DataBaseHelper.rollback();
                    Growl.Error(save_fail_message);
                    return;
                }
                DataBaseHelper.commit();
                Growl.Info(Save_successful_message);
                InstitutesEnabled = true;
                ShapesEnabled = true;
                IsUpdateButtonEnabled = false;
            }
            else
            {
                Growl.ErrorGlobal(no_data_message);
            }
        }
        catch (Exception ex) {
            DataBaseHelper.rollback();
            Logger.Error($"全局异常捕获：{ex.Message}", ex);
            new MessageBox().Show($"{MultilingualHelper.getString("ApplicationError")}{ex.Message}");
        }
    }
    /// <summary>
    /// 删除配置响应
    /// </summary>
    /// <param name="param"></param>
    public void DelLevelConfig(object param)
    {
       
    }

    /// <summary>
    /// 导入配置响应
    /// </summary>
    /// <param name="param"></param>
    public void LoadLevelConfig(object param)
    {
        try
        {
          
            Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog();
            openFileDialog.Filter = "Text files (*.enc)|*.enc|All files (*.*)|*.*";
            jsonEntity = null;
            if (openFileDialog.ShowDialog() == true)
            {
                string filename = openFileDialog.FileName;
                string content = "";
                if (File.Exists(filename))
                {
                    try
                    {
                        content = AESHelper.DecryptFile(filename, "000000");
                        jsonEntity = JsonConvert.DeserializeObject<JsonEntity>(content);
                    }
                    catch (Exception ex)
                    {
                        new MessageBox().Show($"{MultilingualHelper.getString("LevelConfigFormatError")}");
                        Logger.Error($"全局异常捕获：{ex.Message}", ex);
                        return;
                    }
                }
            }
            else
            {
                InstitutesEnabled = true;
                ShapesEnabled = true;
                IsUpdateButtonEnabled = false;
                InitData();
                ChangeShapeModel("");
                return;
            }
            if (jsonEntity != null)
            {
                // 形状列表重新生成
                string shapeSql = $"SELECT * FROM SHAPE WHERE SHAPE_ID = '{jsonEntity.SHAPE_ID}';";
                DataTable shapes = DataBaseHelper.ExecuteQuery(shapeSql);
                if (shapes == null || shapes.Rows.Count == 0)
                {
                    var row = Shapes.NewRow();
                    row["SHAPE_ID"] = jsonEntity.SHAPE_ID;
                    row["SHAPE_NAME"] = jsonEntity.SHAPE_NAME;
                    row["SHAPE_EN_NAME"] = jsonEntity.SHAPE_EN_NAME;
                    Shapes.Rows.Add(row);
                    ShapeId = jsonEntity.SHAPE_ID;
                }
                else
                {
                    ShapeId = shapes.Rows[0]["SHAPE_ID"].ToString() ?? "";
                }

                // 机构列表重新生成
                string instituteSql = $"SELECT * FROM RULE WHERE RULE_ID = '{jsonEntity.RULE_ID}';";
                DataTable institute = DataBaseHelper.ExecuteQuery(instituteSql);
                if (institute == null || institute.Rows.Count == 0)
                {
                    var row = Institutes.NewRow();
                    row["RULE_ID"] = jsonEntity.RULE_ID;
                    row["RULE_NAME"] = jsonEntity.RULE_NAME;
                    row["RULE_EN_NAME"] = jsonEntity.RULE_EN_NAME;
                    Institutes.Rows.Add(row);
                    InstituteId = jsonEntity.RULE_ID;
                }
                else
                {
                    InstituteId = institute.Rows[0]["RULE_ID"].ToString() ?? "";
                }
                // 表格内容重新生成
                string gradeInfosJson = JsonConvert.SerializeObject(jsonEntity.gradeInfos);
                DataTable gradeInfos = Common.JsonToDataTable(gradeInfosJson);
                string standardInfosJson = JsonConvert.SerializeObject(jsonEntity.standardInfos);
                DataTable standardInfos = Common.JsonToDataTable(standardInfosJson);
                setStandardList(gradeInfos, standardInfos);
                InstitutesEnabled = false;
                ShapesEnabled = false;
                IsUpdateButtonEnabled = true;
            }
            else
            {
                new MessageBox().Show($"{MultilingualHelper.getString("LevelConfigFormatError")}");
                InstitutesEnabled = true;
                ShapesEnabled = true;
                IsUpdateButtonEnabled = false;
                return;
            }
        }
        catch (Exception ex)
        {
            new MessageBox().Show($"{MultilingualHelper.getString("ApplicationError")}{ex.Message}");
            Logger.Error($"全局异常捕获：{ex.Message}", ex);
        }
    }

    /// <summary>
    /// 切换规则响应
    /// </summary>
    /// <param name="param"></param>
    public void ChangeInstituteModel(object param)
    {
        if (InstituteId != null && InstituteId != string.Empty)
        {
            dataGrid.Columns.Clear();
            setDataGrid(ShapeId, InstituteId);
        }
    }

    /// <summary>
    /// 切换形状响应
    /// </summary>
    /// <param name="param"></param>
    public void ChangeShapeModel(object param)
    {
        if (ShapeId!= null && ShapeId != string.Empty) { 
           InstituteId = setInstitutes(ShapeId);
        }
    }

    //class GradeInfo
    //{
    //    public int GRADE_ID { get; set; }
    //    public string GRADE_NAME { get; set; }
    //    public string GRADE_EN_NAME { get; set; }
    //    public string GRADE_EN_S_NAME { get; set; }
    //    public int GRADE_ORDER { get; set; }

    //    public string getInsertSql(string shapeId,string instituteId)
    //    {
    //        string insertSql = "INSERT INTO GRADE(";
    //        insertSql = insertSql +
    //            "SHAPE_ID" +
    //            ",INSTITUTE_ID" +
    //            ",GRADE_ID" +
    //            ",GRADE_NAME" +
    //            ",GRADE_EN_NAME" +
    //            ",GRADE_EN_S_NAME" +
    //            ",GRADE_ORDER" +
    //            ",GUID";
    //        insertSql = insertSql + ")VALUES(";
    //        insertSql = insertSql +
    //            $"'{shapeId}'" +
    //            $",'{instituteId}'" +
    //            $",'{GRADE_ID}'" +
    //            $",'{GRADE_NAME}'" +
    //            $",'{GRADE_EN_NAME}'" +
    //            $",'{GRADE_EN_S_NAME}'" +
    //            $",'{GRADE_ORDER}'" +
    //            $",'{Guid.NewGuid().ToString()}'";

    //        insertSql = insertSql + ");";
    //        return insertSql;
    //    }
    //    public string getDeleteSql(string shapeId, string instituteId)
    //    {
    //        string deleteSql = $"DELETE FROM GRADE WHERE SHAPE_ID='{shapeId}' AND INSTITUTE_ID='{instituteId}';";
    //        return deleteSql;
    //    }

    //}

    //class StandardInfo
    //{
    //    public int GRADE_ID { get; set; }
    //    public int STANDARD_ID { get; set; }
    //    public string STANDARD_NAME { get; set; }
    //    public string STANDARD_EN_NAME { get; set; }
    //    public decimal? STANDARD_MIN { get; set; }
    //    public decimal? STANDARD_MAX { get; set; }
    //    public string IS_MIN_EXIST { get; set; } = "0";
    //    public string IS_MAX_EXIST { get; set; } = "0";
    //    public string UNIT { get; set; }
    //    public string MIN_PREFIX { get; set; }
    //    public string MIN_SUFFIX { get; set; }
    //    public string MAX_PREFIX { get; set; }
    //    public string MAX_SUFFIX { get; set; }
    //    public string MIN_NULL_REPALCE { get; set; } = "←";
    //    public string MAX_NULL_REPALCE { get; set; } = "→";
    //    public int SORT { get; set; }
    //    public string getInsertSql(string shapeId, string instituteId)
    //    {
    //        string insertSql = "INSERT INTO STANDARD(";
    //        insertSql = insertSql +
    //                    "STANDARD_ID      " +
    //                    ",SHAPE_ID         " +
    //                    ",GRADE_ID         " +
    //                    ",INSTITUTE_ID     " +
    //                    ",STANDARD_NAME    " +
    //                    ",STANDARD_EN_NAME " +
    //                    ",STANDARD_MIN     " +
    //                    ",STANDARD_MAX     " +
    //                    ",IS_MIN_EXIST     " +
    //                    ",IS_MAX_EXIST     " +
    //                    ",SORT             " +
    //                    ",UNIT             " +
    //                    ",MAX_NULL_REPALCE " +
    //                    ",MIN_PREFIX       " +
    //                    ",MIN_SUFFIX       " +
    //                    ",MAX_PREFIX       " +
    //                    ",MAX_SUFFIX       " +
    //                    ",MIN_NULL_REPALCE " +
    //                    ",GUID             " ;
    //        insertSql = insertSql + ")VALUES(";
    //        insertSql = insertSql +
    //            $"'{STANDARD_ID}'" +
    //            $",'{shapeId}'" +
    //            $",'{GRADE_ID}'" +
    //            $",'{instituteId}'" +
    //            $",'{STANDARD_NAME}'" +
    //            $",'{STANDARD_EN_NAME}'" +
    //            $",{(STANDARD_MIN != null ? STANDARD_MIN.ToString() : "null")}" +
    //            $",{(STANDARD_MAX != null ? STANDARD_MAX.ToString() : "null")}" +
    //            $",'{IS_MIN_EXIST}'" +
    //            $",'{IS_MAX_EXIST}'" +
    //            $",'{SORT}'" +
    //            $",'{UNIT}'" +
    //            $",'{MAX_NULL_REPALCE}'" +
    //            $",'{MIN_PREFIX}'" +
    //            $",'{MIN_SUFFIX}'" +
    //            $",'{MAX_PREFIX}'" +
    //            $",'{MAX_SUFFIX}'" +
    //            $",'{MIN_NULL_REPALCE}'" +
    //            $",'{Guid.NewGuid().ToString()}'";

    //        insertSql = insertSql + ");";
    //        return insertSql;
    //    }

    //    public string getDeleteSql(string shapeId, string instituteId)
    //    {
    //        string deleteSql = $"DELETE FROM STANDARD WHERE SHAPE_ID='{shapeId}' AND INSTITUTE_ID='{instituteId}';";
    //        return deleteSql;
    //    }
    //}
}