using EmitMapper;
using FineUIPro;
using MiniExcelLibs;
using MiniExcelLibs.Attributes;
using Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace BLL
{
    public static class PHTGL_QuantityService
    {
        public static PHTGL_Quantity GetPHTGL_QuantityById(string Id)
        {
            return Funs.DB.PHTGL_Quantity.FirstOrDefault(x => x.Id == Id);
        }

        public static PHTGL_Quantity GetPHTGL_QuantityByNumBer(string serialNumber, string marjor)
        {
            return Funs.DB.PHTGL_Quantity.FirstOrDefault(x => x.SerialNumber == serialNumber && x.Major == marjor);
        }

        public static void AddPHTGL_Quantity(PHTGL_Quantity newtable)
        {
            var table = new PHTGL_Quantity
            {
                Id = newtable.Id,
                Major = newtable.Major,
                SubProject = newtable.SubProject,
                SubItemProject = newtable.SubItemProject,
                ProjectCode = newtable.ProjectCode,
                ProjectName = newtable.ProjectName,
                ProjectDescription = newtable.ProjectDescription,
                UnitOfMeasurement = newtable.UnitOfMeasurement,
                Quantity = newtable.Quantity,
                TotalCostFixedComprehensiveUnitPrice = newtable.TotalCostFixedComprehensiveUnitPrice,
                MainMaterialCost = newtable.MainMaterialCost,
                TotalPrice = newtable.TotalPrice,
                CalculationRule = newtable.CalculationRule,
                WorkContent = newtable.WorkContent,
                Remarks = newtable.Remarks,
                IsTemplate = newtable.IsTemplate,
                ParentId = newtable.ParentId,
                SerialNumber = newtable.SerialNumber
            };
            Funs.DB.PHTGL_Quantity.InsertOnSubmit(table);
            Funs.DB.SubmitChanges();
        }
        /// <summary>
        /// 通过模板增加实体
        /// </summary>
        /// <param name="newtable"></param>
        /// <param name="parentId"></param>
        public static void AddPHTGL_QuantityByTemModel(PHTGL_Quantity newtable, string parentId)
        {
            var table = new PHTGL_Quantity
            {
                Id = SQLHelper.GetNewID(),
                Major = newtable.Major,
                SubProject = newtable.SubProject,
                SubItemProject = newtable.SubItemProject,
                ProjectCode = newtable.ProjectCode,
                ProjectName = newtable.ProjectName,
                ProjectDescription = newtable.ProjectDescription,
                UnitOfMeasurement = newtable.UnitOfMeasurement,
                Quantity = newtable.Quantity,
                TotalCostFixedComprehensiveUnitPrice = newtable.TotalCostFixedComprehensiveUnitPrice,
                MainMaterialCost = newtable.MainMaterialCost,
                TotalPrice = newtable.TotalPrice,
                CalculationRule = newtable.CalculationRule,
                WorkContent = newtable.WorkContent,
                Remarks = newtable.Remarks,
                IsTemplate = false,
                ParentId = parentId,
                SerialNumber = newtable.SerialNumber
            };
            Funs.DB.PHTGL_Quantity.InsertOnSubmit(table);
            Funs.DB.SubmitChanges();
        }

        public static void UpdatePHTGL_Quantity(PHTGL_Quantity newtable)
        {
            var table = Funs.DB.PHTGL_Quantity.FirstOrDefault(x => x.Id == newtable.Id);
            if (table != null)
            {
                table.Id = newtable.Id;
                table.Major = newtable.Major;
                table.SubProject = newtable.SubProject;
                table.SubItemProject = newtable.SubItemProject;
                table.ProjectCode = newtable.ProjectCode;
                table.ProjectName = newtable.ProjectName;
                table.ProjectDescription = newtable.ProjectDescription;
                table.UnitOfMeasurement = newtable.UnitOfMeasurement;
                table.Quantity = newtable.Quantity;
                table.TotalCostFixedComprehensiveUnitPrice = newtable.TotalCostFixedComprehensiveUnitPrice;
                table.MainMaterialCost = newtable.MainMaterialCost;
                table.TotalPrice = newtable.TotalPrice;
                table.CalculationRule = newtable.CalculationRule;
                table.WorkContent = newtable.WorkContent;
                table.Remarks = newtable.Remarks;
                table.IsTemplate = newtable.IsTemplate;
                table.ParentId = newtable.ParentId;
                table.SerialNumber = newtable.SerialNumber;
                Funs.DB.SubmitChanges();
            }
        }

        public static void DeletePHTGL_QuantityById(string Id)
        {
            var table = Funs.DB.PHTGL_Quantity.FirstOrDefault(x => x.Id == Id);
            if (table != null)
            {
                Funs.DB.PHTGL_Quantity.DeleteOnSubmit(table);
                Funs.DB.SubmitChanges();
            }
        }

        public static void DeletePHTGL_QuantityByParentId(string parentId)
        {
            var table = Funs.DB.PHTGL_Quantity.Where(x => x.ParentId == parentId);
            if (table.Any())
            {
                Funs.DB.PHTGL_Quantity.DeleteAllOnSubmit(table);
                Funs.DB.SubmitChanges();
            }
        }

        /// <summary>
        /// 导入数据
        /// </summary>
        /// <param name="path">数据文件地址</param>
        /// <param name="majortype">专业类型</param>
        /// <returns></returns>
        public static ResponeData ImportData(string path, string majortype)
        {
            var responeData = new ResponeData();
            List<PHTGL_QuantityDtoIn> rows = new List<PHTGL_QuantityDtoIn>();
            List<dynamic> remarkQuery = new List<dynamic>();
            string Major = "";
            try
            {
                var sheetNames = MiniExcel.GetSheetNames(path);
                foreach (var item in sheetNames)
                {
                    if (item == "编制说明")
                    {
                        remarkQuery = MiniExcel.Query(path, sheetName: item).ToList();
                    }
                    else
                    {
                        rows = MiniExcel.Query<PHTGL_QuantityDtoIn>(path, sheetName: item).ToList();
                    }
                }

            }
            catch (Exception e)
            {
                responeData.code = 0;
                responeData.message = "模板错误";
                return responeData;
            }

            var mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<List<PHTGL_QuantityDtoIn>, List<PHTGL_Quantity>>();
            var modeList = mapper.Map(rows);
            if (modeList.Count == 0)
            {
                responeData.code = 0;
                responeData.message = "没有数据";
                return responeData;
            }

            Major = GetMajorItems().Where(x => x.Text == majortype).Select(x => x.Value).FirstOrDefault() ??
                    "";
            List<Model.Sys_Const> consts = new List<Model.Sys_Const>();
            int SortIndex = 0;
            foreach (var item in remarkQuery)
            {
                if (string.IsNullOrEmpty(Major)) break;
                Model.Sys_Const model = new Model.Sys_Const()
                {
                    ID = SQLHelper.GetNewID(),
                    ConstValue = item.A?.ToString(),
                    SortIndex = SortIndex,
                    GroupId = "工程量清单-" + Major
                };
                consts.Add(model);
                SortIndex++;
            }

            var old = ConstValue.drpConstItemList("工程量清单-" + Major);
            if (old.Count > 0)
            {
                Funs.DB.Sys_Const.DeleteAllOnSubmit(old);
                Funs.DB.SubmitChanges();
            }
            ;
            Funs.DB.Sys_Const.InsertAllOnSubmit(consts);
            Funs.DB.SubmitChanges();
            foreach (var item in modeList)
            {
                item.Major = Major;
                if (string.IsNullOrEmpty(Major)) break;
                if (string.IsNullOrEmpty(item.ProjectName)) continue;
                if (item.ProjectName == "项目名称") continue;
                var queryPhtglQuantity = new PHTGL_Quantity
                {
                    Major = item.Major,
                    SubProject = item.SubProject,
                    SubItemProject = item.SubItemProject,
                    ProjectCode = item.ProjectCode,
                    ProjectName = item.ProjectName,
                    IsTemplate = true
                };
                var resultModel = GetPHTGL_QuantityByModle(queryPhtglQuantity);
                if (resultModel.Any())
                {
                    item.Id = resultModel[0].Id;
                    UpdatePHTGL_Quantity(item);
                }
                else
                {
                    item.Id = SQLHelper.GetNewID();
                    item.IsTemplate = true;
                    AddPHTGL_Quantity(item);
                }
            }

            return responeData;
        }

        public static ResponeData ImportData(string path, string majortype, string mainProjectQuantityId)
        {
            var responeData = new ResponeData();
            List<PHTGL_QuantityDtoIn> rows;
            try
            {
                rows = MiniExcel.Query<PHTGL_QuantityDtoIn>(path).ToList();
            }
            catch (Exception e)
            {
                responeData.code = 0;
                responeData.message = "模板错误";
                return responeData;
            }

            var mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<List<PHTGL_QuantityDtoIn>, List<PHTGL_Quantity>>();
            var modeList = mapper.Map(rows);
            if (modeList.Count == 0)
            {
                responeData.code = 0;
                responeData.message = "没有数据";
                return responeData;
            }

            foreach (var item in modeList)
            {
                if (!string.IsNullOrEmpty(majortype))
                {
                    item.Major = GetMajorItems().Where(x => x.Text == majortype).Select(x => x.Value).FirstOrDefault() ??
                                 "";
                }
                if (string.IsNullOrEmpty(item.Major)) break;
                var queryPhtglQuantity = new PHTGL_Quantity
                {
                    Major = item.Major,
                    SubProject = item.SubProject,
                    SubItemProject = item.SubItemProject,
                    ProjectCode = item.ProjectCode,
                };
                if (string.IsNullOrEmpty(mainProjectQuantityId))
                {
                    queryPhtglQuantity.IsTemplate = true;
                    item.IsTemplate = true;
                }
                else
                {
                    queryPhtglQuantity.IsTemplate = false;
                    queryPhtglQuantity.ParentId = mainProjectQuantityId;
                    item.ParentId = mainProjectQuantityId;
                    item.IsTemplate = false;
                }

                var resultModel = GetPHTGL_QuantityByModle(queryPhtglQuantity);
                if (resultModel.Any())
                {
                    item.Id = resultModel[0].Id;
                    UpdatePHTGL_Quantity(item);
                }
                else
                {
                    item.Id = SQLHelper.GetNewID();
                    AddPHTGL_Quantity(item);
                }
            }

            return responeData;
        }


        public static ListItem[] GetMajorItems()
        {
            var list = new ListItem[12];
            list[0] = new ListItem("0", "土建工程");
            list[1] = new ListItem("1", "钢结构预制工程");
            list[2] = new ListItem("2", "工艺管道安装工程");
            list[3] = new ListItem("3", "工艺设备安装工程");
            list[4] = new ListItem("4", "非标设备现场制作安装工程");
            list[5] = new ListItem("5.1", "电气工程");
            list[6] = new ListItem("5.2", "仪表工程");
            list[7] = new ListItem("5.3", "电信工程");
            list[8] = new ListItem("6", "水暖安装工程");
            list[9] = new ListItem("7", "防腐绝热工程");
            list[10] = new ListItem("8", "无损检测工程");
            list[11] = new ListItem("9", "消防工程");

            return list;
        }

        public static ListItem[] GetMajorItems2()
        {
            var list = new ListItem[12];
            list[0] = new ListItem("Z01", "土建工程");
            list[1] = new ListItem("Z02", "钢结构预制工程");
            list[2] = new ListItem("Z03", "工艺管道安装工程");
            list[3] = new ListItem("Z04", "工艺设备安装工程");
            list[4] = new ListItem("Z05", "非标设备现场制作安装工程");
            list[5] = new ListItem("Z06.1", "电气工程");
            list[6] = new ListItem("Z06.2", "仪表工程");
            list[7] = new ListItem("Z06.3", "电信工程");
            list[8] = new ListItem("Z07", "水暖安装工程");
            list[9] = new ListItem("Z08", "防腐绝热工程");
            list[10] = new ListItem("Z09", "无损检测工程");
            list[11] = new ListItem("Z10", "消防工程");

            return list;
        }
        public static ListItem[] GetMajorItems3()
        {
            var list = new ListItem[12];
            list[0] = new ListItem("土建工程", "土建工程");
            list[1] = new ListItem("钢结构预制工程", "钢结构预制工程");
            list[2] = new ListItem("工艺管道安装工程", "工艺管道安装工程");
            list[3] = new ListItem("工艺设备安装工程", "工艺设备安装工程");
            list[4] = new ListItem("非标设备现场制作安装工程", "非标设备现场制作安装工程");
            list[5] = new ListItem("电气工程", "电气工程");
            list[6] = new ListItem("仪表工程", "仪表工程");
            list[7] = new ListItem("电信工程", "电信工程");
            list[8] = new ListItem("水暖安装工程", "水暖安装工程");
            list[9] = new ListItem("防腐绝热工程", "防腐绝热工程");
            list[10] = new ListItem("无损检测工程", "无损检测工程");
            list[11] = new ListItem("消防工程", "消防工程");

            return list;
        }
        public static void IniGetMajorItems3DownList(FineUIPro.DropDownList dropName, bool isShowPlease)
        {
            dropName.DataValueField = "Value";
            dropName.DataTextField = "Text";
            dropName.DataSource = GetMajorItems3();
            dropName.DataBind();
            if (isShowPlease)
            {
                Funs.FineUIPleaseSelect(dropName);
            }
        }

        public static string GetMajorName(string majorIds)
        {
            string majorName = string.Empty;
            if (!string.IsNullOrEmpty(majorIds))
            {
                string[] strs = majorIds.Split(',');
                var items = GetMajorItems2();
                foreach (var item in strs)
                {
                    var un = items.FirstOrDefault(x => x.Text == item);
                    if (un != null)
                    {
                        majorName += un.Value + ",";
                    }
                }
                if (!string.IsNullOrEmpty(majorName))
                {
                    majorName = majorName.Substring(0, majorName.LastIndexOf(","));
                }
            }
            return majorName;
        }

        #region 获取列表

        /// <summary>
        ///     记录数
        /// </summary>
        public static int count { get; set; }

        public static List<PHTGL_Quantity> GetPHTGL_QuantityByModle(PHTGL_Quantity table)
        {
            var q = from x in Funs.DB.PHTGL_Quantity
                    where
                        (string.IsNullOrEmpty(table.Id) || x.Id.Contains(table.Id)) &&
                        (string.IsNullOrEmpty(table.Major) || x.Major.Contains(table.Major)) &&
                        (string.IsNullOrEmpty(table.SubProject) || x.SubProject.Contains(table.SubProject)) &&
                        (string.IsNullOrEmpty(table.SubItemProject) ||
                         x.SubItemProject.Contains(table.SubItemProject)) &&
                        (string.IsNullOrEmpty(table.ProjectCode) || x.ProjectCode.Contains(table.ProjectCode)) &&
                        (string.IsNullOrEmpty(table.ProjectName) || x.ProjectName.Contains(table.ProjectName)) &&
                        (string.IsNullOrEmpty(table.ProjectDescription) ||
                         x.ProjectDescription.Contains(table.ProjectDescription)) &&
                        (string.IsNullOrEmpty(table.UnitOfMeasurement) ||
                         x.UnitOfMeasurement.Contains(table.UnitOfMeasurement)) &&
                        (string.IsNullOrEmpty(table.Quantity) || x.Quantity.Contains(table.Quantity)) &&
                        (string.IsNullOrEmpty(table.TotalCostFixedComprehensiveUnitPrice) ||
                         x.TotalCostFixedComprehensiveUnitPrice.Contains(table.TotalCostFixedComprehensiveUnitPrice)) &&
                        (string.IsNullOrEmpty(table.MainMaterialCost) ||
                         x.MainMaterialCost.Contains(table.MainMaterialCost)) &&
                        (string.IsNullOrEmpty(table.TotalPrice) || x.TotalPrice.Contains(table.TotalPrice)) &&
                        (string.IsNullOrEmpty(table.CalculationRule) ||
                         x.CalculationRule.Contains(table.CalculationRule)) &&
                        (string.IsNullOrEmpty(table.WorkContent) || x.WorkContent.Contains(table.WorkContent)) &&
                        (string.IsNullOrEmpty(table.Remarks) || x.Remarks.Contains(table.Remarks)) &&
                        x.IsTemplate == table.IsTemplate &&
                        (string.IsNullOrEmpty(table.ParentId) || x.ParentId.Contains(table.ParentId))

                    select x;
            //select new  { x ,IntSerialNumber= Funs.GetNewIntOrZero(x.SerialNumber.Replace(".", ""))
            //    }

            ;
            //var model = q.ToList().OrderBy(x => x.IntSerialNumber).Select(itemx =>  itemx.x).ToList();
            var model = q.ToList().OrderBy(x => x.SerialNumber, new CustomComparer()).ToList();
            return model;
        }

        /// 获取分页列表
        /// </summary>
        /// <param name="PageIndex">页码</param>
        /// <param name="PageSize">每页数量</param>
        /// <returns></returns>
        public static IEnumerable getListData(PHTGL_Quantity table, Grid Grid1)
        {
            var q = GetPHTGL_QuantityByModle(table);
            count = q.Count();
            if (count == 0) return null;
            q = q.Skip(Grid1.PageSize * Grid1.PageIndex).Take(Grid1.PageSize).ToList();
            // q = SortConditionHelper.SortingAndPaging(q, Grid1.SortField, Grid1.SortDirection, Grid1.PageIndex, Grid1.PageSize);
            return from x in q
                   select new
                   {
                       x.Id,
                       x.SerialNumber,
                       x.Major,
                       x.SubProject,
                       x.SubItemProject,
                       x.ProjectCode,
                       x.ProjectName,
                       x.ProjectDescription,
                       x.UnitOfMeasurement,
                       x.Quantity,
                       x.TotalCostFixedComprehensiveUnitPrice,
                       x.MainMaterialCost,
                       x.TotalPrice,
                       x.CalculationRule,
                       x.WorkContent,
                       x.Remarks,
                       x.IsTemplate,
                       x.ParentId
                   };
        }

        public static void CheckSubProjectName(List<PHTGL_Quantity> list)
        {
            foreach (var item in list)
            {
                var SubProject = "";
                var SubItemProject = "";
                var SerialNumberArry = item.SerialNumber?.Split('.');
                if (SerialNumberArry.Length == 2)
                {
                    item.SubProject = GetPHTGL_QuantityByNumBer(SerialNumberArry[0], item.Major).ProjectName;
                    UpdatePHTGL_Quantity(item);

                }
                else if (SerialNumberArry.Length == 3)
                {
                    item.SubProject = GetPHTGL_QuantityByNumBer(SerialNumberArry[0], item.Major).ProjectName;
                    item.SubItemProject = GetPHTGL_QuantityByNumBer(SerialNumberArry[0] + "." + SerialNumberArry[1], item.Major).ProjectName;
                    UpdatePHTGL_Quantity(item);
                }

            }
        }

        #endregion
    }
    public class CustomComparer : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            if (string.IsNullOrEmpty(x) || string.IsNullOrEmpty(y))
            {
                return 0;
            }
            var xParts = x.Split('.');
            var yParts = y.Split('.');

            for (int i = 0; i < Math.Min(xParts.Length, yParts.Length); i++)
            {
                int xNumber, yNumber;
                if (int.TryParse(xParts[i], out xNumber) && int.TryParse(yParts[i], out yNumber))
                {
                    if (xNumber != yNumber)
                    {
                        return xNumber.CompareTo(yNumber);
                    }
                }
                else
                {
                    return x.CompareTo(y);
                }
            }

            return xParts.Length.CompareTo(yParts.Length);
        }
    }
    public class PHTGL_QuantityDtoIn
    {
        [ExcelColumnIndex("A")] public string SerialNumber { get; set; }
        [ExcelColumnIndex("B")] public string SubProject { get; set; }

        [ExcelColumnIndex("C")] public string SubItemProject { get; set; }

        [ExcelColumnIndex("D")] public string ProjectCode { get; set; }

        [ExcelColumnIndex("E")] public string ProjectName { get; set; }

        [ExcelColumnIndex("F")] public string ProjectDescription { get; set; }

        [ExcelColumnIndex("G")] public string UnitOfMeasurement { get; set; }

        [ExcelColumnIndex("H")] public string Quantity { get; set; }

        [ExcelColumnIndex("I")] public string TotalCostFixedComprehensiveUnitPrice { get; set; }

        [ExcelColumnIndex("J")] public string MainMaterialCost { get; set; }

        [ExcelColumnIndex("K")] public string TotalPrice { get; set; }

        [ExcelColumnIndex("L")] public string CalculationRule { get; set; }

        [ExcelColumnIndex("M")] public string WorkContent { get; set; }

        [ExcelColumnIndex("N")] public string Remarks { get; set; }
    }
}