using System;
using System.Collections.Generic;
using System.Linq;

namespace BLL
{
    /// <summary>
    /// 焊缝外观检测业务服务。
    /// </summary>
    public static class WeldAppearanceCheckService
    {
        /// <summary>
        /// 分页查询焊缝外观检测记录。
        /// </summary>
        /// <param name="projectId">项目ID。</param>
        /// <param name="checkCode">检测编号。</param>
        /// <param name="pipelineCode">管线号查询条件。</param>
        /// <param name="weldJointCode">焊口号查询条件。</param>
        /// <param name="qualified">合格状态，1为合格，0为不合格，空为全部。</param>
        /// <param name="pageIndex">页码，从0开始。</param>
        /// <param name="pageSize">每页记录数。</param>
        /// <returns>外观检测记录及总记录数。</returns>
        public static Tuple<List<Model.WeldAppearanceCheckItem>, int> GetList(string projectId,
            string checkCode, string pipelineCode, string weldJointCode, string qualified, int pageIndex, int pageSize)
        {
            var db = Funs.DB;
            var query = from c in db.HJGL_WeldAppearanceCheck
                        join w in db.HJGL_WeldJoint on c.WeldJointId equals w.WeldJointId
                        join p in db.Person_Persons on c.CheckPerson equals p.PersonId into persons
                        from p in persons.DefaultIfEmpty()
                        where string.IsNullOrEmpty(projectId) || c.ProjectId == projectId
                        select new { c, w, CheckPersonName = p == null ? string.Empty : p.PersonName };

            if (!string.IsNullOrWhiteSpace(checkCode))
            {
                query = query.Where(x => x.c.CheckCode == checkCode);
            }
            if (!string.IsNullOrWhiteSpace(pipelineCode))
            {
                query = query.Where(x => x.w.PipelineCode.Contains(pipelineCode));
            }
            if (!string.IsNullOrWhiteSpace(weldJointCode))
            {
                query = query.Where(x => x.w.WeldJointCode.Contains(weldJointCode));
            }
            if (qualified == "1" || qualified == "0")
            {
                bool isQualified = qualified == "1";
                query = query.Where(x => x.c.IsQualified == isQualified);
            }

            int total = query.Count();
            var data = query.OrderByDescending(x => x.c.CheckTime)
                .ThenByDescending(x => x.c.CreateTime)
                .Skip(pageIndex * pageSize)
                .Take(pageSize)
                .Select(x => new Model.WeldAppearanceCheckItem
                {
                    AppearanceCheckId = x.c.AppearanceCheckId,
                    CheckCode = x.c.CheckCode,
                    ProjectId = x.c.ProjectId,
                    WeldJointId = x.c.WeldJointId,
                    PipelineCode = x.w.PipelineCode,
                    WeldJointCode = x.w.WeldJointCode,
                    IsQualified = x.c.IsQualified,
                    QualifiedText = x.c.IsQualified ? "合格" : "不合格",
                    CheckPerson = x.c.CheckPerson,
                    CheckPersonName = x.CheckPersonName,
                    CheckTime = x.c.CheckTime,
                    Remark = x.c.Remark,
                    WeldReinforcement = x.c.WeldReinforcement,
                    WeldHeight = x.c.WeldHeight,
                    WeldWidth = x.c.WeldWidth,
                    SurfaceDefect = x.c.SurfaceDefect,
                    PreheatTemperature = x.c.PreheatTemperature,
                    InterpassTemperature = x.c.InterpassTemperature,
                    CreateTime = x.c.CreateTime
                }).ToList();
            PopulateReportFields(data);
            PopulateAttachUrls(data);
            return Tuple.Create(data, total);
        }

        private static void PopulateReportFields(List<Model.WeldAppearanceCheckItem> data)
        {
            List<string> weldJointIds = data.Select(x => x.WeldJointId).Distinct().ToList();
            if (weldJointIds.Count == 0)
            {
                return;
            }

            var details = Funs.DB.View_HJGL_WeldJoint
                .Where(x => weldJointIds.Contains(x.WeldJointId))
                .Select(x => new
                {
                    x.WeldJointId,
                    x.UnitWorkId,
                    x.UnitWorkName,
                    x.WelderCode,
                    x.Specification,
                    x.MaterialCode,
                    x.WeldingLocationCode,
                    x.WeldingMethodCode,
                    x.WeldingRod,
                    x.WeldingRodCode,
                    x.WeldingWire,
                    x.WeldingWireCode
                }).ToList();

            List<string> consumablesIds = details
                .SelectMany(x => new[] { x.WeldingWire, x.WeldingRod })
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Distinct()
                .ToList();
            var consumablesById = new Dictionary<string, string>();
            if (consumablesIds.Count > 0)
            {
                consumablesById = Funs.DB.Base_Consumables
                    .Where(x => consumablesIds.Contains(x.ConsumablesId))
                    .ToDictionary(x => x.ConsumablesId, x => x.ConsumablesName);
            }

            foreach (Model.WeldAppearanceCheckItem item in data)
            {
                var detail = details.FirstOrDefault(x => x.WeldJointId == item.WeldJointId);
                if (detail == null)
                {
                    continue;
                }

                item.UnitWorkId = detail.UnitWorkId;
                item.UnitWorkName = detail.UnitWorkName;
                item.WelderCode = detail.WelderCode;
                item.Specification = detail.Specification;
                item.MaterialCode = detail.MaterialCode;
                item.WeldingLocation = detail.WeldingLocationCode;
                item.WeldingMethodCode = detail.WeldingMethodCode;
                item.WeldingRodCode = detail.WeldingRodCode;
                item.WeldingWireCode = detail.WeldingWireCode;
                string wireName;
                string rodName;
                consumablesById.TryGetValue(detail.WeldingWire ?? string.Empty, out wireName);
                consumablesById.TryGetValue(detail.WeldingRod ?? string.Empty, out rodName);
                // 焊材牌号使用焊丝、焊条在耗材基础表中的名称，按既有报表口径以“+”合并并去重。
                item.WeldingMaterial = string.Join("+", new[] { wireName, rodName }
                    .Where(x => !string.IsNullOrWhiteSpace(x)).Distinct());
            }
        }

        /// <summary>
        /// 查询当前项目可用于筛选和打印的检测编号。
        /// </summary>
        /// <param name="projectId">项目ID。</param>
        /// <returns>检测编号列表。</returns>
        public static List<string> GetCheckCodes(string projectId)
        {
            return Funs.DB.HJGL_WeldAppearanceCheck
                .Where(x => (string.IsNullOrEmpty(projectId) || x.ProjectId == projectId)
                    && x.CheckCode != null && x.CheckCode != string.Empty)
                .Select(x => x.CheckCode)
                .Distinct()
                .OrderByDescending(x => x)
                .ToList();
        }

        /// <summary>
        /// 分页查询当前项目中已焊接的焊口。
        /// </summary>
        /// <param name="projectId">项目ID。</param>
        /// <param name="pipelineCode">管线号查询条件。</param>
        /// <param name="weldJointCode">焊口号查询条件。</param>
        /// <param name="pageIndex">页码，从0开始。</param>
        /// <param name="pageSize">每页记录数。</param>
        /// <returns>已焊接焊口列表。</returns>
        public static List<Model.WeldAppearanceJointItem> GetWeldedJoints(string projectId,
            string pipelineCode, string weldJointCode, int pageIndex, int pageSize)
        {
            var db = Funs.DB;
            var query = db.View_HJGL_WeldJoint.Where(x => x.ProjectId == projectId && x.WeldingDailyId != null);
            if (!string.IsNullOrWhiteSpace(pipelineCode))
            {
                query = query.Where(x => x.PipelineCode.Contains(pipelineCode));
            }
            if (!string.IsNullOrWhiteSpace(weldJointCode))
            {
                query = query.Where(x => x.WeldJointCode.Contains(weldJointCode));
            }
            return query.OrderBy(x => x.PipelineCode).ThenBy(x => x.WeldJointCode)
                .Skip(pageIndex * pageSize).Take(pageSize)
                .Select(x => new Model.WeldAppearanceJointItem
                {
                    WeldJointId = x.WeldJointId,
                    ProjectId = x.ProjectId,
                    PipelineCode = x.PipelineCode,
                    WeldJointCode = x.WeldJointCode,
                    WeldTypeCode = x.WeldTypeCode,
                    WeldingMethodCode = x.WeldingMethodCode,
                    WeldingDate = x.WeldingDateD
                }).ToList();
        }

        /// <summary>
        /// 查询焊口基础信息及历史外观检测记录。
        /// </summary>
        /// <param name="weldJointId">焊口ID。</param>
        /// <returns>焊口详情及外观检测历史。</returns>
        public static Model.WeldAppearanceJointItem GetJointDetail(string weldJointId)
        {
            var db = Funs.DB;
            var joint = db.View_HJGL_WeldJoint.Where(x => x.WeldJointId == weldJointId)
                .Select(x => new Model.WeldAppearanceJointItem
                {
                    WeldJointId = x.WeldJointId,
                    ProjectId = x.ProjectId,
                    PipelineCode = x.PipelineCode,
                    WeldJointCode = x.WeldJointCode,
                    WeldTypeCode = x.WeldTypeCode,
                    WeldingMethodCode = x.WeldingMethodCode,
                    WeldingDate = x.WeldingDateD
                }).FirstOrDefault();
            if (joint != null)
            {
                joint.History = GetHistory(weldJointId);
            }
            return joint;
        }

        /// <summary>
        /// 根据记录ID查询焊缝外观检测记录。
        /// </summary>
        /// <param name="appearanceCheckId">外观检测记录ID。</param>
        /// <returns>焊缝外观检测记录。</returns>
        public static Model.WeldAppearanceCheckItem GetById(string appearanceCheckId)
        {
            var item = GetHistoryQuery().FirstOrDefault(x => x.AppearanceCheckId == appearanceCheckId);
            if (item != null)
            {
                item.AttachUrl = GetAttachUrl(item.AppearanceCheckId);
            }
            return item;
        }

        /// <summary>
        /// 新增或修改焊缝外观检测记录。
        /// </summary>
        /// <param name="item">外观检测结果及附件信息。</param>
        /// <returns>外观检测记录ID。</returns>
        public static string Save(Model.WeldAppearanceCheckInput item)
        {
            if (item == null || string.IsNullOrWhiteSpace(item.WeldJointId))
            {
                throw new ArgumentException("焊口不能为空。");
            }

            var db = Funs.DB;
            var joint = db.HJGL_WeldJoint.FirstOrDefault(x => x.WeldJointId == item.WeldJointId);
            if (joint == null || joint.WeldingDailyId == null)
            {
                throw new ArgumentException("只能对已焊接焊口进行外观检测。");
            }

            string unitWorkName = (from pipeline in db.HJGL_Pipeline
                                   join unitWork in db.WBS_UnitWork on pipeline.UnitWorkId equals unitWork.UnitWorkId
                                   where pipeline.PipelineId == joint.PipelineId
                                   select unitWork.UnitWorkName).FirstOrDefault();
            if (string.IsNullOrWhiteSpace(unitWorkName))
            {
                throw new ArgumentException("焊口所属单位工程不存在，无法生成检测编号。");
            }
            DateTime checkTime = item.CheckTime ?? DateTime.Now;

            string id = string.IsNullOrWhiteSpace(item.AppearanceCheckId)
                ? Guid.NewGuid().ToString()
                : item.AppearanceCheckId;
            var check = db.HJGL_WeldAppearanceCheck.FirstOrDefault(x => x.AppearanceCheckId == id);
            bool hasExistingPhoto = db.AttachFile.Any(x => x.MenuId == Const.HJGL_WeldAppearanceCheckMenuId && x.ToKeyId == id);
            if (string.IsNullOrWhiteSpace(item.AttachUrl) && !hasExistingPhoto)
            {
                throw new ArgumentException("请至少上传一张外观检测照片。");
            }

            if (check == null)
            {
                check = new Model.HJGL_WeldAppearanceCheck
                {
                    AppearanceCheckId = id,
                    CreateTime = DateTime.Now,
                    CreateUser = string.IsNullOrEmpty(item.CreateUser) ? item.CheckPerson : item.CreateUser
                };
                db.HJGL_WeldAppearanceCheck.InsertOnSubmit(check);
            }
            else
            {
                check.ModifyUser = string.IsNullOrEmpty(item.CreateUser) ? item.CheckPerson : item.CreateUser;
                check.ModifyTime = DateTime.Now;
            }

            check.ProjectId = string.IsNullOrEmpty(item.ProjectId) ? joint.ProjectId : item.ProjectId;
            check.WeldJointId = item.WeldJointId;
            // 检测编号由单位工程和检测日期统一生成，PC页面与WebAPI保存共用此规则。
            check.CheckCode = "FCC-" + unitWorkName.Trim() + "-" + checkTime.ToString("yyyyMMdd");
            check.IsQualified = item.IsQualified;
            check.CheckPerson = item.CheckPerson;
            check.CheckTime = checkTime;
            check.Remark = item.Remark;
            check.WeldReinforcement = item.WeldReinforcement;
            check.WeldHeight = item.WeldHeight;
            check.WeldWidth = item.WeldWidth;
            check.SurfaceDefect = item.SurfaceDefect;
            check.PreheatTemperature = item.PreheatTemperature;
            check.InterpassTemperature = item.InterpassTemperature;
            db.SubmitChanges();

            if (!string.IsNullOrWhiteSpace(item.AttachUrl))
            {
                UploadFileService.SaveAttachUrl(UploadFileService.GetSourceByAttachUrl(item.AttachUrl, 10, null),
                    item.AttachUrl, Const.HJGL_WeldAppearanceCheckMenuId, id);
            }
            return id;
        }

        /// <summary>
        /// 删除焊缝外观检测记录及其附件。
        /// </summary>
        /// <param name="appearanceCheckId">外观检测记录ID。</param>
        public static void Delete(string appearanceCheckId)
        {
            var db = Funs.DB;
            var check = db.HJGL_WeldAppearanceCheck.FirstOrDefault(x => x.AppearanceCheckId == appearanceCheckId);
            if (check == null)
            {
                return;
            }
            db.HJGL_WeldAppearanceCheck.DeleteOnSubmit(check);
            db.SubmitChanges();
            CommonService.DeleteAttachFileById(Const.HJGL_WeldAppearanceCheckMenuId, appearanceCheckId);
        }

        /// <summary>
        /// 查询指定焊口的历史外观检测记录。
        /// </summary>
        /// <param name="weldJointId">焊口ID。</param>
        /// <returns>按检测时间倒序排列的历史记录。</returns>
        private static List<Model.WeldAppearanceCheckItem> GetHistory(string weldJointId)
        {
            var data = GetHistoryQuery().Where(x => x.WeldJointId == weldJointId)
                .OrderByDescending(x => x.CheckTime).ThenByDescending(x => x.CreateTime).ToList();
            PopulateAttachUrls(data);
            return data;
        }

        /// <summary>
        /// 构建焊缝外观检测记录查询。
        /// </summary>
        /// <returns>焊缝外观检测记录查询对象。</returns>
        private static IQueryable<Model.WeldAppearanceCheckItem> GetHistoryQuery()
        {
            var db = Funs.DB;
            return from c in db.HJGL_WeldAppearanceCheck
                   join w in db.HJGL_WeldJoint on c.WeldJointId equals w.WeldJointId
                   join p in db.Person_Persons on c.CheckPerson equals p.PersonId into persons
                   from p in persons.DefaultIfEmpty()
                   select new Model.WeldAppearanceCheckItem
                   {
                       AppearanceCheckId = c.AppearanceCheckId,
                       CheckCode = c.CheckCode,
                       ProjectId = c.ProjectId,
                       WeldJointId = c.WeldJointId,
                       PipelineCode = w.PipelineCode,
                       WeldJointCode = w.WeldJointCode,
                       IsQualified = c.IsQualified,
                       QualifiedText = c.IsQualified ? "合格" : "不合格",
                       CheckPerson = c.CheckPerson,
                       CheckPersonName = p == null ? string.Empty : p.PersonName,
                       CheckTime = c.CheckTime,
                       Remark = c.Remark,
                       WeldReinforcement = c.WeldReinforcement,
                       WeldHeight = c.WeldHeight,
                       WeldWidth = c.WeldWidth,
                       SurfaceDefect = c.SurfaceDefect,
                       PreheatTemperature = c.PreheatTemperature,
                       InterpassTemperature = c.InterpassTemperature,
                       CreateTime = c.CreateTime
                   };
        }

        /// <summary>
        /// 为外观检测记录补充附件地址。
        /// </summary>
        /// <param name="data">外观检测记录。</param>
        private static void PopulateAttachUrls(IList<Model.WeldAppearanceCheckItem> data)
        {
            foreach (var item in data)
            {
                item.AttachUrl = GetAttachUrl(item.AppearanceCheckId);
            }
        }

        /// <summary>
        /// 查询外观检测记录的附件地址。
        /// </summary>
        /// <param name="id">外观检测记录ID。</param>
        /// <returns>附件地址。</returns>
        private static string GetAttachUrl(string id)
        {
            var db = Funs.DB;
            var url = db.AttachFile.Where(x => x.MenuId == Const.HJGL_WeldAppearanceCheckMenuId && x.ToKeyId == id)
                .Select(x => x.AttachUrl).FirstOrDefault();
            return string.IsNullOrEmpty(url) ? url : url.Replace('\\', '/');
        }
    }
}