using BLL;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

namespace FineUIPro.Web.JDGL.SGManPower
{
    public partial class ManPowerPlanGrid : PageBase
    {
        #region Page_Init

        // 注意：动态创建的代码需要放置于Page_Init（不是Page_Load），这样每次构造页面时都会执行
        protected void Page_Init(object sender, EventArgs e)
        {
            InitGrid();
        }

        public DataTable GridTable = new DataTable();

        private void InitGrid()
        {
            FineUIPro.BoundField bf;
            FineUIPro.RenderField rf;
            FineUIPro.TextBox txTextBox;

            // 设置Grid的编辑属性
            Grid1.AllowCellEditing = true;
            Grid1.ClicksToEdit = 1;
            Grid1.EnableAfterEditEvent = true;

            UnitId = Request.Params["UnitId"];
            StartTime = Request.Params["StartTime"];
            EndTime = Request.Params["EndTime"];

            GridTable.Columns.Add("Id");
            // 添加主键列用于编辑操作
            GridTable.Columns.Add("PrimaryKeyMap"); // 用于存储原始记录的ID

            // 添加隐藏列来存储额外的ID信息
            GridTable.Columns.Add("UnitId");
            GridTable.Columns.Add("UnitWorkId");
            GridTable.Columns.Add("WorkPostId");

            ListItem[] list = new ListItem[6];
            list[0] = new ListItem("序号", "SerialNumber");
            list[1] = new ListItem("单位", "UnitName");
            list[2] = new ListItem("装置", "UnitWorkName");
            list[3] = new ListItem("岗位", "WorkPostName");
            list[4] = new ListItem("版本", "Version");
            list[5] = new ListItem("累计", "TotalCount");

            foreach (var item in list)
            {
                bf = new FineUIPro.BoundField();
                bf.ColumnID = item.Value;
                bf.DataField = item.Value;
                bf.HeaderText = item.Text;
                bf.HeaderTextAlign = TextAlign.Center;
                bf.TextAlign = TextAlign.Center;
                bf.Locked = true;
                Grid1.Columns.Add(bf);
                GridTable.Columns.Add(item.Value);
            }

            // 动态获取日期范围
            DateTime startDate = Convert.ToDateTime(StartTime);
            DateTime endDate = Convert.ToDateTime(EndTime);
            var dateRange = Enumerable.Range(0, (endDate - startDate).Days + 1)
                .Select(i => startDate.AddDays(i))
                .ToList();

            // 按年分组日期
            var groupedByYear = dateRange.GroupBy(d => d.Year)
                .OrderBy(g => g.Key)
                .ToList();

            foreach (var yearGroup in groupedByYear)
            {
                GroupField yearGroupField = new GroupField();
                yearGroupField.HeaderText = $"{yearGroup.Key}年";
                yearGroupField.TextAlign = TextAlign.Center;

                // 按月分组
                var groupedByMonth = yearGroup.GroupBy(d => d.Month)
                    .OrderBy(g => g.Key)
                    .ToList();

                foreach (var monthGroup in groupedByMonth)
                {
                    GroupField monthGroupField = new GroupField();
                    monthGroupField.HeaderText = $"{monthGroup.Key}月";
                    monthGroupField.TextAlign = TextAlign.Center;

                    // 添加具体日期的列
                    foreach (var date in monthGroup.OrderBy(d => d))
                    {
                        rf = new FineUIPro.RenderField();
                        rf.ColumnID = date.ToString("yyyy-MM-dd");
                        rf.DataField = date.ToString("yyyy-MM-dd");
                        rf.HeaderText = date.ToString("dd");
                        rf.HeaderTextAlign = TextAlign.Center;
                        rf.TextAlign = TextAlign.Center;
                        txTextBox = new FineUIPro.TextBox();
                        txTextBox.ID = "txt" + date.ToString("yyyy-MM-dd");
                        rf.Editor.Add(txTextBox);
                        monthGroupField.Columns.Add(rf);
                        GridTable.Columns.Add(date.ToString("yyyy-MM-dd"));
                    }

                    yearGroupField.Columns.Add(monthGroupField);
                }

                Grid1.Columns.Add(yearGroupField);
            }
        }

        #endregion

        public string UnitId
        {
            get => (string)ViewState["UnitId"];
            set => ViewState["UnitId"] = value;
        }

        public string StartTime
        {
            get => (string)ViewState["StartTime"];
            set => ViewState["StartTime"] = value;
        }

        public string EndTime
        {
            get => (string)ViewState["EndTime"];
            set => ViewState["EndTime"] = value;
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                this.GetButtonPower();
                Funs.DropDownPageSize(this.ddlPageSize);
                // 设置Grid的PageSize与下拉框默认值一致
                Grid1.PageSize = Convert.ToInt32(ddlPageSize.SelectedValue);
                WorkPostService.InitWorkPostDropDownList(this.drpWorkPost, true); //岗位
                UnitWorkService.InitUnitWorkDownList(drpUnitWork, this.CurrUser.LoginProjectId, true); //单位工程(装置)

                //版本
                this.drpVersion.DataTextField = "Version";
                this.drpVersion.DataValueField = "Version";
                this.drpVersion.DataSource = BLL.ManPowerPlanService.getGroupVersion(this.CurrUser.LoginProjectId);
                this.drpVersion.DataBind();
                // 绑定表格
                this.BindGrid();
            }
        }
        
       

        #region 绑定数据

        /// <summary>
        /// 绑定数据
        /// </summary>
        private void BindGrid()
        {
            
            // 清空现有数据
            GridTable.Clear();
            // 重新添加列定义（保持列结构）
            if (GridTable.Columns.Count == 0)
            {
                GridTable.Columns.Add("Id");
                GridTable.Columns.Add("UnitId");
                GridTable.Columns.Add("UnitWorkId");
                GridTable.Columns.Add("WorkPostId");
                GridTable.Columns.Add("Version");
                GridTable.Columns.Add("PrimaryKeyMap");

                // 添加动态日期列（这部分已经在InitGrid中定义了）
                ListItem[] list = new ListItem[6];
                list[0] = new ListItem("序号", "SerialNumber");
                list[1] = new ListItem("单位", "UnitName");
                list[2] = new ListItem("装置", "UnitWorkName");
                list[3] = new ListItem("岗位", "WorkPostName");
                list[4] = new ListItem("版本", "Version");
                list[5] = new ListItem("累计", "TotalCount");
                foreach (var item in list)
                {
                    GridTable.Columns.Add(item.Value);
                }

                // 日期列会在InitGrid中添加，这里不需要重复添加
            }
            else
            {
                // 清空行数据但保持列结构
                GridTable.Rows.Clear();
            }

            // 获取当前项目的人力计划数据
            var manpowerPlans = (from x in Funs.DB.JDGL_SGManPower
                join y in Funs.DB.Base_WorkPost on x.WorkPostId equals y.WorkPostId
                where x.ProjectId == this.CurrUser.LoginProjectId
                orderby y.WorkPostCode
                select x).ToList();
            
            if (UnitId != Const._Null)
            {
                manpowerPlans = manpowerPlans.Where(x => x.UnitId == UnitId).ToList();
            }

            if (drpWorkPost.SelectedValue != Const._Null)
            {
                manpowerPlans = manpowerPlans.Where(x => x.WorkPostId == drpWorkPost.SelectedValue).ToList();
            }

            if (drpUnitWork.SelectedValue != Const._Null)
            {
                manpowerPlans = manpowerPlans.Where(x => x.UnitWorkId == drpUnitWork.SelectedValue).ToList();
            }
            
            if (drpVersion.SelectedValue != Const._Null)
            {
                manpowerPlans = manpowerPlans.Where(x => x.Version == drpVersion.SelectedValue).ToList();
            }
            
            // 获取所有相关单位、装置和岗位信息
            var units = Funs.DB.Base_Unit.ToList();
            var unitWorks = Funs.DB.WBS_UnitWork.ToList();
            var workPosts = Funs.DB.Base_WorkPost.ToList();

            // 按单位、装置、岗位分组数据
            var groupedData = manpowerPlans
                .GroupBy(x => new { x.UnitId, x.UnitWorkId, x.WorkPostId, x.Version })
                .ToList();

            var count = groupedData.Count();
            Grid1.RecordCount = count;

            groupedData = groupedData.Skip(Grid1.PageSize * Grid1.PageIndex).Take(Grid1.PageSize).ToList();


            foreach (var group in groupedData)
            {
                DataRow row = GridTable.NewRow();

                // 基本信息
                var firstItem = group.First();
                row["Id"] = Guid.NewGuid().ToString(); // 生成唯一ID用于行标识
                row["SerialNumber"] = GridTable.Rows.Count + 1; // 序号

                // 单位信息
                var unit = units.FirstOrDefault(u => u.UnitId == firstItem.UnitId);
                row["UnitName"] = unit != null ? unit.UnitName : "";
                row["UnitId"] = firstItem.UnitId ?? (object)DBNull.Value;

                // 装置信息
                var unitWork = unitWorks.FirstOrDefault(uw => uw.UnitWorkId == firstItem.UnitWorkId);
                row["UnitWorkName"] = unitWork != null ? unitWork.UnitWorkName : "";
                // 当UnitWorkId为null时，保持为null而不是空字符串
                row["UnitWorkId"] = firstItem.UnitWorkId ?? (object)DBNull.Value;

                // 岗位信息
                var workPost = workPosts.FirstOrDefault(wp => wp.WorkPostId == firstItem.WorkPostId);
                row["WorkPostName"] = workPost != null ? workPost.WorkPostName : "";
                row["WorkPostId"] = firstItem.WorkPostId ?? (object)DBNull.Value;

                // 版本信息
                row["Version"] = firstItem.Version ?? "";
                // 计算累计数量
                int totalCount = 0;

                // 存储主键信息，用于编辑操作
                // 创建一个字典来存储每个日期对应的记录ID
                var dateIdMap = new Dictionary<string, string>();
                // 日期相关的人力数据
                foreach (var item in group)
                {
                    if (item.PlanDate.HasValue)
                    {
                        string dateColumnId = item.PlanDate.Value.ToString("yyyy-MM-dd");

                        // 确保列存在
                        if (GridTable.Columns.Contains(dateColumnId))
                        {
                            int quantity = item.Quantity ?? 0;
                            row[dateColumnId] = quantity;
                            dateIdMap[dateColumnId] = item.Id; // 记录每个日期对应的记录ID
                            totalCount += quantity; // 累计数量
                        }
                    }
                }

                // 设置累计数量
                row["TotalCount"] = totalCount;
                // 将ID映射序列化后存储到行中
                row["PrimaryKeyMap"] = Newtonsoft.Json.JsonConvert.SerializeObject(dateIdMap);
                GridTable.Rows.Add(row);
            }

            Grid1.DataSource = GridTable;
            Grid1.DataBind();
            // 计算汇总数据
            OutputSummaryData();
        }

        #region 计算合计

        /// <summary>
        /// 计算合计
        /// </summary>
        private void OutputSummaryData()
        {
            // 创建用于存储合计值的对象
            JObject summary = new JObject();

            // 设置固定列的合计值
            summary.Add("UnitName", "合计");

            // 计算TotalCount列的合计值
            int totalCountSum = 0;
            foreach (DataRow row in GridTable.Rows)
            {
                if (row["TotalCount"] != DBNull.Value && row["TotalCount"] != null)
                {
                    int value;
                    if (int.TryParse(row["TotalCount"].ToString(), out value))
                    {
                        totalCountSum += value;
                    }
                }
            }

            summary.Add("TotalCount", totalCountSum.ToString());

            // 计算日期列的合计值
            foreach (DataColumn column in GridTable.Columns)
            {
                // 检查是否为日期列（格式为 yyyy-MM-dd）
                DateTime date;
                if (DateTime.TryParseExact(column.ColumnName, "yyyy-MM-dd", null,
                        System.Globalization.DateTimeStyles.None, out date))
                {
                    // 计算该列的合计值
                    int columnSum = 0;
                    foreach (DataRow row in GridTable.Rows)
                    {
                        if (row[column.ColumnName] != DBNull.Value && row[column.ColumnName] != null)
                        {
                            int value;
                            if (int.TryParse(row[column.ColumnName].ToString(), out value))
                            {
                                columnSum += value;
                            }
                        }
                    }

                    summary.Add(column.ColumnName, columnSum.ToString());
                }
            }

            // 设置汇总数据
            Grid1.SummaryData = summary;
        }

        #endregion

        #endregion

        #region GV 数据操作

        /// <summary>
        /// 分页
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Grid1_PageIndexChange(object sender, GridPageEventArgs e)
        {
            this.Grid1.PageIndex = e.NewPageIndex;
            this.BindGrid();
        }

        /// <summary>
        /// 排序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Grid1_Sort(object sender, GridSortEventArgs e)
        {
            this.Grid1.SortDirection = e.SortDirection;
            this.Grid1.SortField = e.SortField;
            this.BindGrid();
        }

        /// <summary>
        /// 分页显示条数下拉框
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ddlPageSize_SelectedIndexChanged(object sender, EventArgs e)
        {
            Grid1.PageSize = Convert.ToInt32(ddlPageSize.SelectedValue);
            this.BindGrid();
        }

        #endregion

        #region 数据查询

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="button"></param>
        /// <returns></returns>
        protected void btnQuery_OnClick(object sender, EventArgs e)
        {
            BindGrid();
        }

        /// <summary>
        /// 统计图表
        /// </summary>
        /// <param name="button"></param>
        /// <returns></returns>
        protected void btnGetChart_Click(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(UnitId) && !string.IsNullOrEmpty(StartTime) && !string.IsNullOrEmpty(EndTime))
            {
                // 构建基础URL参数
                string urlParams = string.Format("UnitId={0}&StartTime={1}&EndTime={2}", UnitId, StartTime, EndTime);

                // 添加装置参数（如果已选择）
                if (drpUnitWork.SelectedValue != Const._Null && !string.IsNullOrEmpty(drpUnitWork.SelectedValue))
                {
                    urlParams += "&UnitWorkId=" + drpUnitWork.SelectedValue;
                }

                // 添加岗位参数（如果已选择）
                if (drpWorkPost.SelectedValue != Const._Null && !string.IsNullOrEmpty(drpWorkPost.SelectedValue))
                {
                    urlParams += "&WorkPostId=" + drpWorkPost.SelectedValue;
                }

                // 版本参数
                if (drpVersion.SelectedValue != Const._Null && !string.IsNullOrEmpty(drpVersion.SelectedValue))
                {
                    urlParams += "&drpVersion=" + drpVersion.SelectedValue;
                }
              
                PageContext.RegisterStartupScript(
                    Window2.GetShowReference(string.Format("ManPowerPlanChart.aspx?{0}", urlParams), "人力计划图表"));
            }
            else
            {
                ShowNotify("请先选择单位并确保时间范围已设置", MessageBoxIcon.Warning);
            }
        }

        #endregion

        #region 获取权限按钮

        /// <summary>
        /// 获取按钮权限
        /// </summary>
        /// <param name="button"></param>
        /// <returns></returns>
        private void GetButtonPower()
        {
            if (Request.Params["value"] == BLL.Const._Null)
            {
                return;
            }

            var buttonList = BLL.CommonService.GetAllButtonList(this.CurrUser.LoginProjectId, this.CurrUser.UserId,
                BLL.Const.SGManPowerMenuId);
            if (buttonList.Count() > 0)
            {
                if (buttonList.Contains(BLL.Const.BtnSave))
                {
                    this.btnNew.Hidden = false;
                }
            }
        }

        #endregion

        #region 关闭弹出窗

        /// <summary>
        /// 关闭弹出窗
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Window1_Close(object sender, WindowCloseEventArgs e)
        {
            BindGrid();
        }

        #endregion

        #region 导出按钮

        /// 导出按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnOut_Click(object sender, EventArgs e)
        {
            Response.ClearContent();
            string filename = Funs.GetNewFileName();
            Response.AddHeader("content-disposition",
                "attachment; filename=" +
                System.Web.HttpUtility.UrlEncode("施工人力计划表" + filename, System.Text.Encoding.UTF8) + ".xls");
            Response.ContentType = "application/excel";
            Response.ContentEncoding = System.Text.Encoding.UTF8;
            this.BindGrid();
            // 生成并写入Excel表格
            Response.Write(GetGridTableHtml(Grid1));
            Response.End();
        }

        /// <summary>
        /// 导出方法 - 支持多级表头
        /// </summary>
        /// <param name="grid"></param>
        /// <returns></returns>
        /// <summary>
        private string GetGridTableHtml(Grid grid)
        {
            StringBuilder sb = new StringBuilder();

            MultiHeaderTable mht = new MultiHeaderTable();
            mht.ResolveMultiHeaderTable(grid.Columns);

            sb.Append("<meta http-equiv=\"Content-Type\" content=\"application/vnd.ms-excel;charset=utf-8\"/>");
            sb.Append("<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">");

            // 生成多级表头
            foreach (List<object[]> rows in mht.MultiTable)
            {
                sb.Append("<tr>");
                foreach (object[] cell in rows)
                {
                    int rowspan = 1;
                    int colspan = Convert.ToInt32(cell[1]);
                    GridColumn column = cell[2] as GridColumn;

                    // 对于锁定列（固定列），确保rowspan为3
                    if (column.Locked)
                    {
                        rowspan = 3;
                    }

                    sb.AppendFormat("<th{0}{1}{2}>{3}</th>",
                        " rowspan=\"" + rowspan + "\"",
                        colspan != 1 ? " colspan=\"" + colspan + "\"" : "",
                        colspan != 1 ? " style=\"text-align:center;\"" : "",
                        column.HeaderText);
                }

                sb.Append("</tr>");
            }

            // 生成数据行
            foreach (GridRow row in grid.Rows)
            {
                sb.Append("<tr>");

                foreach (GridColumn column in mht.Columns)
                {
                    string html = row.Values[column.ColumnIndex].ToString();

                    // 特殊处理固定列
                    if (column.ColumnID == "UnitName")
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }
                    else if (column.ColumnID == "UnitWorkName")
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }
                    else if (column.ColumnID == "WorkPostName")
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }
                    else if (column.ColumnID == "Version")
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }
                    else if (column.ColumnID == "TotalCount")
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }
                    // 处理日期列（格式为 yyyy-MM-dd）
                    else if (DateTime.TryParseExact(column.ColumnID, "yyyy-MM-dd", null,
                                 System.Globalization.DateTimeStyles.None, out _))
                    {
                        html = row.Values[column.ColumnIndex].ToString();
                    }

                    sb.AppendFormat("<td>{0}</td>", html);
                }
                sb.Append("</tr>");
            }

            // 添加合计行
            if (grid.SummaryData != null)
            {
                sb.Append("<tr style=\"font-weight:bold;\">");
                
                foreach (GridColumn column in mht.Columns)
                {
                    string summaryValue = "";
                    // 检查SummaryData中是否有该列的合计值
                    if (grid.SummaryData.Properties().Any(p => p.Name == column.ColumnID))
                    {
                        var property = grid.SummaryData.Properties().FirstOrDefault(p => p.Name == column.ColumnID);
                        if (property != null)
                        {
                            summaryValue = property.Value.ToString();
                        }
                    }
                    else if (column.ColumnID == "UnitName")
                    {
                        summaryValue = "合计";
                    }
                    
                    sb.AppendFormat("<td>{0}</td>", summaryValue);
                }
                
                sb.Append("</tr>");
            }
            
            sb.Append("</table>");

            return sb.ToString();
        }


        #region 多表头处理

        /// <summary>
        /// 处理多表头的类
        /// </summary>
        public class MultiHeaderTable
        {
            // 包含 rowspan，colspan 的多表头，方便生成 HTML 的 table 标签
            public List<List<object[]>> MultiTable = new List<List<object[]>>();

            // 最终渲染的列数组
            public List<GridColumn> Columns = new List<GridColumn>();

            public void ResolveMultiHeaderTable(GridColumnCollection columns)
            {
                List<object[]> row = new List<object[]>();
                foreach (GridColumn column in columns)
                {
                    object[] cell = new object[4];
                    cell[0] = 1; // rowspan
                    cell[1] = 1; // colspan
                    cell[2] = column;
                    cell[3] = null;

                    row.Add(cell);
                }

                ResolveMultiTable(row, 0);
                ResolveColumns(row);
            }

            private void ResolveColumns(List<object[]> row)
            {
                foreach (object[] cell in row)
                {
                    GroupField groupField = cell[2] as GroupField;
                    if (groupField != null && groupField.Columns.Count > 0)
                    {
                        List<object[]> subrow = new List<object[]>();
                        foreach (GridColumn column in groupField.Columns)
                        {
                            subrow.Add(new object[]
                            {
                                1,
                                1,
                                column,
                                groupField
                            });
                        }

                        ResolveColumns(subrow);
                    }
                    else
                    {
                        Columns.Add(cell[2] as GridColumn);
                    }
                }
            }

            private void ResolveMultiTable(List<object[]> row, int level)
            {
                List<object[]> nextrow = new List<object[]>();

                foreach (object[] cell in row)
                {
                    GroupField groupField = cell[2] as GroupField;
                    if (groupField != null && groupField.Columns.Count > 0)
                    {
                        // 如果当前列包含子列，则更改当前列的 colspan，以及增加父列（向上递归）的colspan
                        cell[1] = Convert.ToInt32(groupField.Columns.Count);
                        PlusColspan(level - 1, cell[3] as GridColumn, groupField.Columns.Count - 1);

                        foreach (GridColumn column in groupField.Columns)
                        {
                            nextrow.Add(new object[]
                            {
                                1,
                                1,
                                column,
                                groupField
                            });
                        }
                    }
                    else
                    {
                        // 如果当前列不包含子列，但不是最末级列（不是叶子节点），则增加rowspan
                        if (level > 0)
                        {
                            cell[0] = level + 1;
                        }
                    }
                }

                MultiTable.Add(row);

                if (nextrow.Count > 0)
                {
                    ResolveMultiTable(nextrow, level + 1);
                }
            }

            private void PlusColspan(int level, GridColumn column, int colspan)
            {
                if (level < 0)
                {
                    return;
                }

                foreach (List<object[]> rows in MultiTable)
                {
                    foreach (object[] cells in rows)
                    {
                        if (cells[2] == column)
                        {
                            cells[1] = Convert.ToInt32(cells[1]) + colspan;

                            PlusColspan(level - 1, cells[3] as GridColumn, colspan);
                            break;
                        }
                    }
                }
            }
        }

        #endregion

        #endregion

        #region 编辑单元格

        protected void Grid1_AfterEdit(object sender, GridAfterEditEventArgs e)
        {
            Dictionary<int, Dictionary<string, object>> modifiedDict = Grid1.GetModifiedDict();

            foreach (int rowIndex in modifiedDict.Keys)
            {
                // 确保GridTable中有足够的行
                if (GridTable.Rows.Count <= rowIndex)
                {
                    // 如果GridTable中没有足够的行，重新绑定数据
                    BindGrid();
                }

                // 再次检查是否有了足够的行
                if (GridTable.Rows.Count <= rowIndex)
                {
                    ShowNotify("数据状态异常，请刷新页面后重试！");
                    return;
                }

                // 获取行ID
                string rowId = Grid1.DataKeys[rowIndex][0].ToString();
                //获取固定列的列数据
                var d = GridTable.Rows[rowIndex];
                string unitId = null;
                var UnitIdValue = GridTable.Rows[rowIndex]["UnitId"];
                if (UnitIdValue != null && UnitIdValue != DBNull.Value)
                {
                    unitId = UnitIdValue.ToString();
                }

                // 处理可能为null的unitWorkId
                string unitWorkId = null;
                var unitWorkIdValue = GridTable.Rows[rowIndex]["UnitWorkId"];
                if (unitWorkIdValue != null && unitWorkIdValue != DBNull.Value)
                {
                    unitWorkId = unitWorkIdValue.ToString();
                }

                string workPostId = null;
                var workPostIdValue = GridTable.Rows[rowIndex]["WorkPostId"];
                if (workPostIdValue != null && workPostIdValue != DBNull.Value)
                {
                    workPostId = workPostIdValue.ToString();
                }

                string version = GridTable.Rows[rowIndex]["Version"].ToString();

                // 获取主键映射信息
                string primaryKeyMapJson = GridTable.Rows[rowIndex]["PrimaryKeyMap"].ToString();
                var dateIdMap =
                    Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(primaryKeyMapJson)
                    ?? new Dictionary<string, string>();

                // 遍历该行中被修改的列
                foreach (string columnName in modifiedDict[rowIndex].Keys)
                {
                    // 获取修改后的值
                    object newValue = modifiedDict[rowIndex][columnName];

                    // 根据列名判断是否为日期列
                    DateTime planDate;
                    if (DateTime.TryParse(columnName, out planDate))
                    {
                        // 检查是否应该删除记录（值为0或空字符串）
                        bool shouldDelete = (newValue == null) ||
                                            (newValue.ToString() == "") ||
                                            (newValue.ToString() == "0");
                        if (shouldDelete)
                        {
                            // 删除记录
                            string recordId = null;
                            if (dateIdMap.ContainsKey(columnName))
                            {
                                recordId = dateIdMap[columnName];
                            }

                            DeleteManPowerPlan(recordId, unitId, unitWorkId, workPostId, version, planDate);

                            // 从映射中移除该日期
                            if (dateIdMap.ContainsKey(columnName))
                            {
                                dateIdMap.Remove(columnName);
                            }
                        }
                        else
                        {
                            // 这是一个日期列，需要更新对应的人力计划数据
                            string recordId = null;
                            // 尝试从映射中获取记录ID
                            if (dateIdMap.ContainsKey(columnName))
                            {
                                recordId = dateIdMap[columnName];
                            }

                            // 更新或创建人力计划数据
                            UpdateManPowerPlan(recordId, unitId, unitWorkId, workPostId, version, planDate, newValue);
                        }
                    }
                }

                // 更新行中的主键映射信息
                GridTable.Rows[rowIndex]["PrimaryKeyMap"] = Newtonsoft.Json.JsonConvert.SerializeObject(dateIdMap);
            }

            BindGrid();


            ShowNotify("数据保存成功！（表格数据已重新绑定）");
        }

        /// <summary>
        /// 更新人力计划数据
        /// </summary>
        /// <param name="recordId">记录ID（如果存在）</param>
        /// <param name="unitId">单位ID</param>
        /// <param name="unitWorkId">装置ID</param>
        /// <param name="workPostId">岗位ID</param>
        /// <param name="version">版本</param>
        /// <param name="planDate">计划日期</param>
        /// <param name="quantity">数量</param>
        private void UpdateManPowerPlan(string recordId, string unitId, string unitWorkId, string workPostId,
            string version, DateTime planDate, object quantity)
        {
            Model.JDGL_SGManPower manpowerPlan = null;

            // 如果记录ID存在，则尝试查找现有记录
            if (!string.IsNullOrEmpty(recordId))
            {
                manpowerPlan = Funs.DB.JDGL_SGManPower.FirstOrDefault(x => x.Id == recordId);
            }

            // 如果没有找到现有记录，则根据条件查找或创建新记录
            if (manpowerPlan == null)
            {
                // 尝试查找匹配条件的现有记录
                manpowerPlan = Funs.DB.JDGL_SGManPower.FirstOrDefault(x =>
                    x.ProjectId == this.CurrUser.LoginProjectId &&
                    x.UnitId == unitId &&
                    x.UnitWorkId == unitWorkId &&
                    x.WorkPostId == workPostId &&
                    x.Version == version &&
                    x.PlanDate == planDate);
            }

            // 如果仍然没有找到记录，则创建新记录
            if (manpowerPlan == null)
            {
                manpowerPlan = new Model.JDGL_SGManPower
                {
                    Id = SQLHelper.GetNewID(typeof(Model.JDGL_SGManPower)),
                    ProjectId = this.CurrUser.LoginProjectId,
                    UnitId = unitId,
                    UnitWorkId = unitWorkId,
                    WorkPostId = workPostId,
                    Version = version,
                    PlanDate = planDate,
                    CompileMan = this.CurrUser.UserId,
                    CompileTime = DateTime.Now
                };

                // 设置数量
                if (quantity != null && !string.IsNullOrEmpty(quantity.ToString()))
                {
                    int qty;
                    if (int.TryParse(quantity.ToString(), out qty))
                    {
                        manpowerPlan.Quantity = qty;
                    }
                }

                BLL.ManPowerPlanService.AddSGManPower(manpowerPlan);
            }
            else
            {
                // 如果有值就进行编辑修改操作
                if (quantity != null && !string.IsNullOrEmpty(quantity.ToString()))
                {
                    int qty;
                    if (int.TryParse(quantity.ToString(), out qty))
                    {
                        manpowerPlan.Quantity = qty;
                    }
                    else
                    {
                        manpowerPlan.Quantity = null; // 清空数量
                    }
                }
                else
                {
                    manpowerPlan.Quantity = null; // 清空数量
                }
            }
            
            Funs.DB.SubmitChanges();
        }

        /// <summary>
        /// 删除人力计划数据
        /// </summary>
        /// <param name="recordId">记录ID（如果存在）</param>
        /// <param name="unitId">单位ID</param>
        /// <param name="unitWorkId">装置ID</param>
        /// <param name="workPostId">岗位ID</param>
        /// <param name="version">版本</param>
        /// <param name="planDate">计划日期</param>
        private void DeleteManPowerPlan(string recordId, string unitId, string unitWorkId, string workPostId,
            string version, DateTime planDate)
        {
            Model.JDGL_SGManPower manpowerPlan = null;

            // 如果记录ID存在，则尝试查找现有记录
            if (!string.IsNullOrEmpty(recordId))
            {
                manpowerPlan = Funs.DB.JDGL_SGManPower.FirstOrDefault(x => x.Id == recordId);
            }
            else
            {
                // 根据条件查找记录
                var query = Funs.DB.JDGL_SGManPower.Where(x =>
                    x.ProjectId == this.CurrUser.LoginProjectId &&
                    x.UnitId == unitId &&
                    x.WorkPostId == workPostId &&
                    x.Version == version &&
                    x.PlanDate == planDate);

                // 根据unitWorkId是否为null进行不同的查询
                if (string.IsNullOrEmpty(unitWorkId))
                {
                    query = query.Where(x => x.UnitWorkId == null);
                }
                else
                {
                    query = query.Where(x => x.UnitWorkId == unitWorkId);
                }

                manpowerPlan = query.FirstOrDefault();
            }

            // 如果找到了记录，则删除它
            if (manpowerPlan != null)
            {
                Funs.DB.JDGL_SGManPower.DeleteOnSubmit(manpowerPlan);
                Funs.DB.SubmitChanges();
            }
        }

        #endregion

        #region 新增

        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnNew_Click(object sender, EventArgs e)
        {
            PageContext.RegisterStartupScript(Window1.GetShowReference(String.Format("ManPowerPlanEdit.aspx"),
                "新增 - 施工人力计划"));
        }

        #endregion

        #region 导入

        /// <summary>
        /// 导入按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnImport_Click(object sender, EventArgs e)
        {
            PageContext.RegisterStartupScript(Window1.GetShowReference(
                String.Format("ManPowerPlanIn.aspx?ProjectId={0}", this.CurrUser.LoginProjectId), "导入 - 施工人力计划"));
        }

        #endregion
    }
}