using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using DevExpress.XtraGrid.Columns;
using DevExpress.XtraGrid.Views.Grid;
using DevExpress.XtraTreeList;
using DevExpress.XtraTreeList.Nodes;
using Lskj.Business;
using Lskj.Business.Impl;
using Lskj.Control;
using Lskj.Control.Model;
using Lskj.Core;
using Lskj.Main.Model;
using Lskj.Model;
using Lskj.Util;

namespace Lskj.PubCodeDesign
{
    public partial class FrmMain : Form
    {
        private const string NodeTypeMenu = "menu";
        private const string NodeTypeScheme = "scheme";
        private const string ExecTypeView = "0";
        private const string ExecTypeDesign = "1";
        private const int MenuStructStepLength = 2;
        private const int LeafTreeLevel = 3;
        private const int MaxMenuStructLevel = 2;
        private const int DesignFieldControlWidth = 160;
        private const int DesignFieldControlHeight = 28;
        private const string SplitRootLocationKeyFormat = "code_design_left_width_{0}";
        private const string SchemeTableName = "P_CodeSchemeTab";
        private const string SchemeControlTableName = "P_CodeSchemeControlTab";
        private const string CodeRecordTableName = "P_CodeSchemeRecordTab";
        private const string CodeGenerateProcedureName = "P_create_CodeSchemeDocumentPr";
        private const string NumberRuleTableName = "p_systemNumberRuleTab";
        private const string DesignRuleUseColumn = "UseEd";
        private const string DesignRuleSortColumn = "SortNo";
        private const string DesignRuleUserNameColumn = "UserName";
        private const string DesignRuleFieldNameColumn = "FieldName";
        private const string DesignRuleFieldTypeColumn = "FieldTypeId";
        private const string NumberRuleSchemeIdColumn = "SchemeId";
        private const string NumberRuleSchemeCodeColumn = "SchemeCode";
        private const string NumberRuleSchemeNameColumn = "SchemeName";
        private const string NumberRuleMenuKeyColumn = "MenuKey";
        private const string NumberRuleBindModuleColumn = "BindModule";
        private const string NumberRuleBindModuleCodeColumn = "BindModuleCode";
        private const string NumberRuleModIdColumn = "modid";
        private const string NumberRuleSourceTableProperty = "NumberRuleSourceTable";

        public DynamicCodeDesign Model; // 动态编码设计对象

        private DataTable _allMenus = new DataTable();
        private DataTable _fieldConfigTable = new DataTable();
        private DataTable _designRuleTable = new DataTable();
        private DataTable _moduleLeftSourceTable = new DataTable();
        private readonly List<FieldDesignItem> _viewSchemeItems = new List<FieldDesignItem>();
        private DataRow _moduleLeftSourceRow;
        private DataRow _menuTreeSourceRow;
        private string _menuTreeKeyField;
        private string _menuTreeTextField;
        private string _menuTreeNodeLength;
        private string _menuSql;
        private string _currentSchemeKey;
        private TreeListNode _currentSchemeNode;
        private int _treeIconSerial;
        private bool _loadingSplitLocation;
        private bool _currentSchemeDirty;
        private bool _loadingSchemeEditor;
        private bool _loadingBindControls;
        private bool _loadingDesignRuleGrid;
        private bool _restoringFocusedNode;
        private bool _suppressNextFocusPrompt;
        private bool _numberRuleGridInitialized;
        private string _numberRuleGridModuleCode;
        private MyControl _viewControlObj;

        public FrmMain()
        {
            InitializeComponent();
            InitializeRuntimeEvents();
            this.Load += OnFrmMainLoad;
        }

        private void OnFrmMainLoad(object sender, EventArgs e)
        {
            CodeSchemeStorage.EnsureCodeSchemeStorage();
            InitlizeSpiltLocation();
            LoadTreeIcons();
            LoadMenuTree();
            InitializeNumberRuleGridWithPrompt();
            ApplyExecMode();
        }

        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            CommitDesignRuleGridEditor();
            bool canClose = ConfirmAbandonCurrentSchemeChanges();
            SetMainModuleCloseState(canClose);

            if (!canClose)
            {
                e.Cancel = true;
                return;
            }

            base.OnFormClosing(e);
        }

        private void SetMainModuleCloseState(bool isClose)
        {
            string guid = this.Tag + "";
            if (string.IsNullOrWhiteSpace(guid)) return;

            try
            {
                if (Manager.ModuleForms.ContainsKey(guid))
                {
                    Manager.ModuleForms[guid].IsClose = isClose;
                }
            }
            catch
            {
            }
        }

        private void InitializeRuntimeEvents()
        {
            this.splitRoot.SplitterMoved += OnSplitterMoved;
            this.treeMenu.MouseDown += OnTreeMenuMouseDown;
            this.treeMenu.BeforeFocusNode += OnTreeMenuBeforeFocusNode;
            this.treeMenu.FocusedNodeChanged += OnTreeMenuFocusedNodeChanged;
            this.menuAddScheme.Click += OnAddSchemeClick;
            this.btnDeleteScheme.Click += OnDeleteSchemeClick;
            this.btnGenerateCode.Click += OnGenerateCodeClick;
            this.btnAddLogic.Click += OnAddLogicClick;
            this.btnDeleteLogic.Click += OnDeleteLogicClick;
            this.btnSave.Click += OnSaveSchemeClick;
            this.txtSchemeName.KeyDown += OnSchemeNameKeyDown;
            this.txtSchemeName.EditValueChanged += OnSchemeNameChanged;
            this.pl_buttom.Resize += OnBottomPanelResize;

            InitializeDesignRuleGridControl();
            InitializeBindModuleEvents();
            LayoutBottomButtons();

            SetSchemeEditor(null);
        }

        private bool IsViewMode()
        {
            string execType = this.Model == null ? ExecTypeDesign : (this.Model.ExecType + "").Trim();
            return string.Equals(execType, ExecTypeView, StringComparison.OrdinalIgnoreCase);
        }

        private bool IsDesignMode()
        {
            return !IsViewMode();
        }

        private void ApplyExecMode()
        {
            bool designMode = IsDesignMode();

            this.menuAddScheme.Visible = designMode;
            this.cmsMenuTree.Enabled = designMode;
            this.btnDeleteScheme.Visible = designMode;
            this.btnGenerateCode.Visible = !designMode;
            this.btnAddLogic.Visible = designMode;
            this.btnDeleteLogic.Visible = designMode;
            this.btnSave.Visible = designMode;
            this.pl_buttom.Visible = designMode;
            this.pnlDesignWork.Visible = true;
            this.pnlViewWork.Visible = false;
            this.lblCodePreview.Visible = !designMode;
            this.txtCodePreview.Visible = !designMode;
            this.txtCodePreview.Properties.ReadOnly = true;

            SetSchemeEditor(this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData);
            ApplyDesignRuleGridEditState();
        }

        private void InitializeDesignRuleGridControl()
        {
            this.gridDesignRules.VisibleOperPanel = false;
            this.gridDesignRules.VisibleSearchPanel = true;
            this.gridDesignRules.HideTopToolPanel();
        }

        private void OnBottomPanelResize(object sender, EventArgs e)
        {
            LayoutBottomButtons();
        }

        private void LayoutBottomButtons()
        {
            if (this.pl_buttom == null || this.btnAddLogic == null || this.btnDeleteLogic == null || this.btnSave == null) return;

            const int marginRight = 8;
            const int gap = 6;
            int top = Math.Max(4, (this.pl_buttom.Height - this.btnSave.Height) / 2);

            this.btnSave.Top = top;
            this.btnDeleteLogic.Top = top;
            this.btnAddLogic.Top = top;

            this.btnSave.Left = Math.Max(6, this.pl_buttom.ClientSize.Width - marginRight - this.btnSave.Width);
            this.btnDeleteLogic.Left = this.btnSave.Left - gap - this.btnDeleteLogic.Width;
            this.btnAddLogic.Left = this.btnDeleteLogic.Left - gap - this.btnAddLogic.Width;

            if (this.btnAddLogic.Left < 6)
            {
                this.btnAddLogic.Left = 6;
                this.btnDeleteLogic.Left = this.btnAddLogic.Right + gap;
                this.btnSave.Left = this.btnDeleteLogic.Right + gap;
            }
        }

        private GridControlEx DesignRuleGrid
        {
            get { return this.gridDesignRules == null ? null : this.gridDesignRules.GridControlObj; }
        }

        private void InitializeBindModuleEvents()
        {
            this.chkBindModule.CheckedChanged += OnBindModuleCheckedChanged;
            this.cboBindLevel1.SelectedIndexChanged += OnBindLevel1Changed;
            this.cboBindLevel2.SelectedIndexChanged += OnBindLevel2Changed;
            this.cboBindLevel3.SelectedIndexChanged += OnBindLevel3Changed;
        }

        private void InitlizeSpiltLocation()
        {
            this._loadingSplitLocation = true;
            try
            {
                ApplySavedSplitLocation(this.splitRoot, GetSplitLocationKey(SplitRootLocationKeyFormat));
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
            finally
            {
                this._loadingSplitLocation = false;
            }
        }

        private void ApplySavedSplitLocation(DevExpress.XtraEditors.SplitContainerControl splitControl, string key)
        {
            if (splitControl == null || string.IsNullOrWhiteSpace(key)) return;

            string value = IniHelper.Read(key);
            int splitterPosition;
            if (!int.TryParse(value, out splitterPosition) || splitterPosition <= 0) return;

            splitControl.SplitterPosition = NormalizeSplitterPosition(splitControl, splitterPosition);
        }

        private void OnSplitterMoved(object sender, EventArgs e)
        {
            if (this._loadingSplitLocation) return;

            try
            {
                if (sender == this.splitRoot)
                {
                    IniHelper.Write(GetSplitLocationKey(SplitRootLocationKeyFormat), this.splitRoot.SplitterPosition + "");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
        }

        private int NormalizeSplitterPosition(DevExpress.XtraEditors.SplitContainerControl splitControl, int splitterPosition)
        {
            if (splitControl == null) return splitterPosition;

            int length = Math.Max(splitControl.Width, splitControl.Height);
            if (length <= 0) return splitterPosition;

            const int minPanelLength = 80;
            int maxPosition = Math.Max(minPanelLength, length - minPanelLength);
            return Math.Max(minPanelLength, Math.Min(maxPosition, splitterPosition));
        }

        private string GetSplitLocationKey(string keyFormat)
        {
            return string.Format(keyFormat, GetSplitLocationModuleCode());
        }

        private string GetSplitLocationModuleCode()
        {
            if (this.Model != null && !string.IsNullOrWhiteSpace(this.Model.ModuleCode))
            {
                return this.Model.ModuleCode;
            }
            return "Lskj.PubCodeDesign";
        }

        private void LoadTreeIcons()
        {
            this.imgMenuTree.Images.Clear();
            string iconPath = PubUtil.MainTreeviewImagePath;
            if (Directory.Exists(iconPath))
            {
                string[] files = Directory.GetFiles(iconPath, "*.png").OrderBy(n => n).ToArray();
                foreach (string file in files)
                {
                    using (Image image = ImageHelper.ReadImage(file))
                    {
                        if (image != null)
                        {
                            this.imgMenuTree.Images.Add(new Bitmap(image));
                        }
                    }
                }
            }

            if (this.imgMenuTree.Images.Count == 0)
            {
                this.imgMenuTree.Images.Add(new Bitmap(18, 18));
            }
        }

        private int GetNextTreeIconIndex()
        {
            int iconCount = this.imgMenuTree.Images.Count;
            if (iconCount == 0) return 0;

            int iconIndex = Math.Abs(this._treeIconSerial) % iconCount;
            this._treeIconSerial++;
            return iconIndex;
        }

        private void LoadMenuTree()
        {
            this.treeMenu.BeginUpdate();
            try
            {
                this.treeMenu.Nodes.Clear();
                this._treeIconSerial = 0;
                LoadBindMenuSource();

                DataTable speciesTreeTable = LoadSpeciesTreeTable();
                BindSpeciesTree(speciesTreeTable);
                LoadBindLevel1Items(null);

                if (this.treeMenu.Nodes.Count > 0)
                {
                    this.treeMenu.CollapseAll();
                    this.lblDesignerStatus.Text = "右键编码分类可添加方案";
                }
                else
                {
                    this.lblDesignerStatus.Text = "未获取到可展示的编码分类数据";
                }
            }
            catch (Exception ex)
            {
                this.lblDesignerStatus.Text = "编码分类加载失败";
                MessageUtil.Show("编码分类加载失败：" + ex.Message);
            }
            finally
            {
                this.treeMenu.EndUpdate();
            }
        }

        private void BindMenuTree(DataTable menuTable, List<DataRow> topSubSystems)
        {
            if (menuTable == null || menuTable.Rows.Count == 0 || !menuTable.Columns.Contains("MenuStruct")) return;
            if (topSubSystems == null || topSubSystems.Count == 0) return;

            HashSet<string> visibleSubSysIds = new HashSet<string>(topSubSystems.Select(n => n["SubSysId"] + ""));

            List<DataRow> rows = menuTable.Rows.Cast<DataRow>()
                .Where(IsMenuTreeRow)
                .Where(n => visibleSubSysIds.Contains(GetRowValue(n, "SubSysId")))
                .OrderBy(n => GetTopSubSystemSortIndex(topSubSystems, GetRowValue(n, "SubSysId")))
                .ThenBy(n => n["MenuStruct"] + "")
                .ThenBy(n => n.Table.Columns.Contains("MenuId") ? n["MenuId"] + "" : "")
                .ToList();

            Dictionary<string, TreeListNode> nodeMap = new Dictionary<string, TreeListNode>();

            foreach (DataRow subSystemRow in topSubSystems)
            {
                string topNodeKey = GetTopNodeKey(subSystemRow);
                if (nodeMap.ContainsKey(topNodeKey)) continue;

                TreeListNode topNode = AppendTreeNode(null, GetTopNodeText(subSystemRow), new TreeNodeData
                {
                    NodeType = NodeTypeMenu,
                    MenuKey = topNodeKey,
                    MenuLevel = 1
                }, GetNextTreeIconIndex());
                nodeMap.Add(topNodeKey, topNode);
            }

            foreach (DataRow row in rows.Where(n => GetMenuLevel(n["MenuStruct"] + "") == 1))
            {
                string nodeKey = GetMenuNodeKey(row);
                if (nodeMap.ContainsKey(nodeKey)) continue;

                TreeListNode node = AppendTreeNode(nodeMap[GetTopNodeKey(row)], GetMenuNodeText(row), new TreeNodeData
                {
                    NodeType = NodeTypeMenu,
                    MenuKey = nodeKey,
                    MenuLevel = 2,
                    MenuRow = row
                }, GetNextTreeIconIndex());
                nodeMap.Add(nodeKey, node);
            }

            foreach (DataRow row in rows.Where(n => GetMenuLevel(n["MenuStruct"] + "") == MaxMenuStructLevel))
            {
                string nodeKey = GetMenuNodeKey(row);
                string parentKey = GetMenuParentNodeKey(row);
                if (nodeMap.ContainsKey(nodeKey) || string.IsNullOrEmpty(parentKey) || !nodeMap.ContainsKey(parentKey)) continue;

                TreeListNode node = AppendTreeNode(nodeMap[parentKey], GetMenuNodeText(row), new TreeNodeData
                {
                    NodeType = NodeTypeMenu,
                    MenuKey = nodeKey,
                    MenuLevel = LeafTreeLevel,
                    MenuRow = row
                }, GetNextTreeIconIndex());
                nodeMap.Add(nodeKey, node);
            }

            AppendCodeSchemeNodes(nodeMap);
        }

        private void AppendCodeSchemeNodes(Dictionary<string, TreeListNode> nodeMap)
        {
            if (nodeMap == null || nodeMap.Count == 0) return;

            DataTable table = GetCodeSchemes();
            int schemeIconIndex = Math.Min(3, this.imgMenuTree.Images.Count - 1);
            foreach (DataRow row in table.Rows)
            {
                string menuKey = row["MenuKey"] + "";
                if (!nodeMap.ContainsKey(menuKey)) continue;

                TreeListNode menuNode = nodeMap[menuKey];
                TreeNodeData menuData = menuNode.Tag as TreeNodeData;
                TreeListNode schemeNode = AppendTreeNode(menuNode, row["SchemeName"] + "", new TreeNodeData
                {
                    NodeType = NodeTypeScheme,
                    MenuKey = menuKey,
                    MenuRow = menuData == null ? null : menuData.MenuRow,
                    MenuCaption = menuData == null ? string.Empty : menuData.MenuCaption,
                    ModuleCode = menuData == null ? string.Empty : menuData.ModuleCode,
                    SchemeId = ToInt(row["SchemeId"]),
                    SchemeCode = row["SchemeCode"] + "",
                    SchemeName = row["SchemeName"] + "",
                    BindModule = ToBool(GetRowValue(row, "BindModule")),
                    BindSubSysId = GetRowValue(row, "BindSubSysId"),
                    BindMenuStruct1 = GetRowValue(row, "BindMenuStruct1"),
                    BindMenuStruct2 = GetRowValue(row, "BindMenuStruct2"),
                    BindMenuId = GetRowValue(row, "BindMenuId"),
                    BindModuleCode = GetRowValue(row, "BindModuleCode")
                }, schemeIconIndex);
            }
        }

        private TreeListNode AppendTreeNode(TreeListNode parentNode, string text, TreeNodeData nodeData, int iconIndex)
        {
            TreeListNode node = this.treeMenu.AppendNode(new object[] { text }, parentNode);
            node.Tag = nodeData;
            node.ImageIndex = iconIndex;
            node.SelectImageIndex = iconIndex;
            return node;
        }

        private List<DataRow> GetVisibleTopSubSystems(DataTable menuTable)
        {
            List<DataRow> result = new List<DataRow>();
            if (menuTable == null || menuTable.Rows.Count == 0) return result;

            string where = string.IsNullOrEmpty(ERPInfo.Instance.SeriesId) ? "" : string.Format("and SeriesId={0}", ERPInfo.Instance.SeriesId);
            DataTable subSystems = MainImpl.GetSubSystems(where);
            if (LanguageTranslation.Translatable)
            {
                subSystems = LanguageTranslation.TranslationTableColumn(subSystems, "SubSysName");
            }

            foreach (DataRow subSystemRow in subSystems.Rows)
            {
                if (!string.Equals(GetRowValue(subSystemRow, "UseEd"), "True", StringComparison.OrdinalIgnoreCase)) continue;

                string subSysId = GetRowValue(subSystemRow, "SubSysId");
                if (string.IsNullOrWhiteSpace(subSysId)) continue;
                if (HasVisibleMenu(menuTable, subSysId))
                {
                    result.Add(subSystemRow);
                }
            }
            return result;
        }

        private bool HasVisibleMenu(DataTable menuTable, string subSysId)
        {
            List<DataRow> parentMenus = menuTable.Rows.Cast<DataRow>()
                .Where(IsMenuTreeRow)
                .Where(n => GetMenuLevel(n["MenuStruct"] + "") == 1)
                .Where(n => string.Equals(GetRowValue(n, "SubSysId"), subSysId, StringComparison.OrdinalIgnoreCase))
                .Where(n => !IsSplitBarMenu(n))
                .ToList();

            foreach (DataRow parentMenu in parentMenus)
            {
                string menuStruct = parentMenu["MenuStruct"] + "";
                bool hasChild = menuTable.Rows.Cast<DataRow>()
                    .Where(IsMenuTreeRow)
                    .Any(n => GetMenuLevel(n["MenuStruct"] + "") == MaxMenuStructLevel
                        && string.Equals(GetRowValue(n, "SubSysId"), subSysId, StringComparison.OrdinalIgnoreCase)
                        && (n["MenuStruct"] + "").StartsWith(menuStruct)
                        && !IsSplitBarMenu(n)
                        && !string.IsNullOrWhiteSpace(GetRowValue(n, "DllFileName")));
                if (hasChild) return true;
            }
            return false;
        }

        private bool IsSplitBarMenu(DataRow row)
        {
            string splitBar = SystemInfo.Instance.SplitBar;
            return !string.IsNullOrWhiteSpace(splitBar) && GetMenuNodeText(row).StartsWith(splitBar);
        }

        private int GetTopSubSystemSortIndex(List<DataRow> topSubSystems, string subSysId)
        {
            for (int i = 0; i < topSubSystems.Count; i++)
            {
                if (string.Equals(GetRowValue(topSubSystems[i], "SubSysId"), subSysId, StringComparison.OrdinalIgnoreCase))
                {
                    return i;
                }
            }
            return int.MaxValue;
        }

        private bool IsMenuTreeRow(DataRow row)
        {
            if (row == null || !row.Table.Columns.Contains("MenuStruct")) return false;

            string menuStruct = row["MenuStruct"] + "";
            if (string.IsNullOrWhiteSpace(menuStruct)) return false;
            if (menuStruct.Length % MenuStructStepLength != 0) return false;

            int level = GetMenuLevel(menuStruct);
            return level > 0 && level <= MaxMenuStructLevel;
        }

        private int GetMenuLevel(string menuStruct)
        {
            return string.IsNullOrEmpty(menuStruct) ? 0 : menuStruct.Length / MenuStructStepLength;
        }

        private string GetMenuNodeKey(DataRow row)
        {
            string subSysId = GetRowValue(row, "SubSysId");
            string nodeKey = string.Format("{0}|{1}", subSysId, row["MenuStruct"]);
            if (GetMenuLevel(row["MenuStruct"] + "") == MaxMenuStructLevel)
            {
                string menuId = GetRowValue(row, "MenuId");
                if (!string.IsNullOrWhiteSpace(menuId))
                {
                    nodeKey = string.Format("{0}|{1}", nodeKey, menuId);
                }
            }
            return nodeKey;
        }

        private string GetTopNodeKey(DataRow row)
        {
            string subSysId = GetRowValue(row, "SubSysId");
            return "top|" + subSysId;
        }

        private string GetMenuParentNodeKey(DataRow row)
        {
            string menuStruct = row["MenuStruct"] + "";
            if (menuStruct.Length <= MenuStructStepLength) return GetTopNodeKey(row);

            string parentStruct = menuStruct.Substring(0, menuStruct.Length - MenuStructStepLength);
            string subSysId = GetRowValue(row, "SubSysId");
            return string.Format("{0}|{1}", subSysId, parentStruct);
        }

        private string GetTopNodeText(DataRow row)
        {
            string subSysName = GetRowValue(row, "SubSysName");
            if (!string.IsNullOrWhiteSpace(subSysName)) return subSysName;

            string subSysId = GetRowValue(row, "SubSysId");
            return string.IsNullOrWhiteSpace(subSysId) ? "主菜单" : subSysId;
        }

        private string GetMenuNodeText(DataRow row)
        {
            string caption = GetRowValue(row, "MenuCaption");
            if (string.IsNullOrWhiteSpace(caption))
            {
                caption = GetRowValue(row, "SearchMenuCaption");
            }
            if (string.IsNullOrWhiteSpace(caption))
            {
                caption = row["MenuStruct"] + "";
            }
            return caption;
        }

        private string GetRowValue(DataRow row, string columnName)
        {
            if (row == null || row.Table == null || !row.Table.Columns.Contains(columnName)) return string.Empty;
            return row[columnName] + "";
        }

        private DataTable GetCodeSchemes()
        {
            string sql = "SELECT * FROM P_CodeSchemeTab ORDER BY MenuKey, SchemeId";
            return SqlHelper.ExecuteDataTable(sql);
        }

        private DataTable GetSchemeControls(int schemeId)
        {
            string sql = string.Format("SELECT * FROM {0} WHERE {1} = @SchemeId{2}",
                CodeSchemeStorage.QuoteSqlIdentifier(SchemeControlTableName),
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn),
                GetNumberRuleOrderByClause(SchemeControlTableName));
            return SqlHelper.ExecuteDataTable(sql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
        }

        private TreeNodeData CreatePendingCodeScheme(TreeNodeData menuData, string schemeName)
        {
            if (menuData == null || menuData.MenuRow == null) return null;

            string schemeCode = "CD" + Guid.NewGuid().ToString("N");
            return new TreeNodeData
            {
                NodeType = NodeTypeScheme,
                MenuKey = menuData.MenuKey,
                MenuRow = menuData.MenuRow,
                MenuCaption = menuData.MenuCaption,
                ModuleCode = menuData.ModuleCode,
                SchemeId = 0,
                SchemeCode = schemeCode,
                SchemeName = schemeName,
                BindModule = false
            };
        }

        private int InsertCodeScheme(TreeNodeData nodeData, string schemeName)
        {
            if (nodeData == null || nodeData.MenuRow == null) return 0;

            string schemeCode = string.IsNullOrWhiteSpace(nodeData.SchemeCode) ? "CD" + Guid.NewGuid().ToString("N") : nodeData.SchemeCode;
            ApplyBindModuleToNodeData(nodeData);
            string moduleCode = GetMenuModuleCode(nodeData);
            string sql = @"INSERT INTO P_CodeSchemeTab
(SchemeCode, SchemeName, MenuKey, SubSysId, MenuId, MenuStruct, MenuCaption, ModuleCode, BindModule, BindSubSysId, BindMenuStruct1, BindMenuStruct2, BindMenuId, BindModuleCode, IsDefault, CreateUserId, CreateUserName, CreateTime)
VALUES
(@SchemeCode, @SchemeName, @MenuKey, @SubSysId, @MenuId, @MenuStruct, @MenuCaption, @ModuleCode, @BindModule, @BindSubSysId, @BindMenuStruct1, @BindMenuStruct2, @BindMenuId, @BindModuleCode, 0, @CreateUserId, @CreateUserName, GETDATE());
SELECT CAST(SCOPE_IDENTITY() AS INT);";
            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[]
            {
                new SqlParameter("@SchemeCode", schemeCode),
                new SqlParameter("@SchemeName", schemeName),
                new SqlParameter("@MenuKey", nodeData.MenuKey),
                new SqlParameter("@SubSysId", GetRowValue(nodeData.MenuRow, "SubSysId")),
                new SqlParameter("@MenuId", GetRowValue(nodeData.MenuRow, "MenuId")),
                new SqlParameter("@MenuStruct", GetRowValue(nodeData.MenuRow, "MenuStruct")),
                new SqlParameter("@MenuCaption", GetTreeNodeCaption(nodeData)),
                new SqlParameter("@ModuleCode", moduleCode),
                new SqlParameter("@BindModule", nodeData.BindModule),
                new SqlParameter("@BindSubSysId", GetDbValue(nodeData.BindSubSysId)),
                new SqlParameter("@BindMenuStruct1", GetDbValue(nodeData.BindMenuStruct1)),
                new SqlParameter("@BindMenuStruct2", GetDbValue(nodeData.BindMenuStruct2)),
                new SqlParameter("@BindMenuId", GetDbValue(nodeData.BindMenuId)),
                new SqlParameter("@BindModuleCode", GetDbValue(nodeData.BindModuleCode)),
                new SqlParameter("@CreateUserId", ERPInfo.Instance.UserId),
                new SqlParameter("@CreateUserName", ERPInfo.Instance.UserName)
            });

            nodeData.SchemeCode = schemeCode;
            return ToInt(result);
        }

        private void DeleteCodeScheme(TreeNodeData nodeData)
        {
            int schemeId = nodeData == null ? 0 : nodeData.SchemeId;
            if (schemeId <= 0) return;

            string bindModuleCode = nodeData.BindModule ? nodeData.BindModuleCode : string.Empty;
            DeleteCodeSchemeData(schemeId, bindModuleCode);
        }

        private void DeleteCodeSchemeData(int schemeId, string bindModuleCode)
        {
            if (schemeId <= 0) return;

            DeleteRuleRows(SchemeControlTableName, schemeId);
            if (!string.IsNullOrWhiteSpace(bindModuleCode))
            {
                DeleteBindModuleNumberRuleRows(bindModuleCode);
            }

            string sql = "DELETE FROM P_CodeSchemeTab WHERE SchemeId = @SchemeId";
            SqlHelper.ExecuteNonQuery(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
        }

        private void DeleteDisabledCodeSchemes()
        {
            if (!CodeSchemeStorage.TableExists(SchemeTableName) || !CodeSchemeStorage.ColumnExists(SchemeTableName, DesignRuleUseColumn)) return;

            string sql = "SELECT SchemeId, BindModule, BindModuleCode FROM P_CodeSchemeTab WHERE ISNULL(UseEd, 1) = 0";
            DataTable table = SqlHelper.ExecuteDataTable(sql);
            if (table == null || table.Rows.Count == 0) return;

            foreach (DataRow row in table.Rows)
            {
                int schemeId = ToInt(row["SchemeId"]);
                string bindModuleCode = ToBool(row["BindModule"]) ? row["BindModuleCode"] + "" : string.Empty;

                DeleteRuleRows(SchemeControlTableName, schemeId);
                if (!string.IsNullOrWhiteSpace(bindModuleCode) && !BindModuleOwnedByEnabledScheme(bindModuleCode))
                {
                    DeleteBindModuleNumberRuleRows(bindModuleCode);
                }

                string deleteSql = "DELETE FROM P_CodeSchemeTab WHERE SchemeId = @SchemeId";
                SqlHelper.ExecuteNonQuery(CommandType.Text, deleteSql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
            }
        }

        private bool BindModuleOwnedByEnabledScheme(string bindModuleCode)
        {
            if (string.IsNullOrWhiteSpace(bindModuleCode) || !CodeSchemeStorage.TableExists(SchemeTableName) || !CodeSchemeStorage.ColumnExists(SchemeTableName, DesignRuleUseColumn)) return false;

            string sql = @"
SELECT COUNT(1)
FROM P_CodeSchemeTab
WHERE ISNULL(UseEd, 1) = 1
  AND ISNULL(BindModule, 0) = 1
  AND ISNULL(BindModuleCode, '') = @BindModuleCode";
            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@BindModuleCode", bindModuleCode) });
            return ToInt(result) > 0;
        }

        private string GetNextSchemeName(string menuKey)
        {
            int serial = 1;
            while (true)
            {
                string schemeName = "方案" + serial;
                string sql = "SELECT COUNT(1) FROM P_CodeSchemeTab WHERE MenuKey = @MenuKey AND SchemeName = @SchemeName";
                object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[]
                {
                    new SqlParameter("@MenuKey", menuKey),
                    new SqlParameter("@SchemeName", schemeName)
                });
                if (Convert.ToInt32(result) == 0 && !SchemeNameExistsInTree(menuKey, schemeName)) return schemeName;
                serial++;
            }
        }

        private bool SchemeNameExistsInTree(string menuKey, string schemeName)
        {
            foreach (TreeListNode node in this.treeMenu.Nodes)
            {
                if (SchemeNameExistsInTreeNode(node, menuKey, schemeName))
                {
                    return true;
                }
            }
            return false;
        }

        private bool SchemeNameExistsInTreeNode(TreeListNode node, string menuKey, string schemeName)
        {
            if (node == null) return false;

            TreeNodeData nodeData = node.Tag as TreeNodeData;
            if (nodeData != null &&
                NodeTypeScheme.Equals(nodeData.NodeType) &&
                string.Equals(nodeData.MenuKey, menuKey, StringComparison.OrdinalIgnoreCase) &&
                string.Equals(nodeData.SchemeName, schemeName, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            foreach (TreeListNode child in node.Nodes)
            {
                if (SchemeNameExistsInTreeNode(child, menuKey, schemeName))
                {
                    return true;
                }
            }
            return false;
        }

        private string GetMenuModuleCode(TreeNodeData menuData)
        {
            if (menuData != null && !string.IsNullOrWhiteSpace(menuData.ModuleCode))
            {
                return menuData.ModuleCode;
            }
            if (menuData != null && menuData.MenuRow != null)
            {
                string moduleCode = GetRowValue(menuData.MenuRow, "ModuleCode");
                if (!string.IsNullOrWhiteSpace(moduleCode)) return moduleCode;

                string purviewId = GetRowValue(menuData.MenuRow, "PurviewId");
                if (!string.IsNullOrWhiteSpace(purviewId)) return purviewId;

                moduleCode = GetRowValue(menuData.MenuRow, "ModeCode");
                if (!string.IsNullOrWhiteSpace(moduleCode)) return moduleCode;
            }
            return this.Model == null ? string.Empty : this.Model.ModuleCode;
        }

        private string GetTreeNodeCaption(TreeNodeData nodeData)
        {
            if (nodeData == null) return string.Empty;
            if (!string.IsNullOrWhiteSpace(nodeData.MenuCaption)) return nodeData.MenuCaption;
            return GetMenuNodeText(nodeData.MenuRow);
        }

        private static int ToInt(object value)
        {
            if (value == null || value == DBNull.Value) return 0;

            int result;
            return int.TryParse(value + "", out result) ? result : 0;
        }

        private static bool ToBool(object value)
        {
            if (value == null || value == DBNull.Value) return false;

            string text = (value + "").Trim();
            return string.Equals(text, "1", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(text, "True", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(text, "是", StringComparison.OrdinalIgnoreCase);
        }

        private static object GetDbValue(string value)
        {
            return string.IsNullOrWhiteSpace(value) ? (object)DBNull.Value : value;
        }

        private void OnTreeMenuMouseDown(object sender, MouseEventArgs e)
        {
            TreeListHitInfo hitInfo = this.treeMenu.CalcHitInfo(e.Location);
            if (hitInfo == null || hitInfo.Node == null) return;
            if (e.Button != MouseButtons.Right) return;

            this.treeMenu.FocusedNode = hitInfo.Node;
            if (this.treeMenu.FocusedNode != hitInfo.Node) return;
            if (!IsDesignMode()) return;

            this.menuAddScheme.Enabled = CanAddScheme(hitInfo.Node);
            if (this.menuAddScheme.Enabled)
            {
                this.cmsMenuTree.Show(this.treeMenu, e.Location);
            }
        }

        private void OnTreeMenuBeforeFocusNode(object sender, BeforeFocusNodeEventArgs e)
        {
            if (this._restoringFocusedNode) return;
            if (e == null || e.Node == null) return;
            if (this._currentSchemeNode == null || e.Node == this._currentSchemeNode) return;
            CommitDesignRuleGridEditor();
            if (!this._currentSchemeDirty && !HasPendingSchemeChanges()) return;

            if (!ConfirmAbandonCurrentSchemeChanges())
            {
                e.CanFocus = false;
                return;
            }

            DiscardCurrentSchemeChanges();
        }

        private void OnTreeMenuFocusedNodeChanged(object sender, FocusedNodeChangedEventArgs e)
        {
            if (this._restoringFocusedNode) return;
            if (e.Node == null) return;

            TreeNodeData nodeData = e.Node.Tag as TreeNodeData;
            if (nodeData == null) return;

            if (this._currentSchemeNode != null &&
                e.Node != this._currentSchemeNode &&
                this._currentSchemeDirty)
            {
                if (this._suppressNextFocusPrompt)
                {
                    this._suppressNextFocusPrompt = false;
                    RestoreFocusedSchemeNode();
                    return;
                }

                if (!ConfirmAbandonCurrentSchemeChanges())
                {
                    SuppressNextFocusPromptOnce();
                    RestoreFocusedSchemeNode();
                    return;
                }

                DiscardCurrentSchemeChanges();
            }

            if (NodeTypeScheme.Equals(nodeData.NodeType))
            {
                LoadScheme(e.Node);
            }
            else if (CanAddScheme(e.Node))
            {
                ClearCurrentSchemeContext();
                this.lblDesignerStatus.Text = IsDesignMode() ? "右键当前末级菜单可添加方案" : "请选择方案";
            }
        }

        private bool IsMenuNode(TreeListNode node)
        {
            TreeNodeData nodeData = node == null ? null : node.Tag as TreeNodeData;
            return nodeData != null && NodeTypeMenu.Equals(nodeData.NodeType);
        }

        private bool HasMenuChildren(TreeListNode node)
        {
            if (node == null) return false;
            foreach (TreeListNode child in node.Nodes)
            {
                if (IsMenuNode(child)) return true;
            }
            return false;
        }

        private bool CanAddScheme(TreeListNode node)
        {
            TreeNodeData nodeData = node == null ? null : node.Tag as TreeNodeData;
            return nodeData != null && NodeTypeMenu.Equals(nodeData.NodeType) && !HasMenuChildren(node);
        }

        private void OnAddSchemeClick(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;

            TreeListNode menuNode = this.treeMenu.FocusedNode;
            if (!CanAddScheme(menuNode))
            {
                MessageUtil.Show("只能在末级菜单节点下添加方案。");
                return;
            }

            TreeNodeData menuData = menuNode.Tag as TreeNodeData;
            if (menuData == null) return;

            try
            {
                string schemeName = GetNextSchemeName(menuData.MenuKey);
                TreeNodeData schemeData = CreatePendingCodeScheme(menuData, schemeName);
                if (schemeData == null)
                {
                    MessageUtil.Show("方案新增失败。");
                    return;
                }

                int schemeIconIndex = Math.Min(3, this.imgMenuTree.Images.Count - 1);
                TreeListNode schemeNode = AppendTreeNode(menuNode, schemeName, schemeData, schemeIconIndex);

                menuNode.Expanded = true;
                this.treeMenu.FocusedNode = schemeNode;
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("方案新增失败：" + ex.Message);
            }
        }

        private void OnSchemeNameKeyDown(object sender, KeyEventArgs e)
        {
            if (!IsDesignMode()) return;
            if (e.KeyCode != Keys.Enter) return;

            e.SuppressKeyPress = true;
            OnSaveSchemeClick(sender, EventArgs.Empty);
        }

        private void OnSchemeNameChanged(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;
            if (this._loadingSchemeEditor || this._currentSchemeNode == null) return;

            TreeNodeData nodeData = this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData != null && NodeTypeScheme.Equals(nodeData.NodeType))
            {
                this._currentSchemeDirty = true;
            }
        }

        private void OnSaveSchemeClick(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;
            if (SaveSchemeAndRules())
            {
                MessageUtil.Show("方案保存成功。");
            }
        }

        private void EnsureIndexIfColumnsExist(string tableName, string[] columnNames, string indexName, string createSql)
        {
            if (string.IsNullOrWhiteSpace(tableName) || columnNames == null) return;
            foreach (string columnName in columnNames)
            {
                if (!CodeSchemeStorage.ColumnExists(tableName, columnName)) return;
            }

            CodeSchemeStorage.EnsureIndexIfColumnsExist(tableName, columnNames, indexName, createSql);
        }

        private void LoadBindMenuSource()
        {
            this._allMenus = MainImpl.GetMenusByMenuType(out this._menuSql);
            if (LanguageTranslation.Translatable)
            {
                this._allMenus = LanguageTranslation.InitialTableTranslation(this._allMenus);
            }
        }

        private DataTable LoadSpeciesTreeTable()
        {
            string sql = @"SELECT SpeciesNo, SpeciesName
FROM PLM_AutoNumberSpeciesTab
WHERE ISNULL(SpeciesNo, '') <> ''
ORDER BY SpeciesNo";

            DataTable treeTable = BaseImpl.GetDataTableResult(sql);
            return treeTable ?? new DataTable();
        }

        private void BindSpeciesTree(DataTable treeTable)
        {
            if (treeTable == null || treeTable.Rows.Count == 0) return;
            if (!treeTable.Columns.Contains("SpeciesNo"))
            {
                throw new InvalidOperationException("编码分类数据源缺少列[SpeciesNo]。");
            }
            if (!treeTable.Columns.Contains("SpeciesName"))
            {
                throw new InvalidOperationException("编码分类数据源缺少列[SpeciesName]。");
            }

            List<DataRow> rows = treeTable.Rows.Cast<DataRow>()
                .Where(n => !string.IsNullOrWhiteSpace(GetRowValue(n, "SpeciesNo")))
                .OrderBy(n => GetRowValue(n, "SpeciesNo"))
                .ToList();
            if (rows.Count == 0) return;

            int treeDigit = GetRowValue(rows[0], "SpeciesNo").Length;
            Dictionary<string, TreeListNode> nodeMap = new Dictionary<string, TreeListNode>(StringComparer.OrdinalIgnoreCase);
            foreach (DataRow row in rows)
            {
                string speciesNo = GetRowValue(row, "SpeciesNo").Trim();
                if (string.IsNullOrWhiteSpace(speciesNo) || nodeMap.ContainsKey(speciesNo)) continue;

                string speciesName = GetRowValue(row, "SpeciesName").Trim();
                string nodeText = string.IsNullOrWhiteSpace(speciesName) ? speciesNo : speciesName;
                TreeListNode parentNode = GetSpeciesParentNode(row, speciesNo, treeDigit, nodeMap);
                TreeListNode node = AppendTreeNode(parentNode, nodeText, new TreeNodeData
                {
                    NodeType = NodeTypeMenu,
                    MenuKey = speciesNo,
                    MenuLevel = GetSpeciesNodeLevel(speciesNo, treeDigit),
                    MenuRow = row,
                    MenuCaption = nodeText,
                    ModuleCode = GetNumberRuleGridModuleCode()
                }, GetNextTreeIconIndex());
                nodeMap.Add(speciesNo, node);
            }

            AppendCodeSchemeNodes(nodeMap);
        }

        private TreeListNode GetSpeciesParentNode(DataRow row, string speciesNo, int treeDigit, Dictionary<string, TreeListNode> nodeMap)
        {
            if (row != null && row.Table != null && SystemInfo.Instance.TreeSpecialBinding && row.Table.Columns.Contains("pid"))
            {
                string pid = GetRowValue(row, "pid").Trim();
                return !string.IsNullOrWhiteSpace(pid) && nodeMap.ContainsKey(pid) ? nodeMap[pid] : null;
            }

            if (treeDigit <= 0 || string.IsNullOrWhiteSpace(speciesNo) || speciesNo.Length < treeDigit * 2) return null;

            string parentKey = speciesNo.Substring(0, speciesNo.Length - treeDigit);
            return nodeMap.ContainsKey(parentKey) ? nodeMap[parentKey] : null;
        }

        private int GetSpeciesNodeLevel(string speciesNo, int treeDigit)
        {
            if (treeDigit <= 0 || string.IsNullOrWhiteSpace(speciesNo)) return 1;
            return Math.Max(1, (int)Math.Ceiling(speciesNo.Length * 1.0 / treeDigit));
        }

        private DataTable LoadConfiguredMenuTreeTable()
        {
            this._menuTreeSourceRow = null;
            this._menuTreeKeyField = string.Empty;
            this._menuTreeTextField = string.Empty;
            this._menuTreeNodeLength = string.Empty;

            string moduleCode = this.Model == null ? string.Empty : this.Model.ModuleCode;
            if (string.IsNullOrWhiteSpace(moduleCode))
            {
                throw new InvalidOperationException("未获取到 ModuleCode，无法加载左侧配置树。");
            }

            this._menuTreeSourceRow = BaseModuleImpl.GetBaseLeftTreeField(moduleCode);
            if (this._menuTreeSourceRow == null)
            {
                throw new InvalidOperationException(string.Format("模块[{0}]未配置左侧树节点关联。", moduleCode));
            }

            string fieldSql = GetRowValue(this._menuTreeSourceRow, "fieldsql");
            this._menuTreeKeyField = GetRowValue(this._menuTreeSourceRow, "fieldsqlid");
            this._menuTreeTextField = GetRowValue(this._menuTreeSourceRow, "fieldsqlname");
            this._menuTreeNodeLength = GetRowValue(this._menuTreeSourceRow, "TreeNodeLength");

            if (string.IsNullOrWhiteSpace(fieldSql))
            {
                throw new InvalidOperationException("左侧树节点关联未配置 fieldsql。");
            }
            if (string.IsNullOrWhiteSpace(this._menuTreeKeyField))
            {
                throw new InvalidOperationException("左侧树节点关联未配置 fieldsqlid。");
            }
            if (string.IsNullOrWhiteSpace(this._menuTreeTextField))
            {
                throw new InvalidOperationException("左侧树节点关联未配置 fieldsqlname。");
            }

            DataTable treeTable = BaseImpl.GetDataTableResult(fieldSql);
            if (treeTable == null)
            {
                treeTable = new DataTable();
            }
            if (!treeTable.Columns.Contains(this._menuTreeKeyField))
            {
                throw new InvalidOperationException(string.Format("左侧树数据源缺少节点编号列[{0}]。", this._menuTreeKeyField));
            }
            if (!treeTable.Columns.Contains(this._menuTreeTextField))
            {
                throw new InvalidOperationException(string.Format("左侧树数据源缺少节点名称列[{0}]。", this._menuTreeTextField));
            }
            return treeTable;
        }

        private void BindConfiguredMenuTree(DataTable treeTable)
        {
            if (treeTable == null || treeTable.Rows.Count == 0) return;

            List<DataRow> rows = GetConfiguredTreeRows(treeTable);
            Dictionary<string, TreeListNode> nodeMap = new Dictionary<string, TreeListNode>(StringComparer.OrdinalIgnoreCase);
            List<DataRow> pendingRows = rows.ToList();

            while (pendingRows.Count > 0)
            {
                bool appended = false;
                for (int i = pendingRows.Count - 1; i >= 0; i--)
                {
                    DataRow row = pendingRows[i];
                    string nodeKey = GetConfiguredTreeNodeKey(row);
                    if (string.IsNullOrWhiteSpace(nodeKey) || nodeMap.ContainsKey(nodeKey))
                    {
                        pendingRows.RemoveAt(i);
                        continue;
                    }

                    string parentKey = GetConfiguredTreeParentKey(row, rows);
                    bool hasParent = !string.IsNullOrWhiteSpace(parentKey) && nodeMap.ContainsKey(parentKey);
                    if (!hasParent && ConfiguredTreeKeyExists(rows, parentKey))
                    {
                        continue;
                    }

                    TreeListNode parentNode = hasParent ? nodeMap[parentKey] : null;
                    string nodeText = GetConfiguredTreeNodeText(row);
                    TreeListNode node = AppendTreeNode(parentNode, nodeText, new TreeNodeData
                    {
                        NodeType = NodeTypeMenu,
                        MenuKey = nodeKey,
                        MenuLevel = GetConfiguredTreeNodeLevel(row),
                        MenuRow = row,
                        MenuCaption = nodeText,
                        ModuleCode = GetConfiguredTreeNodeModuleCode(row)
                    }, GetNextTreeIconIndex());
                    nodeMap.Add(nodeKey, node);
                    pendingRows.RemoveAt(i);
                    appended = true;
                }

                if (!appended)
                {
                    break;
                }
            }

            AppendCodeSchemeNodes(nodeMap);
        }

        private bool ConfiguredTreeKeyExists(List<DataRow> rows, string nodeKey)
        {
            if (rows == null || string.IsNullOrWhiteSpace(nodeKey)) return false;
            return rows.Any(n => string.Equals(GetConfiguredTreeNodeKey(n), nodeKey, StringComparison.OrdinalIgnoreCase));
        }

        private List<DataRow> GetConfiguredTreeRows(DataTable treeTable)
        {
            IEnumerable<DataRow> rows = treeTable.Rows.Cast<DataRow>()
                .Where(n => !string.IsNullOrWhiteSpace(GetConfiguredTreeNodeKey(n)));

            int lengthLimitation;
            if (int.TryParse(this._menuTreeNodeLength, out lengthLimitation) && lengthLimitation > 0)
            {
                rows = rows.OrderBy(n => GetConfiguredTreeNodeKey(n).Length > lengthLimitation ? 1 : 0)
                    .ThenBy(n => GetConfiguredTreeSortValue(n))
                    .ThenBy(n => GetConfiguredTreeNodeKey(n));
            }
            else
            {
                rows = rows.OrderBy(n => GetConfiguredTreeNodeKey(n));
            }

            return rows.ToList();
        }

        private string GetConfiguredTreeNodeKey(DataRow row)
        {
            return GetRowValue(row, this._menuTreeKeyField).Trim();
        }

        private string GetConfiguredTreeNodeText(DataRow row)
        {
            string text = GetRowValue(row, this._menuTreeTextField).Trim();
            if (!string.IsNullOrWhiteSpace(text)) return text;
            return GetConfiguredTreeNodeKey(row);
        }

        private string GetConfiguredTreeSortValue(DataRow row)
        {
            if (row != null && row.Table != null && row.Table.Columns.Contains("remark"))
            {
                return GetRowValue(row, "remark");
            }
            return GetConfiguredTreeNodeKey(row);
        }

        private string GetConfiguredTreeParentKey(DataRow row, List<DataRow> allRows)
        {
            string nodeKey = GetConfiguredTreeNodeKey(row);
            if (string.IsNullOrWhiteSpace(nodeKey)) return string.Empty;

            string pidColumn = FindColumnName(row == null ? null : row.Table, "pid", "Pid", "ParentId", "ParentKey", "ParentNo");
            if (!string.IsNullOrWhiteSpace(pidColumn))
            {
                string pid = GetRowValue(row, pidColumn).Trim();
                if (!string.IsNullOrWhiteSpace(pid) && pid != "0") return pid;
            }

            int lengthLimitation;
            if (int.TryParse(this._menuTreeNodeLength, out lengthLimitation) && lengthLimitation > 0 && nodeKey.Length > lengthLimitation)
            {
                string prefixKey = nodeKey.Substring(0, lengthLimitation);
                string sortValue = GetConfiguredTreeSortValue(row);
                if (!string.IsNullOrWhiteSpace(sortValue) && sortValue.Contains("-"))
                {
                    string parentSortValue = sortValue.Remove(sortValue.LastIndexOf("-"), sortValue.Length - sortValue.LastIndexOf("-"));
                    DataRow parentRow = allRows.FirstOrDefault(n =>
                        GetConfiguredTreeNodeKey(n).StartsWith(prefixKey, StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(GetConfiguredTreeSortValue(n), parentSortValue, StringComparison.OrdinalIgnoreCase));
                    if (parentRow != null) return GetConfiguredTreeNodeKey(parentRow);
                }
                return prefixKey;
            }

            int treeDigit = GetConfiguredTreeDigit(allRows);
            if (treeDigit > 0 && nodeKey.Length >= treeDigit * 2)
            {
                return nodeKey.Substring(0, nodeKey.Length - treeDigit);
            }
            return string.Empty;
        }

        private int GetConfiguredTreeDigit(List<DataRow> rows)
        {
            if (rows == null) return 0;
            DataRow firstRow = rows.FirstOrDefault(n => !string.IsNullOrWhiteSpace(GetConfiguredTreeNodeKey(n)));
            return firstRow == null ? 0 : GetConfiguredTreeNodeKey(firstRow).Length;
        }

        private int GetConfiguredTreeNodeLevel(DataRow row)
        {
            string nodeKey = GetConfiguredTreeNodeKey(row);
            int treeDigit = GetConfiguredTreeDigit(row == null ? null : row.Table.Rows.Cast<DataRow>().ToList());
            if (treeDigit <= 0 || string.IsNullOrWhiteSpace(nodeKey)) return 1;
            return Math.Max(1, (int)Math.Ceiling(nodeKey.Length * 1.0 / treeDigit));
        }

        private string GetConfiguredTreeNodeModuleCode(DataRow row)
        {
            string moduleCode = GetRowValue(row, "ModuleCode");
            if (!string.IsNullOrWhiteSpace(moduleCode)) return moduleCode;

            moduleCode = GetRowValue(row, "PurviewId");
            if (!string.IsNullOrWhiteSpace(moduleCode)) return moduleCode;

            moduleCode = GetRowValue(row, "ModeCode");
            if (!string.IsNullOrWhiteSpace(moduleCode)) return moduleCode;

            return this.Model == null ? string.Empty : this.Model.ModuleCode;
        }

        private void OnAddLogicClick(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;
            if (!EnsureNumberRuleGridReady()) return;

            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType))
            {
                MessageUtil.Show("请先选择方案。");
                return;
            }

            try
            {
                this.gridDesignRules.AddNewLogic();
                this._currentSchemeDirty = true;
                UpdateSchemeStatus();
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("增加逻辑失败：" + ex.Message);
            }
        }

        private void OnDeleteLogicClick(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;
            if (!EnsureNumberRuleGridReady()) return;

            try
            {
                TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
                if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType))
                {
                    MessageUtil.Show("请先选择方案。");
                    return;
                }

                if (DeleteSelectedNumberRuleRows())
                {
                    this._currentSchemeDirty = true;
                    UpdateSchemeStatus();
                }
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("删除逻辑失败：" + ex.Message);
            }
        }

        private void OnDeleteSchemeClick(object sender, EventArgs e)
        {
            if (!IsDesignMode()) return;

            TreeListNode schemeNode = this._currentSchemeNode;
            TreeNodeData nodeData = schemeNode == null ? null : schemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return;

            DialogResult result = MessageUtil.Show("确定要删除当前方案吗？", MessageBoxButtons.OKCancel);
            if (result != DialogResult.OK) return;

            try
            {
                if (nodeData.SchemeId > 0)
                {
                    DeleteCodeScheme(nodeData);
                }

                RemoveSchemeNodeAndClear(schemeNode);
                MessageUtil.Show("方案删除成功。");
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("方案删除失败：" + ex.Message);
            }
        }

        private void OnGenerateCodeClick(object sender, EventArgs e)
        {
            if (!IsViewMode()) return;

            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType))
            {
                MessageUtil.Show("请先选择方案。");
                return;
            }

            if (nodeData.BindModule)
            {
                MessageUtil.Show("当前方案已绑定模块，view模式只支持未绑定方案生成编码。");
                return;
            }

            try
            {
                string codeValue = GenerateCodeByScheme(nodeData);
                if (string.IsNullOrWhiteSpace(codeValue)) return;

                this.txtCodePreview.Text = codeValue;
                MessageUtil.Show("编码生成成功。");
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("编码生成失败：" + ex.Message);
            }
        }

        private string GenerateCodeByScheme(TreeNodeData nodeData)
        {
            if (nodeData == null || nodeData.SchemeId <= 0) return string.Empty;

            CodeSchemeStorage.EnsureCodeRecordStorage();
            CodeSchemeStorage.EnsureCodeGenerateProcedure();
            return ExecuteCodeGenerateProcedure(nodeData);
        }

        private string ExecuteCodeGenerateProcedure(TreeNodeData nodeData)
        {
            string sql = string.Format(@"
DECLARE @return_id NVARCHAR(300);
EXEC dbo.{0}
    @SchemeId = @SchemeId,
    @CreateUserId = @CreateUserId,
    @CreateUserName = @CreateUserName,
    @return_id = @return_id OUTPUT;
SELECT @return_id;", CodeGenerateProcedureName);

            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[]
            {
                new SqlParameter("@SchemeId", nodeData.SchemeId),
                new SqlParameter("@CreateUserId", ERPInfo.Instance.UserId ?? string.Empty),
                new SqlParameter("@CreateUserName", ERPInfo.Instance.UserName ?? string.Empty)
            });
            return result + "";
        }

        private bool SaveSchemeAndRules()
        {
            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return false;
            if (!CanSaveBindModuleRules(nodeData)) return false;

            if (!SaveCurrentScheme(false)) return false;

            nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (!SaveNumberRuleGrid(nodeData))
            {
                this._currentSchemeDirty = true;
                UpdateSchemeStatus();
                return false;
            }

            this._currentSchemeDirty = false;
            UpdateSchemeStatus();
            return true;
        }

        private bool CanSaveBindModuleRules(TreeNodeData nodeData)
        {
            if (nodeData == null || !IsDesignMode() || !this.chkBindModule.Checked) return true;

            string bindModuleCode = GetSelectedBindModuleCode();
            if (string.IsNullOrWhiteSpace(bindModuleCode)) return true;

            bool isNewBindScheme = nodeData.SchemeId <= 0;
            bool isChangingToBind = !nodeData.BindModule;
            bool isChangingBindModule = nodeData.BindModule &&
                !string.Equals(nodeData.BindModuleCode, bindModuleCode, StringComparison.OrdinalIgnoreCase);
            if (!isNewBindScheme && !isChangingToBind && !isChangingBindModule) return true;

            string ownerSchemeName;
            if (BindModuleOwnedByOtherScheme(bindModuleCode, nodeData.SchemeId, out ownerSchemeName))
            {
                MessageUtil.Show(string.Format("当前选择的绑定模块已经被方案[{0}]绑定，不能重复绑定。", ownerSchemeName));
                return false;
            }

            if (!BindModuleNumberRulesExist(bindModuleCode)) return true;

            DialogResult result = MessageUtil.Show(
                "当前选择的绑定模块存在未归属方案的历史编码规则。\r\n确认后将由当前方案接管，并覆盖原有历史规则，是否继续？",
                MessageBoxButtons.YesNo);
            if (result != DialogResult.Yes) return false;
            return true;
        }

        private bool SaveCurrentScheme(bool showSuccess = true)
        {
            if (!IsDesignMode()) return false;
            if (this._currentSchemeNode == null) return false;

            TreeNodeData nodeData = this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return false;

            string schemeName = (this.txtSchemeName.Text + "").Trim();
            if (string.IsNullOrWhiteSpace(schemeName))
            {
                MessageUtil.Show("方案名称不能为空。");
                this.txtSchemeName.Focus();
                return false;
            }
            if (this.chkBindModule.Checked && string.IsNullOrWhiteSpace(GetSelectedBindModuleCode()))
            {
                MessageUtil.Show("请选择绑定模块的三级菜单。");
                this.cboBindLevel3.Focus();
                return false;
            }

            try
            {
                ApplyBindModuleToNodeData(nodeData);

                if (nodeData.SchemeId <= 0)
                {
                    int schemeId = InsertCodeScheme(nodeData, schemeName);
                    if (schemeId <= 0)
                    {
                        MessageUtil.Show("方案保存失败。");
                        return false;
                    }

                    nodeData.SchemeId = schemeId;
                }
                else
                {
                    string sql = @"UPDATE P_CodeSchemeTab
SET SchemeName = @SchemeName,
    ModuleCode = @ModuleCode,
    BindModule = @BindModule,
    BindSubSysId = @BindSubSysId,
    BindMenuStruct1 = @BindMenuStruct1,
    BindMenuStruct2 = @BindMenuStruct2,
    BindMenuId = @BindMenuId,
    BindModuleCode = @BindModuleCode,
    ModifyUserId = @ModifyUserId,
    ModifyUserName = @ModifyUserName,
    ModifyTime = GETDATE()
WHERE SchemeId = @SchemeId";
                    SqlHelper.ExecuteNonQuery(CommandType.Text, sql, new SqlParameter[]
                    {
                        new SqlParameter("@SchemeName", schemeName),
                        new SqlParameter("@ModuleCode", GetMenuModuleCode(nodeData)),
                        new SqlParameter("@BindModule", nodeData.BindModule),
                        new SqlParameter("@BindSubSysId", GetDbValue(nodeData.BindSubSysId)),
                        new SqlParameter("@BindMenuStruct1", GetDbValue(nodeData.BindMenuStruct1)),
                        new SqlParameter("@BindMenuStruct2", GetDbValue(nodeData.BindMenuStruct2)),
                        new SqlParameter("@BindMenuId", GetDbValue(nodeData.BindMenuId)),
                        new SqlParameter("@BindModuleCode", GetDbValue(nodeData.BindModuleCode)),
                        new SqlParameter("@ModifyUserId", ERPInfo.Instance.UserId),
                        new SqlParameter("@ModifyUserName", ERPInfo.Instance.UserName),
                        new SqlParameter("@SchemeId", nodeData.SchemeId)
                    });
                }

                nodeData.SchemeName = schemeName;
                this._currentSchemeNode.SetValue(this.treeColumnMenu, schemeName);
                this._currentSchemeKey = GetSchemeKey(nodeData);
                this._currentSchemeDirty = false;
                UpdateSchemeStatus();
                if (showSuccess)
                {
                    MessageUtil.Show("方案保存成功。");
                }
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("方案保存失败：" + ex.Message);
                return false;
            }
        }

        private void SetSchemeEditor(TreeNodeData nodeData)
        {
            bool hasScheme = nodeData != null && NodeTypeScheme.Equals(nodeData.NodeType);
            bool designMode = IsDesignMode();
            this._loadingSchemeEditor = true;
            try
            {
                this.txtSchemeName.Enabled = hasScheme;
                this.txtSchemeName.Properties.ReadOnly = !designMode;
                this.btnDeleteScheme.Enabled = designMode && hasScheme;
                this.btnGenerateCode.Enabled = !designMode && hasScheme;
                this.btnAddLogic.Enabled = designMode && hasScheme;
                this.btnDeleteLogic.Enabled = designMode && hasScheme;
                this.btnSave.Enabled = designMode && hasScheme;
                this.txtCodePreview.Enabled = hasScheme;
                this.txtSchemeName.Text = hasScheme ? nodeData.SchemeName : "";
                SetBindModuleEditor(nodeData);
                if (!hasScheme)
                {
                this.txtCodePreview.Text = "";
            }
            if (!hasScheme)
            {
                this.pnlViewWork.Controls.Clear();
            }
        }
        finally
        {
            this._loadingSchemeEditor = false;
        }
        SetBindControlsEnabled(hasScheme);
    }

        private void SetBindModuleEditor(TreeNodeData nodeData)
        {
            this._loadingBindControls = true;
            try
            {
                bool hasScheme = nodeData != null && NodeTypeScheme.Equals(nodeData.NodeType);
                this.chkBindModule.Checked = hasScheme && nodeData.BindModule;

                string subSysId = hasScheme ? nodeData.BindSubSysId : string.Empty;
                string menuStruct1 = hasScheme ? nodeData.BindMenuStruct1 : string.Empty;
                string menuStruct2 = hasScheme ? nodeData.BindMenuStruct2 : string.Empty;
                string menuId = hasScheme ? nodeData.BindMenuId : string.Empty;

                if (hasScheme && nodeData.MenuRow != null)
                {
                    if (string.IsNullOrWhiteSpace(subSysId))
                    {
                        subSysId = GetRowValue(nodeData.MenuRow, "SubSysId");
                    }

                    string currentStruct = GetRowValue(nodeData.MenuRow, "MenuStruct");
                    if (string.IsNullOrWhiteSpace(menuStruct1) && currentStruct.Length >= MenuStructStepLength)
                    {
                        menuStruct1 = currentStruct.Substring(0, MenuStructStepLength);
                    }
                    if (string.IsNullOrWhiteSpace(menuStruct2))
                    {
                        menuStruct2 = currentStruct;
                    }
                    if (string.IsNullOrWhiteSpace(menuId))
                    {
                        menuId = GetRowValue(nodeData.MenuRow, "MenuId");
                    }
                }

                LoadBindLevel1Items(subSysId);
                LoadBindLevel2Items(menuStruct1);
                LoadBindLevel3Items(menuStruct2, menuId);
            }
            finally
            {
                this._loadingBindControls = false;
            }
        }

        private void SetBindControlsEnabled(bool hasScheme)
        {
            bool enabled = IsDesignMode() && hasScheme;
            this.chkBindModule.Enabled = enabled;
            bool comboEnabled = enabled && this.chkBindModule.Checked;
            this.cboBindLevel1.Enabled = comboEnabled;
            this.cboBindLevel2.Enabled = comboEnabled && this.cboBindLevel1.SelectedItem is MenuComboItem;
            this.cboBindLevel3.Enabled = comboEnabled && this.cboBindLevel2.SelectedItem is MenuComboItem;
        }

        private void LoadBindLevel1Items(string selectedSubSysId)
        {
            object previousSelected = this.cboBindLevel1.SelectedItem;
            this.cboBindLevel1.Properties.Items.Clear();

            List<DataRow> topSubSystems = GetVisibleTopSubSystems(this._allMenus);
            foreach (DataRow row in topSubSystems)
            {
                this.cboBindLevel1.Properties.Items.Add(new MenuComboItem
                {
                    Text = GetTopNodeText(row),
                    SubSysId = GetRowValue(row, "SubSysId"),
                    Row = row
                });
            }

            SelectComboItem(this.cboBindLevel1, selectedSubSysId, null, null);
            if (string.IsNullOrWhiteSpace(selectedSubSysId) && this.cboBindLevel1.SelectedItem == null && previousSelected is MenuComboItem)
            {
                MenuComboItem previousItem = previousSelected as MenuComboItem;
                SelectComboItem(this.cboBindLevel1, previousItem.SubSysId, null, null);
            }
        }

        private void LoadBindLevel2Items(string selectedMenuStruct)
        {
            MenuComboItem level1 = this.cboBindLevel1.SelectedItem as MenuComboItem;
            this.cboBindLevel2.Properties.Items.Clear();
            this.cboBindLevel3.Properties.Items.Clear();

            if (level1 != null && this._allMenus != null)
            {
                List<DataRow> rows = this._allMenus.Rows.Cast<DataRow>()
                    .Where(IsMenuTreeRow)
                    .Where(n => GetMenuLevel(GetRowValue(n, "MenuStruct")) == 1)
                    .Where(n => string.Equals(GetRowValue(n, "SubSysId"), level1.SubSysId, StringComparison.OrdinalIgnoreCase))
                    .Where(n => !IsSplitBarMenu(n))
                    .OrderBy(n => GetRowValue(n, "MenuStruct"))
                    .ThenBy(n => GetRowValue(n, "MenuId"))
                    .ToList();

                foreach (DataRow row in rows)
                {
                    this.cboBindLevel2.Properties.Items.Add(new MenuComboItem
                    {
                        Text = GetMenuNodeText(row),
                        SubSysId = GetRowValue(row, "SubSysId"),
                        MenuStruct = GetRowValue(row, "MenuStruct"),
                        MenuId = GetRowValue(row, "MenuId"),
                        ModuleCode = GetRowValue(row, "PurviewId"),
                        Row = row
                    });
                }
            }

            SelectComboItem(this.cboBindLevel2, null, selectedMenuStruct, null);
        }

        private void LoadBindLevel3Items(string selectedMenuStruct, string selectedMenuId)
        {
            MenuComboItem level2 = this.cboBindLevel2.SelectedItem as MenuComboItem;
            this.cboBindLevel3.Properties.Items.Clear();

            if (level2 != null && this._allMenus != null)
            {
                List<DataRow> rows = this._allMenus.Rows.Cast<DataRow>()
                    .Where(IsMenuTreeRow)
                    .Where(n => GetMenuLevel(GetRowValue(n, "MenuStruct")) == MaxMenuStructLevel)
                    .Where(n => string.Equals(GetRowValue(n, "SubSysId"), level2.SubSysId, StringComparison.OrdinalIgnoreCase))
                    .Where(n => GetRowValue(n, "MenuStruct").StartsWith(level2.MenuStruct))
                    .Where(n => !IsSplitBarMenu(n))
                    .Where(n => !string.IsNullOrWhiteSpace(GetRowValue(n, "DllFileName")))
                    .OrderBy(n => GetRowValue(n, "MenuStruct"))
                    .ThenBy(n => GetRowValue(n, "MenuId"))
                    .ToList();

                foreach (DataRow row in rows)
                {
                    this.cboBindLevel3.Properties.Items.Add(new MenuComboItem
                    {
                        Text = GetMenuNodeText(row),
                        SubSysId = GetRowValue(row, "SubSysId"),
                        MenuStruct = GetRowValue(row, "MenuStruct"),
                        MenuId = GetRowValue(row, "MenuId"),
                        ModuleCode = GetRowValue(row, "PurviewId"),
                        Row = row
                    });
                }
            }

            SelectComboItem(this.cboBindLevel3, null, selectedMenuStruct, selectedMenuId);
        }

        private void SelectComboItem(DevExpress.XtraEditors.ComboBoxEdit combo, string subSysId, string menuStruct, string menuId)
        {
            if (combo == null)
            {
                return;
            }

            combo.SelectedIndex = -1;
            for (int i = 0; i < combo.Properties.Items.Count; i++)
            {
                MenuComboItem item = combo.Properties.Items[i] as MenuComboItem;
                if (item == null) continue;

                bool matched = true;
                if (!string.IsNullOrWhiteSpace(subSysId))
                {
                    matched = matched && string.Equals(item.SubSysId, subSysId, StringComparison.OrdinalIgnoreCase);
                }
                if (!string.IsNullOrWhiteSpace(menuStruct))
                {
                    matched = matched && string.Equals(item.MenuStruct, menuStruct, StringComparison.OrdinalIgnoreCase);
                }
                if (!string.IsNullOrWhiteSpace(menuId))
                {
                    matched = matched && string.Equals(item.MenuId, menuId, StringComparison.OrdinalIgnoreCase);
                }

                if (matched)
                {
                    combo.SelectedIndex = i;
                    return;
                }
            }
        }

        private void OnBindModuleCheckedChanged(object sender, EventArgs e)
        {
            if (this._loadingBindControls || this._loadingSchemeEditor) return;

            if (this.chkBindModule.Checked && this.cboBindLevel1.SelectedItem == null)
            {
                TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
                SetBindModuleEditor(nodeData);
                this.chkBindModule.Checked = true;
            }

            SetBindControlsEnabled(this._currentSchemeNode != null);
            OnBindModuleEditorChanged(true);
        }

        private void OnBindLevel1Changed(object sender, EventArgs e)
        {
            if (this._loadingBindControls) return;

            this._loadingBindControls = true;
            try
            {
                LoadBindLevel2Items(null);
                LoadBindLevel3Items(null, null);
            }
            finally
            {
                this._loadingBindControls = false;
            }

            SetBindControlsEnabled(this._currentSchemeNode != null);
            OnBindModuleEditorChanged(true);
        }

        private void OnBindLevel2Changed(object sender, EventArgs e)
        {
            if (this._loadingBindControls) return;

            this._loadingBindControls = true;
            try
            {
                LoadBindLevel3Items(null, null);
            }
            finally
            {
                this._loadingBindControls = false;
            }

            SetBindControlsEnabled(this._currentSchemeNode != null);
            OnBindModuleEditorChanged(true);
        }

        private void OnBindLevel3Changed(object sender, EventArgs e)
        {
            if (this._loadingBindControls) return;

            SetBindControlsEnabled(this._currentSchemeNode != null);
            OnBindModuleEditorChanged(true);
        }

        private void OnBindModuleEditorChanged(bool reloadDesignRules)
        {
            if (this._loadingBindControls || this._loadingSchemeEditor) return;
            if (!IsDesignMode() || this._currentSchemeNode == null) return;

            this._currentSchemeDirty = true;
            UpdateSchemeStatus();
        }

        private void ApplyBindModuleToNodeData(TreeNodeData nodeData)
        {
            if (nodeData == null) return;

            nodeData.BindModule = IsDesignMode() && this.chkBindModule.Checked;
            if (!nodeData.BindModule)
            {
                nodeData.BindSubSysId = string.Empty;
                nodeData.BindMenuStruct1 = string.Empty;
                nodeData.BindMenuStruct2 = string.Empty;
                nodeData.BindMenuId = string.Empty;
                nodeData.BindModuleCode = string.Empty;
                return;
            }

            MenuComboItem level1 = this.cboBindLevel1.SelectedItem as MenuComboItem;
            MenuComboItem level2 = this.cboBindLevel2.SelectedItem as MenuComboItem;
            MenuComboItem level3 = this.cboBindLevel3.SelectedItem as MenuComboItem;

            nodeData.BindSubSysId = level1 == null ? string.Empty : level1.SubSysId;
            nodeData.BindMenuStruct1 = level2 == null ? string.Empty : level2.MenuStruct;
            nodeData.BindMenuStruct2 = level3 == null ? string.Empty : level3.MenuStruct;
            nodeData.BindMenuId = level3 == null ? string.Empty : level3.MenuId;
            nodeData.BindModuleCode = GetSelectedBindModuleCode();
        }

        private string GetSelectedBindModuleCode()
        {
            MenuComboItem level3 = this.cboBindLevel3.SelectedItem as MenuComboItem;
            if (level3 == null) return string.Empty;
            if (!string.IsNullOrWhiteSpace(level3.ModuleCode)) return level3.ModuleCode;
            return GetRowValue(level3.Row, "PurviewId");
        }

        private string GetSchemeKey(TreeNodeData nodeData)
        {
            if (nodeData == null) return string.Empty;
            if (nodeData.SchemeId > 0) return nodeData.SchemeId + "";
            if (!string.IsNullOrWhiteSpace(nodeData.SchemeCode)) return "new:" + nodeData.SchemeCode;
            return string.Empty;
        }

        private bool ConfirmAbandonCurrentSchemeChanges()
        {
            if (!IsDesignMode()) return true;
            if (!this._currentSchemeDirty && !HasPendingSchemeChanges()) return true;

            DialogResult result = MessageUtil.Show("当前方案存在未保存的修改。\r\n点击【确定】放弃修改并继续切换；\r\n点击【取消】返回后手动点击保存。", MessageBoxButtons.OKCancel);
            return result == DialogResult.OK;
        }

        private void SuppressNextFocusPromptOnce()
        {
            this._suppressNextFocusPrompt = true;
            BeginInvoke(new MethodInvoker(delegate
            {
                this._suppressNextFocusPrompt = false;
            }));
        }

        private void RestoreFocusedSchemeNode()
        {
            if (this._currentSchemeNode == null) return;

            try
            {
                this._restoringFocusedNode = true;
                this.treeMenu.FocusedNode = this._currentSchemeNode;
            }
            finally
            {
                this._restoringFocusedNode = false;
            }
        }

        private void DiscardCurrentSchemeChanges()
        {
            TreeListNode discardNode = this._currentSchemeNode;
            TreeNodeData nodeData = discardNode == null ? null : discardNode.Tag as TreeNodeData;
            this._currentSchemeDirty = false;

            if (nodeData == null || nodeData.SchemeId > 0) return;

            RemoveSchemeNodeAndClear(discardNode);
        }

        private void RemoveSchemeNodeAndClear(TreeListNode schemeNode)
        {
            try
            {
                this._restoringFocusedNode = true;
                if (schemeNode != null)
                {
                    this.treeMenu.DeleteNode(schemeNode);
                }
            }
            finally
            {
                this._restoringFocusedNode = false;
            }

            if (schemeNode == this._currentSchemeNode)
            {
                this._currentSchemeNode = null;
                this._currentSchemeKey = string.Empty;
                this._currentSchemeDirty = false;
                this.pnlViewWork.Controls.Clear();
                ClearViewRuntimeState();
                BindEmptyDesignRuleGrid();
                SetSchemeEditor(null);
                UpdateSchemeStatus();
            }
        }

        private void ClearCurrentSchemeContext()
        {
            this._currentSchemeNode = null;
            this._currentSchemeKey = string.Empty;
            this._currentSchemeDirty = false;
            this.pnlViewWork.Controls.Clear();
            ClearViewRuntimeState();
            BindEmptyDesignRuleGrid();
            SetSchemeEditor(null);
        }

        private void LoadScheme(TreeListNode schemeNode)
        {
            TreeNodeData nodeData = schemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return;

            string targetSchemeKey = GetSchemeKey(nodeData);
            this._currentSchemeNode = schemeNode;
            this._currentSchemeKey = targetSchemeKey;
            this.pnlViewWork.Controls.Clear();
            ClearViewRuntimeState();
            SetSchemeEditor(nodeData);

            try
            {
                if (nodeData.SchemeId > 0)
                {
                    DataTable controls = LoadNumberRuleSchemeRows(nodeData);
                    LoadSchemeDesignRules(controls);
                }
                else if (IsDesignMode())
                {
                    LoadSchemeDesignRules(null);
                }
                else
                {
                    BindEmptyDesignRuleGrid();
                }
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("方案控件加载失败：" + ex.Message);
            }

            this._currentSchemeDirty = IsDesignMode() && nodeData.SchemeId <= 0;
            UpdateSchemeStatus();
        }

        private void LoadSchemeViewControls(DataTable schemeControls)
        {
            if (!IsViewMode()) return;

            EnsureModelDataCaches();
            DataTable viewControls = CreateViewControlConfigTable(schemeControls);
            if (viewControls.Rows.Count == 0)
            {
                ClearCodePreview();
                return;
            }

            this._viewControlObj = new MyControl();
            this._viewControlObj.Model = this.Model;
            this._viewControlObj.CurrentData = this.Model == null ? null : this.Model.GetMaintabFocusedRow();
            this._viewControlObj.OtherParams = this.Model == null ? null : this.Model.OtherParams();
            this._viewControlObj.OnDataSourceBindCallBack += OnViewControlDataSourceBindCallBack;
            this._viewControlObj.InitControl(viewControls, this.pnlViewWork);
            this.pnlViewWork.Dock = DockStyle.Fill;

            ApplyCurrentRowValuesToViewControls();
            RegisterViewControlValueChanged(this.pnlViewWork);
            ClearCodePreview();
        }

        private void ClearViewRuntimeState()
        {
            this._viewControlObj = null;
            this._viewSchemeItems.Clear();
            if (this.txtCodePreview != null)
            {
                this.txtCodePreview.Text = string.Empty;
            }
        }

        private void EnsureModelDataCaches()
        {
            if (this.Model == null) return;
            if (this.Model.DataCaches == null)
            {
                this.Model.DataCaches = new Dictionary<object, Hashtable>();
            }
        }

        private DataTable CreateViewControlConfigTable(DataTable schemeControls)
        {
            DataTable sourceTable = this._fieldConfigTable;
            DataTable result = sourceTable == null ? new DataTable() : sourceTable.Clone();
            result.PrimaryKey = new DataColumn[0];
            result.Constraints.Clear();
            PrepareMyControlConfigTable(result);
            this._viewSchemeItems.Clear();
            if (schemeControls == null || schemeControls.Rows.Count == 0 || sourceTable == null || sourceTable.Rows.Count == 0)
            {
                return result;
            }

            string fieldNameColumn = FindColumnName(result, "fieldname", "fieldName", "FieldName");
            if (string.IsNullOrWhiteSpace(fieldNameColumn)) return result;
            string userNameColumn = FindColumnName(result, "username", "userName", "UserName");
            string fieldTypeIdColumn = FindColumnName(result, "fieldTypeId", "FieldTypeId", "fieldtypeid");

            Dictionary<string, int> fieldUsage = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
            foreach (DataRow schemeRow in schemeControls.Rows)
            {
                string sourceFieldName = GetSourceValue(schemeRow, "FieldName");
                if (string.IsNullOrWhiteSpace(sourceFieldName)) continue;

                DataRow sourceRow = GetMatchedFieldConfigRow(sourceTable, sourceFieldName);
                if (sourceRow == null) continue;

                int usageNo;
                fieldUsage.TryGetValue(sourceFieldName, out usageNo);
                usageNo++;
                fieldUsage[sourceFieldName] = usageNo;

                string runtimeFieldName = GetRuntimeFieldName(sourceFieldName, usageNo);
                DataRow viewRow = result.NewRow();
                foreach (DataColumn column in result.Columns)
                {
                    if (sourceRow.Table.Columns.Contains(column.ColumnName))
                    {
                        viewRow[column.ColumnName] = sourceRow[column.ColumnName];
                    }
                }
                NormalizeMyControlConfigRow(viewRow);
                int fieldTypeId = GetFieldTypeId(viewRow);
                FieldDesignItem viewItem = new FieldDesignItem
                {
                    UserName = GetViewUserName(sourceRow, schemeRow),
                    FieldName = sourceFieldName,
                    RuntimeFieldName = runtimeFieldName,
                    FieldTypeId = fieldTypeId,
                    ControlWidth = ToPositiveInt(GetSourceValue(schemeRow, "ControlWidth"), DesignFieldControlWidth),
                    ControlHeight = ToPositiveInt(GetSourceValue(schemeRow, "ControlHeight"), DesignFieldControlHeight)
                };
                if (string.IsNullOrWhiteSpace(viewItem.UserName))
                {
                    viewItem.UserName = sourceFieldName;
                }

                NormalizeViewControlLayoutRow(viewRow, viewItem);
                SetFieldTypeIdValue(viewRow, fieldTypeIdColumn, viewItem.FieldTypeId);
                SetDataRowValue(viewRow, userNameColumn, viewItem.UserName);
                SetDataRowValue(viewRow, fieldNameColumn, runtimeFieldName);
                result.Rows.Add(viewRow);

                this._viewSchemeItems.Add(viewItem);
            }
            return result;
        }

        private void NormalizeViewControlLayoutRow(DataRow row, FieldDesignItem item)
        {
            if (row == null) return;

            SetDataRowValue(row, FindColumnName(row.Table, "controlLeft"), 0);
            SetDataRowValue(row, FindColumnName(row.Table, "controlTop"), 0);
            SetDataRowValue(row, FindColumnName(row.Table, "controlWidth"), item != null && item.ControlWidth > 0 ? item.ControlWidth : DesignFieldControlWidth);
            SetDataRowValue(row, FindColumnName(row.Table, "controlHeight"), item != null && item.ControlHeight > 0 ? item.ControlHeight : DesignFieldControlHeight);
        }

        private void PrepareMyControlConfigTable(DataTable table)
        {
            if (table == null) return;

            EnsureMyControlColumn(table, "id", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "controlLeft", typeof(int), 0);
            EnsureMyControlColumn(table, "controlTop", typeof(int), 0);
            EnsureMyControlColumn(table, "controlWidth", typeof(int), 220);
            EnsureMyControlColumn(table, "controlHeight", typeof(int), 26);
            EnsureMyControlColumn(table, "edited", typeof(string), "0");
            EnsureMyControlColumn(table, "nullable", typeof(bool), false);
            EnsureMyControlColumn(table, "fieldTypeId", typeof(string), "0");
            EnsureMyControlColumn(table, "fieldName", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "userName", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "defaultValue", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "lookupResult", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "lookupKeyField", typeof(string), string.Empty);
            EnsureMyControlColumn(table, "lookupSql", typeof(string), string.Empty);
        }

        private void EnsureMyControlColumn(DataTable table, string columnName, Type dataType, object defaultValue)
        {
            if (table == null || !string.IsNullOrWhiteSpace(FindColumnName(table, columnName))) return;

            DataColumn column = new DataColumn(columnName, dataType);
            column.DefaultValue = defaultValue;
            table.Columns.Add(column);
        }

        private void NormalizeMyControlConfigRow(DataRow row)
        {
            if (row == null) return;

            SetDefaultRowValueIfEmpty(row, "controlWidth", 220);
            SetDefaultRowValueIfEmpty(row, "controlHeight", 26);
            SetDefaultRowValueIfEmpty(row, "controlLeft", 0);
            SetDefaultRowValueIfEmpty(row, "controlTop", 0);
            SetDefaultRowValueIfEmpty(row, "edited", "0");
            SetDefaultRowValueIfEmpty(row, "nullable", false);
            NormalizeMyControlAliasValues(row);
            NormalizeBooleanRowValue(row, "nullable");
            NormalizeFieldTypeIdRowValue(row);
            SetDefaultRowValueIfEmpty(row, "fieldTypeId", "0");
            SetDefaultRowValueIfEmpty(row, "defaultValue", string.Empty);
            SetDefaultRowValueIfEmpty(row, "lookupResult", string.Empty);
            SetDefaultRowValueIfEmpty(row, "lookupKeyField", string.Empty);
            SetDefaultRowValueIfEmpty(row, "lookupSql", string.Empty);
        }

        private void NormalizeMyControlAliasValues(DataRow row)
        {
            if (row == null) return;

            SetRowValueFromAliases(row, "fieldName", "fieldname", "FieldName", "controlName", "ControlName");
            SetRowValueFromAliases(row, "userName", "username", "username1", "UserName", "sysname", "SysName", "controlLabel", "ControlLabel");
            SetRowValueFromAliases(row, "defaultValue", "defaultValue", "defaultdate", "DefaultDate");
            SetRowValueFromAliases(row, "lookupResult", "lookupResult", "fieldsqlname", "fieldSqlName", "resultField", "ResultField");
            SetRowValueFromAliases(row, "lookupKeyField", "lookupKeyField", "fieldsqlid", "fieldSqlId", "keyField", "KeyField");
            SetRowValueFromAliases(row, "lookupSql", "lookupSql", "fieldsql", "fieldSql", "sourceSql", "SourceSql");
            SetRowValueFromAliases(row, "nullable", true, "nullable", "CanNull", "canNull");
        }

        private void SetRowValueFromAliases(DataRow row, string targetColumnName, params string[] sourceColumnNames)
        {
            SetRowValueFromAliases(row, targetColumnName, false, sourceColumnNames);
        }

        private void SetRowValueFromAliases(DataRow row, string targetColumnName, bool overwriteTarget, params string[] sourceColumnNames)
        {
            if (row == null || sourceColumnNames == null) return;

            string targetColumn = FindColumnName(row.Table, targetColumnName);
            if (string.IsNullOrWhiteSpace(targetColumn) || !overwriteTarget && !IsEmptyRowValue(row[targetColumn])) return;

            foreach (string sourceColumnName in sourceColumnNames)
            {
                string sourceColumn = FindColumnName(row.Table, sourceColumnName);
                if (string.IsNullOrWhiteSpace(sourceColumn) || string.Equals(sourceColumn, targetColumn, StringComparison.OrdinalIgnoreCase)) continue;

                object value = row[sourceColumn];
                if (IsEmptyRowValue(value)) continue;

                SetDataRowValue(row, targetColumn, value);
                return;
            }
        }

        private bool IsEmptyRowValue(object value)
        {
            return value == null || value == DBNull.Value || string.IsNullOrWhiteSpace(value + "");
        }

        private void SetDefaultRowValueIfEmpty(DataRow row, string columnName, object defaultValue)
        {
            string actualColumnName = FindColumnName(row.Table, columnName);
            if (string.IsNullOrWhiteSpace(actualColumnName)) return;

            object value = row[actualColumnName];
            if (value == null || value == DBNull.Value || string.IsNullOrWhiteSpace(value + "") || "0".Equals(value + "") && ("controlWidth".Equals(columnName) || "controlHeight".Equals(columnName)))
            {
                SetDataRowValue(row, actualColumnName, defaultValue);
            }
        }

        private void NormalizeBooleanRowValue(DataRow row, string columnName)
        {
            string actualColumnName = FindColumnName(row.Table, columnName);
            if (string.IsNullOrWhiteSpace(actualColumnName)) return;

            string value = row[actualColumnName] + "";
            DataColumn column = row.Table.Columns[actualColumnName];
            if ("0".Equals(value))
            {
                SetDataRowValue(row, actualColumnName, GetBooleanColumnValue(column, false));
            }
            else if ("1".Equals(value))
            {
                SetDataRowValue(row, actualColumnName, GetBooleanColumnValue(column, true));
            }
        }

        private object GetBooleanColumnValue(DataColumn column, bool value)
        {
            if (column == null) return value;
            if (column.DataType == typeof(string)) return value ? "True" : "False";
            if (column.DataType == typeof(int) || column.DataType == typeof(short) || column.DataType == typeof(long) || column.DataType == typeof(byte)) return value ? 1 : 0;
            return value;
        }

        private void NormalizeFieldTypeIdRowValue(DataRow row)
        {
            int fieldTypeId = GetFieldTypeId(row);
            if (fieldTypeId <= 0) return;

            SetFieldTypeIdValue(row, FindColumnName(row.Table, "fieldTypeId", "FieldTypeId", "fieldtypeid"), fieldTypeId);
        }

        private void SetFieldTypeIdValue(DataRow row, string columnName, int fieldTypeId)
        {
            if (row == null || fieldTypeId < 0 || string.IsNullOrWhiteSpace(columnName) || !row.Table.Columns.Contains(columnName)) return;

            DataColumn column = row.Table.Columns[columnName];
            SetDataRowValue(row, columnName, GetIntColumnValue(column, fieldTypeId));
        }

        private object GetIntColumnValue(DataColumn column, int value)
        {
            if (column == null) return value;
            if (column.DataType == typeof(string)) return value + "";

            try
            {
                return Convert.ChangeType(value, column.DataType);
            }
            catch
            {
                return value;
            }
        }

        private DataRow GetMatchedFieldConfigRow(DataTable sourceTable, string fieldName)
        {
            if (string.IsNullOrWhiteSpace(fieldName) || sourceTable == null) return null;

            string fieldNameColumn = FindColumnName(sourceTable, "fieldname", "fieldName", "FieldName");
            if (string.IsNullOrWhiteSpace(fieldNameColumn)) return null;

            foreach (DataRow row in sourceTable.Rows)
            {
                if (string.Equals(GetSourceValue(row, fieldNameColumn), fieldName, StringComparison.OrdinalIgnoreCase))
                {
                    return row;
                }
            }
            return null;
        }

        private string GetRuntimeFieldName(string fieldName, int usageNo)
        {
            return usageNo <= 1 ? fieldName : string.Format("{0}__Code{1:00}", fieldName, usageNo);
        }

        private void SetDataRowValue(DataRow row, string columnName, object value)
        {
            if (row == null || string.IsNullOrWhiteSpace(columnName) || !row.Table.Columns.Contains(columnName)) return;

            DataColumn column = row.Table.Columns[columnName];
            bool readOnly = column.ReadOnly;
            try
            {
                column.ReadOnly = false;
                row[columnName] = value;
            }
            finally
            {
                column.ReadOnly = readOnly;
            }
        }

        private void ApplyCurrentRowValuesToViewControls()
        {
            if (this._viewControlObj == null || this.Model == null) return;

            DataRow currentRow = this.Model.GetMaintabFocusedRow();
            if (currentRow == null) return;

            foreach (FieldDesignItem item in this._viewSchemeItems)
            {
                if (item == null || string.IsNullOrWhiteSpace(item.RuntimeFieldName) || string.IsNullOrWhiteSpace(item.FieldName)) continue;
                if (!currentRow.Table.Columns.Contains(item.FieldName)) continue;

                this._viewControlObj.SetControlValue(item.RuntimeFieldName, currentRow[item.FieldName]);
            }
        }

        private void RegisterViewControlValueChanged(System.Windows.Forms.Control parent)
        {
            if (parent == null) return;

            parent.TextChanged -= OnViewControlValueChanged;
            parent.TextChanged += OnViewControlValueChanged;

            DevExpress.XtraEditors.BaseEdit editor = parent as DevExpress.XtraEditors.BaseEdit;
            if (editor != null)
            {
                editor.EditValueChanged -= OnViewControlEditValueChanged;
                editor.EditValueChanged += OnViewControlEditValueChanged;
            }

            foreach (System.Windows.Forms.Control child in parent.Controls)
            {
                RegisterViewControlValueChanged(child);
            }
        }

        private void OnViewControlDataSourceBindCallBack(object sender, EventArgs e)
        {
            ApplyCurrentRowValuesToViewControls();
            ClearCodePreview();
        }

        private void OnViewControlValueChanged(object sender, EventArgs e)
        {
            ClearCodePreview();
        }

        private void OnViewControlEditValueChanged(object sender, EventArgs e)
        {
            ClearCodePreview();
        }

        private void UpdateCodePreview()
        {
            ClearCodePreview();
        }

        private void ClearCodePreview()
        {
            if (this.txtCodePreview == null || !IsViewMode()) return;
            this.txtCodePreview.Text = string.Empty;
        }

        private void SaveCurrentSchemeLayout()
        {
            if (this._currentSchemeNode == null) return;

            TreeNodeData nodeData = this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType) || nodeData.SchemeId <= 0) return;

            SaveNumberRuleGrid(nodeData);
        }

        private bool SaveNumberRuleGrid(TreeNodeData nodeData)
        {
            if (!IsDesignMode()) return false;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return false;
            if (!EnsureNumberRuleGridReady()) return false;

            try
            {
                CodeSchemeStorage.EnsureRuleStorage();

                if (nodeData.BindModule)
                {
                    EnsureNumberRuleGridSourceTable(NumberRuleTableName, true);
                    EnsureNumberRuleGridKeyColumns(NumberRuleTableName);
                    FillNumberRuleGridKeyValues(nodeData);

                    SaveBindModuleNumberRuleRows(nodeData);
                    DeleteOppositeRuleRows(SchemeControlTableName, nodeData.SchemeId);
                    BindNumberRuleGridRows(LoadNumberRuleSchemeRows(nodeData));
                    return true;
                }

                EnsureNumberRuleGridSourceTable(SchemeControlTableName, true);
                EnsureNumberRuleGridKeyColumns(SchemeControlTableName);
                FillNumberRuleGridKeyValues(nodeData);

                SaveOwnNumberRuleRows(nodeData);
                DeleteOppositeRuleRows(NumberRuleTableName, nodeData.SchemeId);
                BindNumberRuleGridRows(LoadNumberRuleSchemeRows(nodeData));
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("保存逻辑失败：" + ex.Message);
                return false;
            }
        }

        private string[] GetNumberRuleKeyColumnNames()
        {
            return new string[]
            {
                NumberRuleSchemeIdColumn,
                NumberRuleSchemeCodeColumn,
                NumberRuleSchemeNameColumn,
                NumberRuleMenuKeyColumn,
                NumberRuleBindModuleColumn,
                NumberRuleBindModuleCodeColumn,
                NumberRuleModIdColumn
            };
        }

        private string[] GetNumberRuleKeyColumnNames(string tableName)
        {
            if (!string.Equals(tableName, NumberRuleTableName, StringComparison.OrdinalIgnoreCase))
            {
                return GetNumberRuleKeyColumnNames();
            }

            return GetNumberRuleKeyColumnNames()
                .Where(n => CodeSchemeStorage.ColumnExists(NumberRuleTableName, n))
                .ToArray();
        }

        private DataTable GetNumberRuleGridDataSource()
        {
            GridControlEx grid = DesignRuleGrid;
            return grid == null || grid.GridControl == null ? null : grid.GridControl.DataSource as DataTable;
        }

        private void EnsureNumberRuleGridKeyColumns()
        {
            DataTable table = GetNumberRuleGridDataSource();
            if (table == null) return;

            EnsureNumberRuleDataTableKeyColumns(table, GetNumberRuleSourceTable(table));
        }

        private void EnsureNumberRuleGridKeyColumns(string tableName)
        {
            DataTable table = GetNumberRuleGridDataSource();
            if (table == null) return;

            EnsureNumberRuleDataTableKeyColumns(table, tableName);
        }

        private void EnsureNumberRuleDataTableKeyColumns(DataTable table)
        {
            EnsureNumberRuleDataTableKeyColumns(table, GetNumberRuleSourceTable(table));
        }

        private void EnsureNumberRuleDataTableKeyColumns(DataTable table, string tableName)
        {
            if (table == null) return;

            foreach (string columnName in GetNumberRuleKeyColumnNames(tableName))
            {
                Type dataType = columnName == NumberRuleSchemeIdColumn ? typeof(int) :
                    columnName == NumberRuleBindModuleColumn ? typeof(bool) :
                    typeof(string);
                EnsureDataColumn(table, columnName, dataType);
            }
        }

        private void EnsureDataColumn(DataTable table, string columnName, Type dataType)
        {
            if (table == null || string.IsNullOrWhiteSpace(columnName) || table.Columns.Contains(columnName)) return;

            table.Columns.Add(columnName, dataType);
        }

        private void FillNumberRuleGridKeyValues(TreeNodeData nodeData)
        {
            DataTable table = GetNumberRuleGridDataSource();
            if (table == null || nodeData == null) return;

            string bindModuleCode = nodeData.BindModule ? nodeData.BindModuleCode : string.Empty;
            string modid = nodeData.BindModule ? bindModuleCode : string.Empty;

            foreach (DataRow row in table.Rows)
            {
                if (row.RowState == DataRowState.Deleted) continue;

                SetRowValueIfColumnExists(row, NumberRuleSchemeIdColumn, nodeData.SchemeId);
                SetRowValueIfColumnExists(row, NumberRuleSchemeCodeColumn, nodeData.SchemeCode);
                SetRowValueIfColumnExists(row, NumberRuleSchemeNameColumn, nodeData.SchemeName);
                SetRowValueIfColumnExists(row, NumberRuleMenuKeyColumn, nodeData.MenuKey);
                SetRowValueIfColumnExists(row, NumberRuleBindModuleColumn, nodeData.BindModule);
                SetRowValueIfColumnExists(row, NumberRuleBindModuleCodeColumn, bindModuleCode);
                SetRowValueIfColumnExists(row, NumberRuleModIdColumn, modid);
                if (row.Table.Columns.Contains(DesignRuleUseColumn) && string.IsNullOrWhiteSpace(row[DesignRuleUseColumn] + ""))
                {
                    SetRowValueIfColumnExists(row, DesignRuleUseColumn, true);
                }
            }
        }

        private void SetRowValueIfColumnExists(DataRow row, string columnName, object value)
        {
            if (row == null || row.Table == null || !row.Table.Columns.Contains(columnName)) return;

            DataColumn column = row.Table.Columns[columnName];
            object nextValue = GetDataColumnValue(column, value);
            object currentValue = row[columnName];
            if (string.Equals(currentValue + "", nextValue + "", StringComparison.Ordinal)) return;

            bool readOnly = column.ReadOnly;
            try
            {
                column.ReadOnly = false;
                row[columnName] = nextValue ?? DBNull.Value;
            }
            finally
            {
                column.ReadOnly = readOnly;
            }
        }

        private object GetDataColumnValue(DataColumn column, object value)
        {
            if (value == null || value == DBNull.Value) return DBNull.Value;
            if (column == null) return value;

            if (column.DataType == typeof(bool)) return ToBool(value);
            if (column.DataType == typeof(string)) return value + "";
            try
            {
                return Convert.ChangeType(value, column.DataType);
            }
            catch
            {
                return value;
            }
        }

        private bool HasModifiedNumberRuleRows()
        {
            DataTable table = GetNumberRuleGridDataSource();
            if (table == null) return false;

            return table.Rows.Cast<DataRow>().Any(n =>
                n.RowState == DataRowState.Added ||
                n.RowState == DataRowState.Modified ||
                n.RowState == DataRowState.Deleted);
        }

        private bool HasPendingSchemeChanges()
        {
            if (this._currentSchemeNode == null) return false;

            TreeNodeData nodeData = this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType)) return false;

            return HasModifiedNumberRuleRows();
        }

        private void CommitDesignRuleGridEditor()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null || grid.GridView == null) return;

            try
            {
                grid.GridView.PostEditor();
                grid.GridView.UpdateCurrentRow();
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
        }

        private bool DeleteSelectedNumberRuleRows()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null || grid.GridView == null) return false;

            CommitDesignRuleGridEditor();
            List<DataRow> selectedRows = GetSelectedNumberRuleRows(grid);
            if (selectedRows.Count == 0)
            {
                MessageUtil.Show("请先选择要删除的数据。");
                return false;
            }

            string confirmText = selectedRows.Count == 1
                ? "确定删除当前选中的数据吗？"
                : string.Format("确定删除当前选中的 {0} 条数据吗？", selectedRows.Count);
            DialogResult result = MessageUtil.Show(confirmText, MessageBoxButtons.YesNo);
            if (result != DialogResult.Yes) return false;

            foreach (DataRow row in selectedRows)
            {
                if (row == null || row.RowState == DataRowState.Deleted || row.RowState == DataRowState.Detached) continue;

                row.Delete();
            }

            grid.GridView.ClearSelection();
            grid.GridView.RefreshData();
            return true;
        }

        private List<DataRow> GetSelectedNumberRuleRows(GridControlEx grid)
        {
            List<DataRow> result = new List<DataRow>();
            if (grid == null || grid.GridView == null) return result;

            int[] rowHandles = grid.GridView.GetSelectedRows();
            if (rowHandles != null)
            {
                foreach (int rowHandle in rowHandles)
                {
                    AddNumberRuleRowByHandle(grid, rowHandle, result);
                }
            }

            if (result.Count == 0)
            {
                AddNumberRuleRowByHandle(grid, grid.GridView.FocusedRowHandle, result);
            }
            return result;
        }

        private void AddNumberRuleRowByHandle(GridControlEx grid, int rowHandle, List<DataRow> rows)
        {
            if (grid == null || grid.GridView == null || rows == null || rowHandle < 0) return;

            DataRow row = grid.GridView.GetDataRow(rowHandle);
            if (row == null || row.RowState == DataRowState.Deleted || row.RowState == DataRowState.Detached) return;
            if (rows.Contains(row)) return;

            rows.Add(row);
        }

        private void SaveBindModuleNumberRuleRows(TreeNodeData nodeData)
        {
            DataTable source = GetNumberRuleGridDataSource();
            if (source == null || nodeData == null || string.IsNullOrWhiteSpace(nodeData.BindModuleCode)) return;

            DeleteBindModuleNumberRuleRows(nodeData.BindModuleCode);

            DataTable dbColumns = BaseImpl.GetTableColumns(NumberRuleTableName);
            string autogrowColumn = MainImpl.GetAutogrowcolumn(NumberRuleTableName);
            foreach (DataRow row in source.Rows)
            {
                if (row.RowState == DataRowState.Deleted) continue;
                if (IsEmptyNumberRuleRow(row)) continue;

                InsertRuleRow(NumberRuleTableName, row, dbColumns, autogrowColumn);
            }
            source.AcceptChanges();
        }

        private void SaveOwnNumberRuleRows(TreeNodeData nodeData)
        {
            DataTable source = GetNumberRuleGridDataSource();
            if (source == null || nodeData == null || nodeData.SchemeId <= 0) return;

            DeleteRuleRows(SchemeControlTableName, nodeData.SchemeId);

            DataTable dbColumns = BaseImpl.GetTableColumns(SchemeControlTableName);
            string autogrowColumn = MainImpl.GetAutogrowcolumn(SchemeControlTableName);
            foreach (DataRow row in source.Rows)
            {
                if (row.RowState == DataRowState.Deleted) continue;
                if (IsEmptyNumberRuleRow(row)) continue;

                InsertRuleRow(SchemeControlTableName, row, dbColumns, autogrowColumn);
            }
            source.AcceptChanges();
        }

        private void SoftDeleteRuleRows(string tableName, int schemeId)
        {
            if (schemeId <= 0 || string.IsNullOrWhiteSpace(tableName) || !CodeSchemeStorage.TableExists(tableName) || !CodeSchemeStorage.ColumnExists(tableName, NumberRuleSchemeIdColumn)) return;

            if (CodeSchemeStorage.ColumnExists(tableName, DesignRuleUseColumn))
            {
                string sql = string.Format("UPDATE {0} SET {1} = 0 WHERE {2} = @SchemeId",
                    CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                    CodeSchemeStorage.QuoteSqlIdentifier(DesignRuleUseColumn),
                    CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn));
                SqlHelper.ExecuteNonQuery(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
                return;
            }

            string deleteSql = string.Format("DELETE FROM {0} WHERE {1} = @SchemeId",
                CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn));
            SqlHelper.ExecuteNonQuery(CommandType.Text, deleteSql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
        }

        private void DeleteRuleRows(string tableName, int schemeId)
        {
            if (schemeId <= 0 || string.IsNullOrWhiteSpace(tableName) || !CodeSchemeStorage.TableExists(tableName) || !CodeSchemeStorage.ColumnExists(tableName, NumberRuleSchemeIdColumn)) return;

            string sql = string.Format("DELETE FROM {0} WHERE {1} = @SchemeId",
                CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn));
            SqlHelper.ExecuteNonQuery(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
        }

        private void DeleteOppositeRuleRows(string tableName, int schemeId)
        {
            if (!RuleRowsExist(tableName, schemeId)) return;

            DeleteRuleRows(tableName, schemeId);
        }

        private bool RuleRowsExist(string tableName, int schemeId)
        {
            if (schemeId <= 0 || string.IsNullOrWhiteSpace(tableName) || !CodeSchemeStorage.TableExists(tableName) || !CodeSchemeStorage.ColumnExists(tableName, NumberRuleSchemeIdColumn)) return false;

            string sql = string.Format("SELECT COUNT(1) FROM {0} WHERE {1} = @SchemeId",
                CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn));
            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@SchemeId", schemeId) });
            return ToInt(result) > 0;
        }

        private bool BindModuleNumberRulesExist(string bindModuleCode)
        {
            if (string.IsNullOrWhiteSpace(bindModuleCode) || !CodeSchemeStorage.TableExists(NumberRuleTableName)) return false;

            List<string> moduleConditions = new List<string>();
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleModIdColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleModIdColumn)));
            }
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleBindModuleCodeColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleBindModuleCodeColumn)));
            }
            if (moduleConditions.Count == 0) return false;

            string useCondition = CodeSchemeStorage.ColumnExists(NumberRuleTableName, DesignRuleUseColumn)
                ? string.Format(" AND ISNULL({0}, 1) = 1", CodeSchemeStorage.QuoteSqlIdentifier(DesignRuleUseColumn))
                : string.Empty;
            string sql = string.Format("SELECT COUNT(1) FROM {0} WHERE ({1}){2}",
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleTableName),
                string.Join(" OR ", moduleConditions),
                useCondition);
            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@BindModuleCode", bindModuleCode) });
            return ToInt(result) > 0;
        }

        private bool BindModuleOwnedByOtherScheme(string bindModuleCode, int currentSchemeId, out string ownerSchemeName)
        {
            ownerSchemeName = string.Empty;
            if (string.IsNullOrWhiteSpace(bindModuleCode) || !CodeSchemeStorage.TableExists(SchemeTableName)) return false;

            string sql = @"
SELECT TOP 1 SchemeName
FROM P_CodeSchemeTab
WHERE ISNULL(BindModule, 0) = 1
  AND ISNULL(BindModuleCode, '') = @BindModuleCode
  AND SchemeId <> @SchemeId
ORDER BY SchemeId";
            object result = SqlHelper.ExecuteScalar(CommandType.Text, sql, new SqlParameter[]
            {
                new SqlParameter("@BindModuleCode", bindModuleCode),
                new SqlParameter("@SchemeId", currentSchemeId)
            });
            ownerSchemeName = result == null || result == DBNull.Value ? string.Empty : result + "";
            if (string.IsNullOrWhiteSpace(ownerSchemeName)) ownerSchemeName = "未命名方案";
            return result != null && result != DBNull.Value;
        }

        private void DeleteBindModuleNumberRuleRows(string bindModuleCode)
        {
            if (string.IsNullOrWhiteSpace(bindModuleCode) || !CodeSchemeStorage.TableExists(NumberRuleTableName)) return;

            List<string> moduleConditions = new List<string>();
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleModIdColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleModIdColumn)));
            }
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleBindModuleCodeColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleBindModuleCodeColumn)));
            }
            if (moduleConditions.Count == 0) return;

            string sql = string.Format("DELETE FROM {0} WHERE ({1})",
                CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleTableName),
                string.Join(" OR ", moduleConditions));
            SqlHelper.ExecuteNonQuery(CommandType.Text, sql, new SqlParameter[] { new SqlParameter("@BindModuleCode", bindModuleCode) });
        }

        private bool IsEmptyNumberRuleRow(DataRow row)
        {
            if (row == null || row.RowState == DataRowState.Deleted) return true;

            foreach (DataColumn column in row.Table.Columns)
            {
                if (IsNumberRuleSystemColumn(column.ColumnName)) continue;
                if (!string.IsNullOrWhiteSpace(row[column] + "")) return false;
            }
            return true;
        }

        private bool IsNumberRuleSystemColumn(string columnName)
        {
            if (IsNumberRuleKeyColumn(columnName)) return true;

            string[] systemColumns =
            {
                "ID",
                "Id",
                "id",
                DesignRuleUseColumn,
                DesignRuleSortColumn,
                "CreateUserId",
                "CreateUserName",
                "CreateTime",
                "ModifyUserId",
                "ModifyUserName",
                "ModifyTime"
            };
            return systemColumns.Any(n => string.Equals(n, columnName, StringComparison.OrdinalIgnoreCase));
        }

        private bool IsNumberRuleKeyColumn(string columnName)
        {
            return GetNumberRuleKeyColumnNames().Any(n => string.Equals(n, columnName, StringComparison.OrdinalIgnoreCase));
        }

        private void InsertRuleRow(string tableName, DataRow row, DataTable dbColumns, string autogrowColumn)
        {
            if (string.IsNullOrWhiteSpace(tableName) || row == null || dbColumns == null) return;

            List<string> fields = new List<string>();
            List<string> values = new List<string>();
            List<SqlParameter> parameters = new List<SqlParameter>();
            int parameterIndex = 0;
            foreach (DataColumn dbColumn in dbColumns.Columns)
            {
                string columnName = dbColumn.ColumnName;
                if (string.Equals(columnName, autogrowColumn, StringComparison.OrdinalIgnoreCase)) continue;
                if (row.Table == null || !row.Table.Columns.Contains(columnName)) continue;
                if (IsEmptyRowValue(row[columnName])) continue;

                string parameterName = "@P" + parameterIndex++;
                fields.Add(CodeSchemeStorage.QuoteSqlIdentifier(columnName));
                values.Add(parameterName);
                parameters.Add(new SqlParameter(parameterName, GetDbColumnValue(row[columnName], dbColumn.DataType)));
            }

            if (fields.Count == 0) return;

            string sql = string.Format("INSERT INTO {0}({1}) VALUES({2})",
                CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                string.Join(",", fields),
                string.Join(",", values));
            SqlHelper.ExecuteNonQuery(CommandType.Text, sql, parameters.ToArray());
        }

        private object GetDbColumnValue(object value, Type dataType)
        {
            if (value == null || value == DBNull.Value) return DBNull.Value;

            string text = value + "";
            if (string.IsNullOrWhiteSpace(text))
            {
                if (dataType == typeof(string)) return string.Empty;
                if (dataType == typeof(DateTime)) return DBNull.Value;
                if (dataType == typeof(bool)) return false;
                if (dataType == typeof(decimal) || dataType == typeof(double) || dataType == typeof(float) ||
                    dataType == typeof(int) || dataType == typeof(long) || dataType == typeof(short) || dataType == typeof(byte))
                {
                    return 0;
                }
                return DBNull.Value;
            }

            if (dataType == typeof(bool)) return ToBool(value);
            try
            {
                return Convert.ChangeType(value, dataType);
            }
            catch
            {
                return value;
            }
        }

        private DataTable LoadNumberRuleSchemeRows(TreeNodeData nodeData)
        {
            CodeSchemeStorage.EnsureRuleStorage();
            string tableName = GetRuleTableName(nodeData);
            DataTable table;
            if (nodeData == null || nodeData.SchemeId <= 0)
            {
                table = CreateEmptyNumberRuleTable(tableName);
                table.AcceptChanges();
                return table;
            }

            List<SqlParameter> parameters = new List<SqlParameter>();
            string whereSql = GetRuleTableWhereSql(tableName, nodeData, parameters);
            if (string.IsNullOrWhiteSpace(whereSql))
            {
                table = CreateEmptyNumberRuleTable(tableName);
                table.AcceptChanges();
                return table;
            }

            string useCondition = CodeSchemeStorage.ColumnExists(tableName, DesignRuleUseColumn)
                ? string.Format(" AND ISNULL({0}, 1) = 1", CodeSchemeStorage.QuoteSqlIdentifier(DesignRuleUseColumn))
                : string.Empty;
            string sql = string.Format("SELECT * FROM {0} WHERE {1}{2}{3}",
                CodeSchemeStorage.QuoteSqlIdentifier(tableName),
                whereSql,
                useCondition,
                GetNumberRuleOrderByClause(tableName));
            table = SqlHelper.ExecuteDataTable(sql, parameters.ToArray());
            if (table == null) table = CreateEmptyNumberRuleTable(tableName);
            EnsureNumberRuleDataTableKeyColumns(table, tableName);
            SetNumberRuleSourceTable(table, tableName);
            table.AcceptChanges();
            return table;
        }

        private string GetRuleTableWhereSql(string tableName, TreeNodeData nodeData, List<SqlParameter> parameters)
        {
            if (string.IsNullOrWhiteSpace(tableName) || nodeData == null) return string.Empty;

            if (!string.Equals(tableName, NumberRuleTableName, StringComparison.OrdinalIgnoreCase))
            {
                if (!CodeSchemeStorage.ColumnExists(tableName, NumberRuleSchemeIdColumn) || nodeData.SchemeId <= 0) return string.Empty;
                if (parameters != null) parameters.Add(new SqlParameter("@SchemeId", nodeData.SchemeId));
                return string.Format("{0} = @SchemeId", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleSchemeIdColumn));
            }

            string bindModuleCode = nodeData.BindModuleCode;
            if (IsDesignMode() && this.chkBindModule.Checked)
            {
                string selectedModuleCode = GetSelectedBindModuleCode();
                if (!string.IsNullOrWhiteSpace(selectedModuleCode)) bindModuleCode = selectedModuleCode;
            }
            if (string.IsNullOrWhiteSpace(bindModuleCode)) return string.Empty;

            List<string> moduleConditions = new List<string>();
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleModIdColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleModIdColumn)));
            }
            if (CodeSchemeStorage.ColumnExists(NumberRuleTableName, NumberRuleBindModuleCodeColumn))
            {
                moduleConditions.Add(string.Format("ISNULL(CONVERT(NVARCHAR(100), {0}), '') = @BindModuleCode", CodeSchemeStorage.QuoteSqlIdentifier(NumberRuleBindModuleCodeColumn)));
            }
            if (moduleConditions.Count == 0) return string.Empty;

            if (parameters != null) parameters.Add(new SqlParameter("@BindModuleCode", bindModuleCode));
            return "(" + string.Join(" OR ", moduleConditions) + ")";
        }

        private bool EnsureNumberRuleGridSourceTable(string tableName, bool markRowsAdded)
        {
            if (string.IsNullOrWhiteSpace(tableName)) return false;

            DataTable source = GetNumberRuleGridDataSource();
            if (source == null)
            {
                BindNumberRuleGridRows(CreateEmptyNumberRuleTable(tableName));
                return true;
            }

            string sourceTableName = GetNumberRuleSourceTable(source);
            if (string.Equals(sourceTableName, tableName, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            BindNumberRuleGridRows(ConvertNumberRuleRowsToTable(source, tableName, markRowsAdded));
            return true;
        }

        private DataTable ConvertNumberRuleRowsToTable(DataTable source, string tableName, bool markRowsAdded)
        {
            DataTable target = CreateEmptyNumberRuleTable(tableName);
            string autogrowColumn = MainImpl.GetAutogrowcolumn(tableName);

            if (source != null)
            {
                foreach (DataRow sourceRow in source.Rows)
                {
                    if (sourceRow.RowState == DataRowState.Deleted || IsEmptyNumberRuleRow(sourceRow)) continue;

                    DataRow targetRow = target.NewRow();
                    foreach (DataColumn targetColumn in target.Columns)
                    {
                        string columnName = targetColumn.ColumnName;
                        if (!string.IsNullOrWhiteSpace(autogrowColumn) &&
                            string.Equals(columnName, autogrowColumn, StringComparison.OrdinalIgnoreCase))
                        {
                            continue;
                        }
                        if (!source.Columns.Contains(columnName)) continue;

                        object value = sourceRow[columnName];
                        if (value == DBNull.Value) continue;
                        targetRow[columnName] = GetDbColumnValue(value, targetColumn.DataType);
                    }
                    target.Rows.Add(targetRow);
                }
            }

            SetNumberRuleSourceTable(target, tableName);
            if (!markRowsAdded)
            {
                target.AcceptChanges();
            }
            return target;
        }

        private void SetNumberRuleSourceTable(DataTable table, string tableName)
        {
            if (table == null) return;

            table.TableName = string.IsNullOrWhiteSpace(tableName) ? string.Empty : tableName;
            table.ExtendedProperties[NumberRuleSourceTableProperty] = table.TableName;
        }

        private string GetNumberRuleSourceTable(DataTable table)
        {
            if (table == null) return string.Empty;

            object value = table.ExtendedProperties[NumberRuleSourceTableProperty];
            if (!string.IsNullOrWhiteSpace(value + "")) return value + "";
            return table.TableName;
        }

        private string GetRuleTableName(TreeNodeData nodeData)
        {
            return IsSchemeBindModule(nodeData) ? NumberRuleTableName : SchemeControlTableName;
        }

        private bool IsSchemeBindModule(TreeNodeData nodeData)
        {
            if (IsDesignMode())
            {
                return this.chkBindModule.Checked;
            }
            return nodeData != null && nodeData.BindModule;
        }

        private DataTable CreateEmptyNumberRuleTable()
        {
            return CreateEmptyNumberRuleTable(NumberRuleTableName);
        }

        private DataTable CreateEmptyNumberRuleTable(string tableName)
        {
            DataTable table = BaseImpl.GetTableColumns(string.IsNullOrWhiteSpace(tableName) ? NumberRuleTableName : tableName);
            EnsureNumberRuleDataTableKeyColumns(table);
            SetNumberRuleSourceTable(table, string.IsNullOrWhiteSpace(tableName) ? NumberRuleTableName : tableName);
            return table;
        }

        private string GetNumberRuleOrderByClause(string tableName)
        {
            if (CodeSchemeStorage.ColumnExists(tableName, DesignRuleSortColumn))
            {
                return " ORDER BY " + CodeSchemeStorage.QuoteSqlIdentifier(DesignRuleSortColumn);
            }
            if (CodeSchemeStorage.ColumnExists(tableName, "Orderid"))
            {
                return " ORDER BY " + CodeSchemeStorage.QuoteSqlIdentifier("Orderid");
            }
            if (CodeSchemeStorage.ColumnExists(tableName, "ID"))
            {
                return " ORDER BY " + CodeSchemeStorage.QuoteSqlIdentifier("ID");
            }
            if (CodeSchemeStorage.ColumnExists(tableName, "SchemeControlId"))
            {
                return " ORDER BY " + CodeSchemeStorage.QuoteSqlIdentifier("SchemeControlId");
            }
            return string.Empty;
        }

        private void BindNumberRuleGridRows(DataTable table)
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null) return;

            EnsureNumberRuleDataTableKeyColumns(table);
            this._loadingDesignRuleGrid = true;
            try
            {
                grid.SetGridViewDataSource(table ?? CreateEmptyNumberRuleTable(), false);
                ConfigureDesignRuleGridColumns();
            }
            finally
            {
                this._loadingDesignRuleGrid = false;
            }
        }

        private bool EnsureNumberRuleGridReady()
        {
            try
            {
                InitializeNumberRuleGrid();
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                MessageUtil.Show("编码规则表格加载失败：" + ex.Message);
                return false;
            }
        }

        private void InitializeNumberRuleGridWithPrompt()
        {
            try
            {
                InitializeNumberRuleGrid();
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                ClearDesignRuleGrid();
                MessageUtil.Show("编码规则表格加载失败：" + ex.Message);
            }
        }

        private void InitializeNumberRuleGrid()
        {
            string moduleCode = GetNumberRuleGridModuleCode();
            if (this._numberRuleGridInitialized &&
                string.Equals(this._numberRuleGridModuleCode, moduleCode, StringComparison.OrdinalIgnoreCase))
            {
                ApplyDesignRuleGridEditState();
                return;
            }

            if (string.IsNullOrWhiteSpace(moduleCode))
            {
                throw new InvalidOperationException("未获取到 ModuleCode，无法加载编码规则表格。");
            }

            DataRow modelRow = MainImpl.GetSystemdllTab(moduleCode);
            if (modelRow == null)
            {
                throw new InvalidOperationException(string.Format("未找到模块[{0}]的系统配置。", moduleCode));
            }

            ModuleModel sysModel = new ModuleModel(modelRow);
            EnsureNumberRuleMainTable(sysModel);

            this.gridDesignRules.VisibleOperPanel = false;
            this.gridDesignRules.VisibleSearchPanel = true;
            this.gridDesignRules.InitializeControl(sysModel, CreateNumberRuleGridModel(moduleCode));
            this.gridDesignRules.HideTopToolPanel();
            this._numberRuleGridInitialized = true;
            this._numberRuleGridModuleCode = moduleCode;
            ApplyDesignRuleGridEditState();
        }

        private string GetNumberRuleGridModuleCode()
        {
            return this.Model == null ? string.Empty : this.Model.ModuleCode;
        }

        private DynamicModuleModel CreateNumberRuleGridModel(string moduleCode)
        {
            return new DynamicModuleModel(new string[]
            {
                this.Text,
                ERPInfo.Instance.UserId,
                ERPInfo.Instance.UserName,
                GetNumberRuleGridPrivilege(),
                moduleCode,
                GetNumberRuleGridModuleIdText(),
                moduleCode,
                string.Empty,
                string.Empty
            });
        }

        private string GetNumberRuleGridPrivilege()
        {
            if (this.Model == null || string.IsNullOrWhiteSpace(this.Model.Privilege))
            {
                return "1";
            }
            return this.Model.Privilege;
        }

        private string GetNumberRuleGridModuleIdText()
        {
            return this.Model == null || this.Model.ModuleId <= 0 ? string.Empty : this.Model.ModuleId + "";
        }

        private void EnsureNumberRuleMainTable(ModuleModel sysModel)
        {
            string tableName = sysModel == null ? string.Empty : (sysModel.MenuTable + "").Trim();
            if (!string.Equals(tableName, NumberRuleTableName, StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(string.Format(
                    "编码规则表格主表配置错误：当前为[{0}]，必须为[{1}]。",
                    string.IsNullOrWhiteSpace(tableName) ? "空" : tableName,
                    NumberRuleTableName));
            }

            CodeSchemeStorage.EnsureRuleStorage();
        }

        private List<DataRow> GetUsedDesignRuleRows()
        {
            List<DataRow> result = new List<DataRow>();
            if (this._designRuleTable == null) return result;

            result = this._designRuleTable.Rows.Cast<DataRow>()
                .Where(IsDesignRuleRowUsed)
                .OrderBy(n => ToPositiveInt(GetSourceValue(n, DesignRuleSortColumn), int.MaxValue))
                .ThenBy(n => this._designRuleTable.Rows.IndexOf(n))
                .ToList();
            return result;
        }

        private bool IsDesignRuleRowUsed(DataRow row)
        {
            if (row == null || !row.Table.Columns.Contains(DesignRuleUseColumn)) return false;
            return ToBool(row[DesignRuleUseColumn]);
        }

        private void BindEmptyDesignRuleGrid()
        {
            InitializeNumberRuleGridWithPrompt();
            BindNumberRuleGridRows(CreateEmptyNumberRuleTable(GetRuleTableName(null)));
        }

        private void ReloadCurrentSchemeDesignRules()
        {
            if (!IsDesignMode()) return;
            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (nodeData == null || !NodeTypeScheme.Equals(nodeData.NodeType))
            {
                InitializeNumberRuleGridWithPrompt();
                return;
            }

            LoadSchemeDesignRules(null);
        }

        private void LoadSchemeDesignRules(DataTable schemeControls)
        {
            InitializeNumberRuleGridWithPrompt();
            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (schemeControls == null)
            {
                schemeControls = LoadNumberRuleSchemeRows(nodeData);
            }
            BindNumberRuleGridRows(schemeControls);
        }

        private DataTable LoadModuleLeftSourceTable(string moduleCode)
        {
            this._moduleLeftSourceRow = null;
            this._moduleLeftSourceTable = new DataTable();
            if (string.IsNullOrWhiteSpace(moduleCode)) return this._moduleLeftSourceTable;

            try
            {
                this._moduleLeftSourceRow = BaseModuleImpl.GetBaseLeftTreeField(moduleCode);
                if (this._moduleLeftSourceRow != null)
                {
                    string fieldSql = GetRowValue(this._moduleLeftSourceRow, "fieldsql");
                    if (!string.IsNullOrWhiteSpace(fieldSql))
                    {
                        this._moduleLeftSourceTable = BaseImpl.GetDataTableResult(fieldSql);
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
                this._moduleLeftSourceTable = new DataTable();
            }
            return this._moduleLeftSourceTable;
        }

        private DataTable CreateDesignRuleTable()
        {
            DataTable table = new DataTable();
            table.Columns.Add(DesignRuleUseColumn, typeof(int));
            table.Columns.Add(DesignRuleSortColumn, typeof(int));
            table.Columns.Add(DesignRuleUserNameColumn, typeof(string));
            table.Columns.Add(DesignRuleFieldNameColumn, typeof(string));
            table.Columns.Add(DesignRuleFieldTypeColumn, typeof(int));
            return table;
        }

        private void AppendSavedDesignRuleRows(DataTable designTable, DataTable schemeControls)
        {
            if (designTable == null || schemeControls == null || schemeControls.Rows.Count == 0) return;

            HashSet<DataRow> usedSourceRows = new HashSet<DataRow>();
            int defaultSort = 1;
            foreach (DataRow schemeRow in schemeControls.Rows)
            {
                string fieldName = GetSourceValue(schemeRow, "FieldName");
                if (string.IsNullOrWhiteSpace(fieldName)) continue;

                DataRow sourceRow = GetMatchedFieldConfigRow(this._fieldConfigTable, fieldName);
                if (sourceRow != null)
                {
                    usedSourceRows.Add(sourceRow);
                }

                AddDesignRuleRow(designTable, sourceRow, schemeRow, true, ToPositiveInt(GetSourceValue(schemeRow, "SortNo"), defaultSort));
                defaultSort++;
            }

            designTable.ExtendedProperties["UsedSourceRows"] = usedSourceRows;
        }

        private void AppendAvailableDesignRuleRows(DataTable designTable)
        {
            if (designTable == null || this._fieldConfigTable == null) return;

            HashSet<DataRow> usedSourceRows = designTable.ExtendedProperties["UsedSourceRows"] as HashSet<DataRow>;
            int sortNo = designTable.Rows.Count + 1;
            foreach (DataRow sourceRow in this._fieldConfigTable.Rows)
            {
                if (usedSourceRows != null && usedSourceRows.Contains(sourceRow)) continue;

                string fieldName = GetSourceValue(sourceRow, FindColumnName(this._fieldConfigTable, "fieldname", "fieldName", "FieldName"));
                if (string.IsNullOrWhiteSpace(fieldName)) continue;

                AddDesignRuleRow(designTable, sourceRow, null, false, sortNo);
                sortNo++;
            }
        }

        private void AddDesignRuleRow(DataTable designTable, DataRow sourceRow, DataRow schemeRow, bool useEd, int sortNo)
        {
            if (designTable == null) return;

            string fieldName = GetSourceValue(sourceRow, FindColumnName(sourceRow == null ? null : sourceRow.Table, "fieldname", "fieldName", "FieldName"));
            if (string.IsNullOrWhiteSpace(fieldName))
            {
                fieldName = GetSourceValue(schemeRow, "FieldName");
            }
            if (string.IsNullOrWhiteSpace(fieldName)) return;

            DataRow row = designTable.NewRow();
            row[DesignRuleUseColumn] = useEd ? 1 : 0;
            row[DesignRuleSortColumn] = sortNo <= 0 ? designTable.Rows.Count + 1 : sortNo;
            row[DesignRuleUserNameColumn] = GetViewUserName(sourceRow, schemeRow);
            if (string.IsNullOrWhiteSpace(row[DesignRuleUserNameColumn] + ""))
            {
                row[DesignRuleUserNameColumn] = fieldName;
            }
            row[DesignRuleFieldNameColumn] = fieldName;
            row[DesignRuleFieldTypeColumn] = GetFieldTypeId(sourceRow);
            designTable.Rows.Add(row);
        }

        private void BindDesignRuleGrid(DataTable table)
        {
            this._loadingDesignRuleGrid = true;
            try
            {
                GridControlEx grid = DesignRuleGrid;
                if (grid == null) return;

                string gridModuleCode = GetDesignRuleGridModuleCode();
                DataTable gridColumns = LoadDesignRuleGridColumns(gridModuleCode);
                grid.SetEditColumns(gridColumns, GetDesignRuleGridCustomKey(gridModuleCode));
                ApplyDesignRuleGridStyle(grid);
                grid.SetGridViewDataSource(table, false);
                ConfigureDesignRuleGridColumns();
            }
            finally
            {
                this._loadingDesignRuleGrid = false;
            }
        }

        private DataTable LoadDesignRuleGridColumns(string moduleCode)
        {
            if (string.IsNullOrWhiteSpace(moduleCode))
            {
                throw new InvalidOperationException("未获取到 ModuleCode，无法加载表格列配置。");
            }

            DataTable gridColumns = BaseModuleImpl.GetBaseGridColumns(moduleCode);
            if (gridColumns == null || gridColumns.Rows.Count == 0)
            {
                throw new InvalidOperationException(string.Format("模块[{0}]未配置表格列。", moduleCode));
            }

            return gridColumns;
        }

        private void ClearDesignRuleGrid()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null) return;

            if (grid.GridView != null)
            {
                grid.GridView.Columns.Clear();
            }
            grid.SetGridViewDataSource(CreateDesignRuleTable(), false);
        }

        private string GetDesignRuleGridModuleCode()
        {
            if (this.Model != null && !string.IsNullOrWhiteSpace(this.Model.ModuleCode))
            {
                return this.Model.ModuleCode;
            }
            return GetCurrentModuleCode();
        }

        private string GetDesignRuleGridCustomKey(string moduleCode)
        {
            if (!string.IsNullOrWhiteSpace(moduleCode))
            {
                try
                {
                    DataRow modelRow = MainImpl.GetSystemdllTab(moduleCode);
                    if (modelRow != null)
                    {
                        ModuleModel sysModel = new ModuleModel(modelRow);
                        if (!string.IsNullOrWhiteSpace(sysModel.FormKey))
                        {
                            return GridCustomColumnStruct.BaseMainGridView + sysModel.FormKey;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Instance.WriteError(ex);
                }
            }

            return GridCustomColumnStruct.BaseMainGridView + "CodeDesign_" + moduleCode;
        }

        private void ApplyDesignRuleGridStyle(GridControlEx grid)
        {
            if (grid == null || grid.GridView == null) return;

            if (SystemInfo.Instance.GridRowFontSize > 0)
            {
                grid.GridView.Appearance.Row.Font = new Font("微软雅黑", SystemInfo.Instance.GridRowFontSize);
            }
            if (SystemInfo.Instance.GridRowHeight > 0)
            {
                grid.GridView.ColumnPanelRowHeight = grid.GridView.RowHeight = SystemInfo.Instance.GridRowHeight;
            }
        }

        private void ConfigureDesignRuleGridColumns()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null || grid.GridView == null) return;

            ApplyDesignRuleGridEditState();
            if (!IsDesignMode()) return;

            GridColumn useColumn = grid.GridView.Columns[DesignRuleUseColumn];
            if (useColumn != null)
            {
                useColumn.OptionsColumn.AllowEdit = true;
                useColumn.OptionsColumn.ReadOnly = false;
            }

            GridColumn sortColumn = grid.GridView.Columns[DesignRuleSortColumn];
            if (sortColumn != null)
            {
                sortColumn.OptionsColumn.AllowEdit = true;
                sortColumn.OptionsColumn.ReadOnly = false;
            }
        }

        private void ApplyDesignRuleGridEditState()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null || grid.GridView == null) return;

            bool designMode = IsDesignMode();
            grid.GridView.OptionsBehavior.Editable = designMode;
            grid.GridView.OptionsBehavior.ReadOnly = !designMode;

            if (designMode) return;

            foreach (GridColumn column in grid.GridView.Columns)
            {
                column.OptionsColumn.AllowEdit = false;
                column.OptionsColumn.ReadOnly = true;
            }
        }

        private void OnDesignRuleCellValueChanging(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        {
            if (this._loadingDesignRuleGrid || !IsDesignMode()) return;
            if (this._currentSchemeNode != null)
            {
                this._currentSchemeDirty = true;
            }

            if (e.Column != null && string.Equals(e.Column.FieldName, DesignRuleUseColumn, StringComparison.OrdinalIgnoreCase))
            {
                GridControlEx grid = DesignRuleGrid;
                if (grid != null && grid.GridView != null)
                {
                    grid.GridView.SetRowCellValue(e.RowHandle, e.Column, e.Value);
                }
            }
        }

        private void OnDesignRuleCellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)
        {
            if (this._loadingDesignRuleGrid || !IsDesignMode()) return;
            if (this._currentSchemeNode == null) return;

            this._currentSchemeDirty = true;
            UpdateSchemeStatus();
        }

        private DataTable LoadFieldConfigTable(string moduleCode, bool showMessage)
        {
            this._fieldConfigTable = new DataTable();

            if (string.IsNullOrWhiteSpace(moduleCode))
            {
                this.lblDesignerStatus.Text = "未获取到 ModuleCode，无法加载字段配置";
                return this._fieldConfigTable;
            }

            try
            {
                DataTable gridColumns = BaseModuleImpl.GetBaseGridColumns(moduleCode);
                this._fieldConfigTable = gridColumns == null ? new DataTable() : gridColumns.Copy();
            }
            catch (Exception ex)
            {
                if (showMessage)
                {
                    MessageUtil.Show("字段配置加载失败：" + ex.Message);
                }
            }

            return this._fieldConfigTable;
        }

        private string GetCurrentModuleCode()
        {
            TreeNodeData currentData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            if (currentData != null)
            {
                if (IsDesignMode() && this.chkBindModule.Checked)
                {
                    string selectedBindModuleCode = GetSelectedBindModuleCode();
                    if (!string.IsNullOrWhiteSpace(selectedBindModuleCode)) return selectedBindModuleCode;
                }

                if (currentData.BindModule && !string.IsNullOrWhiteSpace(currentData.BindModuleCode))
                {
                    return currentData.BindModuleCode;
                }

                if (currentData.MenuRow != null)
                {
                    string purviewId = GetRowValue(currentData.MenuRow, "PurviewId");
                    if (!string.IsNullOrWhiteSpace(purviewId)) return purviewId;
                }
            }

            if (this.Model != null && !string.IsNullOrWhiteSpace(this.Model.ModuleCode))
            {
                return this.Model.ModuleCode;
            }
            return string.Empty;
        }

        private string FindColumnName(DataTable table, params string[] candidates)
        {
            if (table == null || candidates == null) return string.Empty;

            foreach (string candidate in candidates)
            {
                foreach (DataColumn column in table.Columns)
                {
                    if (string.Equals(column.ColumnName, candidate, StringComparison.OrdinalIgnoreCase))
                    {
                        return column.ColumnName;
                    }
                }
            }
            return string.Empty;
        }

        private string GetSourceValue(DataRow row, string columnName)
        {
            if (row == null || string.IsNullOrWhiteSpace(columnName) || !row.Table.Columns.Contains(columnName)) return string.Empty;
            return row[columnName] + "";
        }

        private int ToPositiveInt(object value, int defaultValue)
        {
            int result;
            return int.TryParse(value + "", out result) && result > 0 ? result : defaultValue;
        }

        private int GetFieldTypeId(DataRow row)
        {
            if (row == null || row.Table == null) return 0;

            foreach (string columnName in GetFieldTypeIdColumnCandidates())
            {
                string actualColumnName = FindColumnName(row.Table, columnName);
                if (string.IsNullOrWhiteSpace(actualColumnName)) continue;

                int fieldTypeId = ToPositiveInt(GetSourceValue(row, actualColumnName), 0);
                if (fieldTypeId > 0) return fieldTypeId;
            }
            return 0;
        }

        private string[] GetFieldTypeIdColumnCandidates()
        {
            return new string[]
            {
                "fieldTypeId",
                "FieldTypeId",
                "fieldtypeid",
                "fieldSqlTag",
                "fieldsqlTag",
                "fieldsqltag",
                "FieldSqlTag",
                "ControlType",
                "controlType",
                "FieldType",
                "fieldType",
                "typeid",
                "TypeId"
            };
        }

        private string GetViewUserName(DataRow sourceRow, DataRow schemeRow)
        {
            string userName = GetSourceValue(sourceRow, FindColumnName(sourceRow == null ? null : sourceRow.Table, "username", "username1", "UserName", "sysname", "SysName", "controlLabel", "ControlLabel"));
            if (!string.IsNullOrWhiteSpace(userName)) return userName;

            return GetSourceValue(schemeRow, "UserName");
        }

        private FieldDesignItem CreateFieldDesignItem(DataRow row)
        {
            return CreateFieldDesignItem(row, null);
        }

        private FieldDesignItem CreateFieldDesignItem(DataRow fieldRow, DataRow schemeControlRow)
        {
            string fieldName = GetSourceValue(fieldRow, "FieldName");
            if (string.IsNullOrWhiteSpace(fieldName))
            {
                fieldName = GetSourceValue(schemeControlRow, "FieldName");
            }
            if (string.IsNullOrWhiteSpace(fieldName)) return null;

            DataRow configRow = GetMatchedFieldConfigRow(this._fieldConfigTable, fieldName);

            string userName = GetSourceValue(fieldRow, "UserName");
            if (string.IsNullOrWhiteSpace(userName))
            {
                userName = GetViewUserName(configRow, schemeControlRow);
            }
            if (string.IsNullOrWhiteSpace(userName))
            {
                userName = GetSourceValue(schemeControlRow, "UserName");
            }
            if (string.IsNullOrWhiteSpace(userName))
            {
                userName = fieldName;
            }

            int fieldTypeId = GetFieldTypeId(configRow);

            return new FieldDesignItem
            {
                UserName = userName,
                FieldName = fieldName,
                FieldTypeId = fieldTypeId,
                ControlWidth = ToPositiveInt(GetSourceValue(schemeControlRow, "ControlWidth"), DesignFieldControlWidth),
                ControlHeight = ToPositiveInt(GetSourceValue(schemeControlRow, "ControlHeight"), DesignFieldControlHeight)
            };
        }

        private void UpdateSchemeStatus()
        {
            TreeNodeData nodeData = this._currentSchemeNode == null ? null : this._currentSchemeNode.Tag as TreeNodeData;
            string schemeName = nodeData == null ? "当前方案" : nodeData.SchemeName;
            int count = GetNumberRuleGridRowCount();
            this.lblDesignerStatus.Text = string.Format("{0}，已设置 {1} 条规则", schemeName, count);
        }

        private int GetNumberRuleGridRowCount()
        {
            GridControlEx grid = DesignRuleGrid;
            if (grid == null || grid.GridView == null) return 0;
            return grid.GridView.DataRowCount;
        }

    }
}