using System;
using System.Collections.Generic;
using System.Data;
using SuperMap.RealEstate.ServiceModel;
using Business = SuperMap.RealEstate.PlatForm.Dashboard.Business;
using HCC = HZQR.Common.Common;
using HZQR.Common;

namespace EShang.Common.GeneralMethod
{
    /// <summary>
    /// 解析规则表相关方法
    /// 2025/2/11 17:30:22自动生成
    /// </summary>
    public class ANALYSISRULEHelper
    {
        #region 获取解析规则表列表
        /// <summary>
        /// 获取解析规则表列表
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="TotalCount">查询结果总数</param>
        /// <param name="searchModel">查询条件对象</param>
        public static List<Model.ANALYSISRULEModel> GetANALYSISRULEList(Transaction transaction,
            ref int TotalCount, Model.SearchModel<Model.ANALYSISRULEModel> searchModel)
        {
            List<Model.ANALYSISRULEModel> ANALYSISRULEList = new List<Model.ANALYSISRULEModel>();

            string WhereSQL = "", RowFilterSQL = "";
            if (searchModel.SearchParameter != null)
            {
                WhereSQL = OperationDataHelper<Model.ANALYSISRULEModel>.GetWhereSQL(searchModel.SearchParameter, searchModel.QueryType, "",
                    "CREATE_DATE_Start", "CREATE_DATE_End", "UPDATE_DATE_Start", "UPDATE_DATE_End");
                if (WhereSQL != "")
                {
                    WhereSQL = " WHERE " + WhereSQL;
                }
                //查询创建时间
                if (searchModel.SearchParameter.CREATE_DATE_Start.TryParseToString() != "")
                {
                    WhereSQL += (WhereSQL == "" ? " WHERE " : " AND ") + "CREATE_DATE >= TO_DATE('" +
                        searchModel.SearchParameter.CREATE_DATE_Start.Split(' ')[0] + "','YYYY/MM/DD')";
                }
                if (searchModel.SearchParameter.CREATE_DATE_End.TryParseToString() != "")
                {
                    WhereSQL += (WhereSQL == "" ? " WHERE " : " AND ") + "CREATE_DATE < TO_DATE('" +
                        searchModel.SearchParameter.CREATE_DATE_End.Split(' ')[0] + "','YYYY/MM/DD') + 1";
                }
                //查询修改时间
                if (searchModel.SearchParameter.UPDATE_DATE_Start.TryParseToString() != "")
                {
                    WhereSQL += (WhereSQL == "" ? " WHERE " : " AND ") + "UPDATE_DATE >= TO_DATE('" +
                        searchModel.SearchParameter.UPDATE_DATE_Start.Split(' ')[0] + "','YYYY/MM/DD')";
                }
                if (searchModel.SearchParameter.UPDATE_DATE_End.TryParseToString() != "")
                {
                    WhereSQL += (WhereSQL == "" ? " WHERE " : " AND ") + "UPDATE_DATE < TO_DATE('" +
                        searchModel.SearchParameter.UPDATE_DATE_End.Split(' ')[0] + "','YYYY/MM/DD') + 1";
                }
            }

            DataTable dtANALYSISRULE = new Business.CATERINGGROSSMARGIN(transaction).ExecuteDataTable(
                "SELECT * FROM PLATFORM_DASHBOARD.T_ANALYSISRULE" + WhereSQL);
            //增加组合查询条件
            if (searchModel.keyWord != null && !string.IsNullOrWhiteSpace(searchModel.keyWord.Key))
            {
                foreach (string KeyName in searchModel.keyWord.Key.Split(','))
                {
                    RowFilterSQL += (RowFilterSQL == "" ? "" : " or ") +
                        KeyName + " like '%" + searchModel.keyWord.Value + "%'";
                }
            }
            if (RowFilterSQL != "")
            {
                dtANALYSISRULE.DefaultView.RowFilter = RowFilterSQL;
            }
            //排序：
            dtANALYSISRULE.DefaultView.Sort = searchModel.SortStr;
            dtANALYSISRULE = dtANALYSISRULE.DefaultView.ToTable();
            //获取查询结果总记录条数
            TotalCount = dtANALYSISRULE.Rows.Count;
            //根据传入的页码和每页显示条数返回结果
            dtANALYSISRULE = CommonHelper.GetDataTableWithPageSize(dtANALYSISRULE, searchModel.PageSize, searchModel.PageIndex);

            foreach (DataRow drANALYSISRULE in dtANALYSISRULE.Rows)
            {
                Model.ANALYSISRULEModel analysisruleModel = new Model.ANALYSISRULEModel();
                //绑定解析规则表数据对象
                BindDataRowToModel(drANALYSISRULE, analysisruleModel);

                ANALYSISRULEList.Add(analysisruleModel);
            }

            return ANALYSISRULEList;
        }

        #region 绑定model
        /// <summary>
        /// 绑定model
        /// </summary>
        /// <param name="drANALYSISRULE">datarow数据源</param>
        /// <param name="analysisruleModel">model对象</param>
        public static void BindDataRowToModel(DataRow drANALYSISRULE, Model.ANALYSISRULEModel analysisruleModel)
        {
            if (drANALYSISRULE["ANALYSISRULE_ID"].ToString() != "")
            {
                analysisruleModel.ANALYSISRULE_ID = drANALYSISRULE["ANALYSISRULE_ID"].TryParseToInt();    //内码
            }
            analysisruleModel.TRIGGER_WORDS = drANALYSISRULE["TRIGGER_WORDS"].ToString();    //触发关键词，用于匹配用户输入的关键词（多个关键词用逗号分隔）
            analysisruleModel.USER_INTENT = drANALYSISRULE["USER_INTENT"].ToString();    //用户意图标识，归类规则的用途（如“营收分析”或“服务区查询”）
            analysisruleModel.API_ENDPOINT = drANALYSISRULE["API_ENDPOINT"].ToString();    //接口地址，前端根据解析结果调用该接口获取数据
            analysisruleModel.PARAM_TEMPLATE = drANALYSISRULE["PARAM_TEMPLATE"].ToString();    //参数模板，以 JSON 格式存储，用于动态生成接口请求参数
            analysisruleModel.PARSING_RULES = drANALYSISRULE["PARSING_RULES"].ToString();    //通用解析逻辑，以 JSON 格式存储，定义字段解析的详细规则
            analysisruleModel.RESPONSE_CONFIG = drANALYSISRULE["RESPONSE_CONFIG"].ToString();    //响应内容配置，以 JSON 格式存储，定义接口返回内容的展示逻辑和字段控制
            analysisruleModel.OUTPUT_FORMAT = drANALYSISRULE["OUTPUT_FORMAT"].ToString();    //输出格式，定义数据展示方式，如 JSON、表格 或 图表
            if (drANALYSISRULE["ENABLE_CHART"].ToString() != "")
            {
                analysisruleModel.ENABLE_CHART = drANALYSISRULE["ENABLE_CHART"].TryParseToShort();    //图表输出（0：不支持；1：支持）
            }
            if (drANALYSISRULE["ENABLE_PDF_EXPORT"].ToString() != "")
            {
                analysisruleModel.ENABLE_PDF_EXPORT = drANALYSISRULE["ENABLE_PDF_EXPORT"].TryParseToShort();    //导出为PDF（0：不支持；1：支持）
            }
            if (drANALYSISRULE["ENABLE_VIEW_MORE"].ToString() != "")
            {
                analysisruleModel.ENABLE_VIEW_MORE = drANALYSISRULE["ENABLE_VIEW_MORE"].TryParseToShort();    //“查看更多”功能（0：不支持；1：支持）
            }
            if (drANALYSISRULE["RULE_PRIORITY"].ToString() != "")
            {
                analysisruleModel.RULE_PRIORITY = drANALYSISRULE["RULE_PRIORITY"].TryParseToShort();    //规则优先级，值越小优先级越高，用于多规则冲突时的选择
            }
            if (drANALYSISRULE["RULE_SOURCE"].ToString() != "")
            {
                analysisruleModel.RULE_SOURCE = drANALYSISRULE["RULE_SOURCE"].TryParseToShort();    //规则来源（1000：系统默认；2000：用户自定义）
            }
            if (!string.IsNullOrWhiteSpace(drANALYSISRULE["CREATE_DATE"].ToString()))
            {
                //创建时间
                analysisruleModel.CREATE_DATE = drANALYSISRULE["CREATE_DATE"].ToString();
            }
            if (!string.IsNullOrWhiteSpace(drANALYSISRULE["UPDATE_DATE"].ToString()))
            {
                //修改时间
                analysisruleModel.UPDATE_DATE = drANALYSISRULE["UPDATE_DATE"].ToString();
            }
            if (drANALYSISRULE["ANALYSISRULE_STATE"].ToString() != "")
            {
                analysisruleModel.ANALYSISRULE_STATE = drANALYSISRULE["ANALYSISRULE_STATE"].TryParseToShort();    //启用规则（0：禁用；1：启用）
            }
            analysisruleModel.ANALYSISRULE_DESC = drANALYSISRULE["ANALYSISRULE_DESC"].ToString();    //备注说明，记录规则的背景、用途或配置意图
            if (drANALYSISRULE["ENABLE_TABLE"].ToString() != "")
            {
                analysisruleModel.ENABLE_TABLE = drANALYSISRULE["ENABLE_TABLE"].TryParseToShort();    //表格输出（0：不支持；1：支持）
            }
            if (drANALYSISRULE["SPRESPONSE_TYPE"].ToString() != "")
            {
                analysisruleModel.SPRESPONSE_TYPE = drANALYSISRULE["SPRESPONSE_TYPE"].TryParseToShort();    //服务区返回格式（1：单个服务区；2：多个服务区）
            }
            analysisruleModel.PARAM_FIELD = drANALYSISRULE["PARAM_FIELD"].ToString();    //入参配置
            analysisruleModel.RESPONSE_FIELD = drANALYSISRULE["RESPONSE_FIELD"].ToString();    //返参配置
            if (drANALYSISRULE["SHOW_CHILDNODE"].ToString() != "")
            {
                analysisruleModel.SHOW_CHILDNODE = drANALYSISRULE["SHOW_CHILDNODE"].TryParseToShort();    //显示子集（0：不显示；1：显示）
            }
            analysisruleModel.CHILD_NODENAME = drANALYSISRULE["CHILD_NODENAME"].ToString();    //子集名称
        }
        #endregion

        #endregion

        #region 获取解析规则表明细
        /// <summary>
        /// 获取解析规则表明细
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="ANALYSISRULEId">解析规则表内码</param>
        public static Model.ANALYSISRULEModel GetANALYSISRULEDetail(Transaction transaction, int ANALYSISRULEId)
        {
            Model.ANALYSISRULEModel analysisruleModel = new Model.ANALYSISRULEModel();

            string WhereSQL = "WHERE ANALYSISRULE_ID = " + ANALYSISRULEId;
            //查询明细数据
            DataTable dtANALYSISRULE = new Business.CATERINGGROSSMARGIN(transaction).ExecuteDataTable(
                "SELECT * FROM PLATFORM_DASHBOARD.T_ANALYSISRULE " + WhereSQL);
            if (dtANALYSISRULE.Rows.Count > 0)
            {
                //绑定解析规则表数据对象
                BindDataRowToModel(dtANALYSISRULE.Rows[0], analysisruleModel);
            }

            return analysisruleModel;
        }
        #endregion

        #region 同步解析规则表
        /// <summary>
        /// 赋值解析规则表数据对象
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="analysisruleModel">解析规则表数据对象</param>
        public static bool SynchroANALYSISRULE(Transaction transaction, Model.ANALYSISRULEModel analysisruleModel)
        {
            bool SynchroFlag = true;

            string SQLString;
            List<string> excludeField = new List<string>();
            Dictionary<string, string> dateFieldList = new Dictionary<string, string>();
            string tableName = "PLATFORM_DASHBOARD.T_ANALYSISRULE", keyField = "ANALYSISRULE_ID", seqName = "SEQ_ANALYSISRULE";
            Business.CATERINGGROSSMARGIN _CATERINGGROSSMARGIN = new Business.CATERINGGROSSMARGIN(transaction);

            #region 添加SQL语句中需要排除在外的字段
            excludeField.Add("CREATE_DATE_Start");
            excludeField.Add("CREATE_DATE_End");
            excludeField.Add("UPDATE_DATE_Start");
            excludeField.Add("UPDATE_DATE_End");
            #endregion

            #region 添加SQL语句中日期相关字段的执行语句
            //创建时间
            if (!string.IsNullOrWhiteSpace(analysisruleModel.CREATE_DATE))
            {
                dateFieldList.Add("CREATE_DATE", "TO_DATE('" +
                    analysisruleModel.CREATE_DATE + "','YYYY/MM/DD HH24:MI:SS')");
            }
            else
            {
                dateFieldList.Add("CREATE_DATE", "NULL");
            }
            //修改时间
            if (!string.IsNullOrWhiteSpace(analysisruleModel.UPDATE_DATE))
            {
                dateFieldList.Add("UPDATE_DATE", "TO_DATE('" +
                    analysisruleModel.UPDATE_DATE + "','YYYY/MM/DD HH24:MI:SS')");
            }
            else
            {
                dateFieldList.Add("UPDATE_DATE", "NULL");
            }
            #endregion

            if (analysisruleModel.ANALYSISRULE_ID != null)
            {
                string WhereSQL = " WHERE ANALYSISRULE_ID = " + analysisruleModel.ANALYSISRULE_ID;
                DataTable dtANALYSISRULE = _CATERINGGROSSMARGIN.ExecuteDataTable(
                    "SELECT * FROM PLATFORM_DASHBOARD.T_ANALYSISRULE" + WhereSQL);
                if (dtANALYSISRULE.Rows.Count > 0)
                {
                    SQLString = OperationDataHelper<Model.ANALYSISRULEModel>.GetTableExcuteSQL(
                        analysisruleModel, 1, tableName, keyField, seqName, dateFieldList, excludeField, WhereSQL);
                }
                else
                {
                    return false;
                }
            }
            else
            {
                DataTable dtANALYSISRULE = _CATERINGGROSSMARGIN.ExecuteDataTable(
                    "SELECT " + seqName + ".NEXTVAL FROM DUAL");
                analysisruleModel.ANALYSISRULE_ID = dtANALYSISRULE.Rows[0][0].TryParseToInt();
                SQLString = OperationDataHelper<Model.ANALYSISRULEModel>.GetTableExcuteSQL(
                    analysisruleModel, 0, tableName, keyField, seqName, dateFieldList, excludeField);
            }
            _CATERINGGROSSMARGIN.ExecuteNonQuery(SQLString, null);

            return SynchroFlag;
        }
        #endregion

        #region 删除解析规则表
        /// <summary>
        /// 删除解析规则表
        /// </summary>
        /// <param name="transaction">事务管理器</param>
        /// <param name="ANALYSISRULEId">解析规则表内码</param>
        public static bool DeleteANALYSISRULE(Transaction transaction, int? ANALYSISRULEId)
        {
            bool DeleteFlag = false;

            if (ANALYSISRULEId != null)
            {
                string SQLString = "UPDATE PLATFORM_DASHBOARD.T_ANALYSISRULE SET ANALYSISRULE_STATE = 0 WHERE ANALYSISRULE_ID = " + ANALYSISRULEId;
                int ExcuteCount = new Business.CATERINGGROSSMARGIN(transaction).ExecuteNonQuery(SQLString, null);
                if (ExcuteCount > 0)
                {
                    DeleteFlag = true;
                }
            }

            return DeleteFlag;
        }
        #endregion
    }
}