using System.Text;
using Gs.Entity.BaseInfo;
using Gs.Entity.Sys;
using GS.QC.Models;
using Gs.Toolbox;
using Gs.Toolbox.ApiCore.Abstract.Mvc;
using Gs.Toolbox.ApiCore.Common.Mvc;
using Gs.Toolbox.ApiCore.Group;
using Masuit.Tools;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using SqlSugar;
using System.Data;

namespace GS.QC.Service;

[ApiGroup(ApiGroupNames.QC)]
public class MesQaMjManager : Repository<MesQaMj>, IRomteService
{
    private readonly IHttpContextAccessor _http;

    private readonly string _userCode, _userGuid, _orgFids;

    public MesQaMjManager(IHttpContextAccessor httpContextAccessor)
    {
        _http = httpContextAccessor;


        (_userCode, _userGuid, _orgFids) =
            UtilityHelper.GetUserGuidAndOrgGuid(_http);
    }

    /// <summary>
    ///     查询列表，支持分页
    /// </summary>
    /// <param name="query"></param>
    /// <returns></returns>
    [RequestMethod(RequestMethods.POST)]
    public ReturnDto<PageList<MesQaMj>> GetListPage(PageQuery query)
    {
        var pageList = new PageList<MesQaMj>();
        try
        {
            var _sbWhere = new StringBuilder(" 1=1 " + query.keyWhere);
            var _sbBy =
                new StringBuilder(query.sortName + " " + query.sortOrder);
            var totalCount = 0;
            var itemsList = Db.Queryable<MesQaMj, MesItems, SysOrganization, MesSupplier>(
                    (a, b, org, d) => new JoinQueryInfos(
                        JoinType.Inner, a.ItemId == b.Id,
                        JoinType.Inner, b.FSubsidiary == org.Fid,
                        JoinType.Left, a.SuppId == d.Id.ToString()
                    ))
                 .Where(_sbWhere.ToString())
                 .OrderBy(_sbBy.ToString())
                .Select((a, b, org, d) => new MesQaMj
                {
                    FSubsidiary = "(" + org.FNumber + ") " + org.Name,
                    Guid = a.Guid.SelectAll(),
                    gysName = d.SuppName,
                    itemName = b.ItemName,
                    suppNo = d.SuppNo
                })
                .ToPageList(query.currentPage, query.everyPageSize,
                    ref totalCount);
            pageList = new PageList<MesQaMj>(itemsList, totalCount,
               query.everyPageSize);
            return ReturnDto<PageList<MesQaMj>>.QuickReturn(pageList,
                ReturnCode.Success, "读取成功");
        }
        catch (Exception ex)
        {
            return ReturnDto<PageList<MesQaMj>>.QuickReturn(pageList,
                ReturnCode.Default, ex.Message);
        }
    }

    /// <summary>
    ///     根据主表id读取主表
    /// </summary>
    /// <param name="model"></param>
    /// <returns></returns>
    [RequestMethod(RequestMethods.POST)]
    public ReturnDto<MesQaMj> GetModel(
        [FromBody] MesQaMj model)
    {
        var m = base.GetById(model.Guid);
        System.Text.StringBuilder sbSql = new StringBuilder();
        sbSql.Append("select  i.FSubsidiary,i.[item_name],i.[item_model],i.item_no,mj.SUPP_ID,sup.supp_name,sup.supp_no");
        sbSql.Append(" from MES_ITEMS i right join [dbo].[MES_QA_MJ] mj on i.id=mj.ITEM_ID left join [dbo].[MES_SUPPLIER] sup on sup.id=mj.SUPP_ID ");
        sbSql.Append("  where i.id=" + m.ItemId);
        try
        {
            DataSet dset = new DataSet();
            dset = Gs.Toolbox.DbHelperSQL.Query(sbSql.ToString());
            System.Data.DataRow r = dset.Tables[0].Rows[0];
            m.FSubsidiary = r["FSubsidiary"].ToString();
            m.ItemNo = r["item_no"].ToString();
            m.suppNo = r["supp_no"].ToString();
        }
        catch (Exception ex)
        {
            LogHelper.Debug(ToString(), "GetModel error：" + ex.Message);
        }
        if (m != null)
            return ReturnDto<MesQaMj>.QuickReturn(m,
                ReturnCode.Success, "读取成功！");
        return ReturnDto<MesQaMj>.QuickReturn(m, ReturnCode.Default, "读取失败！");
    }


    /// <summary>
    ///     增加或编辑实体
    /// </summary>
    /// <param name="model"></param>
    /// <returns></returns>
    [RequestMethod(RequestMethods.POST)]
    public ReturnDto<string?> EditModel([FromBody] MesQaMj model)
    {
        if (UtilityHelper.CheckGuid(model.Guid))
        {
            var cont = 0;
            cont = IsChkOrUnChk(model.Guid.ToString());
            if (cont > 0)
                return ReturnDto<string>.QuickReturn("", ReturnCode.Exception, "修改失败，该信息已被审核！");
        }
        try
        {
            // ===== 新增：简化的免检维护校验逻辑 =====
            var validationResult = ValidateItemMaintenance(model);
            if (!validationResult.IsSuccess)
            {
                return ReturnDto<string>.QuickReturn("", ReturnCode.Default, validationResult.Message);
            }

            // ===== 修改：组织一致性校验（仅在有供应商时进行） =====
            // 当没有维护供应商时（全免检），跳过组织校验
            if (!string.IsNullOrEmpty(model.SuppId))
            {
                string supOrg = "", itemOrg = "";
                supOrg = Gs.Toolbox.DbHelperSQL.GetSingle("select top 1 FSubsidiary from MES_SUPPLIER a where a.id=" + model.SuppId.ToString()).ToString();
                itemOrg = Gs.Toolbox.DbHelperSQL.GetSingle("select top 1 FSubsidiary from MES_ITEMS a where a.id=" + model.ItemId.ToString()).ToString();
                if (supOrg != itemOrg)
                {
                    return ReturnDto<string>.QuickReturn("",
                  ReturnCode.Default, "供应商和物料不在同一组织下，请重新选择！");
                }
            }
            Db.Ado.BeginTran();
            if (!UtilityHelper.CheckGuid(model.Guid))
            {
                model.Guid = Guid.NewGuid();
                model.CreateBy = _userCode;
                model.CreateDate = DateTime.Now;
                model.LastupdateBy = _userCode;
                model.LastupdateDate = DateTime.Now;
                model.Status = false;
                base.Insert(model);
            }
            else
            {
                model.LastupdateBy = _userCode;
                model.LastupdateDate = DateTime.Now;
                Db.Updateable(model).IgnoreColumns(true)
                    .ExecuteCommand();
            }

            Db.Ado.CommitTran();
        }
        catch (Exception ex)
        {
            LogHelper.Debug(this.ToString(), "EditModel error：" + ex.Message);
            Db.Ado.RollbackTran();
            return ReturnDto<string>.QuickReturn("", ReturnCode.Exception, ex.Message);
        }

        return ReturnDto<string>.QuickReturn(model.Guid.ToString(),
            ReturnCode.Success, "操作成功！");
    }

    /// <summary>
    ///     删除主表
    /// </summary>
    /// <param name="guid"></param>
    /// <returns></returns>
    [RequestMethod(RequestMethods.POST)]
    public ReturnDto<int?> DeleteModel([FromBody] JArray guidList)
    {
        var intArray = guidList.ToObject<string[]>();
        var cont = IsChkOrUnChk(intArray[0]);
        if (cont > 0)
            return ReturnDto<int>.QuickReturn(default(int?),
                ReturnCode.Exception, "删除失败，该信息已被审核！");

        int? rtnInt = base.DeleteByIds(intArray)
            ? intArray.Length
            : 0;
        return rtnInt > 0
            ? ReturnDto<int>.QuickReturn(rtnInt, ReturnCode.Success,
                "操作成功，共删除" + rtnInt + "条数据！")
            : ReturnDto<int>.QuickReturn(rtnInt, ReturnCode.Exception,
                "删除失败，请重试！");
    }

    /// <summary>
    ///     查看免检物料是否重复维护
    /// </summary>
    /// <param name="itemId"></param>
    /// <returns></returns>
    [RequestMethod(RequestMethods.POST)]
    public ReturnDto<int?> GetCount([FromBody] string? itemIdStr)
    {
        if (itemIdStr.IsNullOrEmpty())
        {
            int? rtnInt = 0;
            return ReturnDto<int>.QuickReturn(rtnInt, ReturnCode.Success,
                "");
        }

        var itemId = Convert.ToInt32(itemIdStr);

        int? count = Db.Queryable<MesQaMj>()
            .Where(s => s.ItemId == itemId)
            .Count();

        return ReturnDto<int>.QuickReturn(count, ReturnCode.Success,
            "");
    }

    private int IsChkOrUnChk(string? _guid)
    {
        var cont = Db.Queryable<MesQaMj>()
            .Where(it =>
                it.Guid == Guid.Parse(_guid) && it.Status == true)
            .Count();
        return cont;
    }

    /// <summary>
    /// ===== 新增方法：简化的免检维护校验逻辑 =====
    /// 业务规则（互斥原则）：
    /// 1. 全免检模式：物料不维护供应商（SuppId为空），表示对所有供应商免检
    /// 2. 指定免检模式：物料维护特定供应商，表示仅对指定供应商免检
    /// 3. 两种模式不能共存，一旦选择了一种模式，就不能切换到另一种模式
    /// 4. 同物料+同供应商的记录不允许重复
    /// </summary>
    /// <param name="model">要保存的免检记录</param>
    /// <returns>校验结果</returns>
    private (bool IsSuccess, string Message) ValidateItemMaintenance(MesQaMj model)
    {
        // 查询当前物料的所有免检记录
        var query = Db.Queryable<MesQaMj>()
            .Where(x => x.ItemId == model.ItemId);

        // 如果是编辑操作，排除当前记录避免误判
        if (UtilityHelper.CheckGuid(model.Guid))
        {
            query = query.Where(x => x.Guid != model.Guid);
        }

        var existingRecords = query.ToList();
        bool isCurrentGlobalMode = string.IsNullOrEmpty(model.SuppId); // 当前要保存的是否为全免检模式

        // 检查现有记录的模式
        var hasGlobalRecord = existingRecords.Any(x => string.IsNullOrEmpty(x.SuppId));      // 是否已有全免检记录
        var hasSpecificRecord = existingRecords.Any(x => !string.IsNullOrEmpty(x.SuppId));  // 是否已有指定供应商免检记录

        if (isCurrentGlobalMode)
        {
            // 要保存全免检模式
            if (hasGlobalRecord)
            {
                return (false, "该物料已存在全免检记录，不能重复添加！");
            }
            if (hasSpecificRecord)
            {
                return (false, "该物料已维护了指定供应商免检，不能再设置全免检模式！请继续维护具体供应商。");
            }
        }
        else
        {
            // 要保存指定供应商免检模式
            if (hasGlobalRecord)
            {
                return (false, "该物料已设置为全免检模式，不能再添加指定供应商免检记录！");
            }
            
            // 检查是否与现有的指定供应商记录重复
            var hasDuplicateSupplier = existingRecords.Any(x => x.SuppId == model.SuppId);
            if (hasDuplicateSupplier)
            {
                return (false, "该物料与该供应商的免检记录已存在，不能重复添加！");
            }
        }

        return (true, ""); // 校验通过
    }
}