using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using Kingdee.BOS;
using Kingdee.BOS.Core.Bill.PlugIn;
using Kingdee.BOS.Core.Bill.PlugIn.Args;
using Kingdee.BOS.Core.CommonFilter;
using Kingdee.BOS.Core.DynamicForm;
using Kingdee.BOS.Core.DynamicForm.PlugIn.Args;
using Kingdee.BOS.Core.DynamicForm.PlugIn.ControlModel;
using Kingdee.BOS.Core.Metadata;
using Kingdee.BOS.Core.Metadata.BarElement;
using Kingdee.BOS.Core.Metadata.ControlElement;
using Kingdee.BOS.Core.Metadata.EntityElement;
using Kingdee.BOS.Core.Permission;
using Kingdee.BOS.Core.SqlBuilder;
using Kingdee.BOS.JSON;
using Kingdee.BOS.Model.ListFilter;
using Kingdee.BOS.Orm;
using Kingdee.BOS.Orm.DataEntity;
using Kingdee.BOS.Serialization;
using Kingdee.BOS.ServiceHelper;
using Kingdee.BOS.Util;

namespace GZ.BGP.K3.GSP.Business.PlugIn.StorageAndMaintenance
{
    [HotUpdate]
    [Description("【自动生成养护监控方案配置】【表单插件】")]
    public class AutoMaintPlanEdit : AbstractBillPlugIn
    {
        private FilterMetaData _filterMetaData;

        private object _compareTypes;

        private object _logicData;

        private ListFilterModel _listFilterModel;

        private Dictionary<string, FormMetadata> dctObjectMetaData = new Dictionary<string, FormMetadata>();

        protected DataRule _dataRule = new DataRule();

        private bool isDataRuleSuccess = true;

        private BusinessInfo _currBusinessInfo;

        private LayoutInfo _currLayoutInfo;

        private SetLayoutInfoArgs _ee;

        protected virtual bool FromXML => true;

        public override void AfterBarItemClick(AfterBarItemClickEventArgs e)
        {
            base.AfterBarItemClick(e);
        }

        public override void OnSetBusinessInfo(SetBusinessInfoArgs e)
        {
            base.OnSetBusinessInfo(e);
            FormMetadata formMetadata = (FormMetadata)ObjectUtils.CreateCopy(base.View.OpenParameter.FormMetaData);
            _currBusinessInfo = formMetadata.BusinessInfo;
            _currLayoutInfo = formMetadata.GetLayoutInfo();
        }

        public override void OnSetLayoutInfo(SetLayoutInfoArgs e)
        {
            base.OnSetLayoutInfo(e);
            e.LayoutInfo = _currLayoutInfo;
            e.BillLayoutInfo = _currLayoutInfo;
            _ee = e;
            base.View.SendDynamicFormAction(base.View);
        }

        public override void OnInitialize(InitializeEventArgs e)
        {
            base.OnInitialize(e);
            InitialFilterMetaData();
            InitialFilterGrid();
            _currLayoutInfo.GetFormAppearance().Menu.GetBarItem("tbSplitButton_1");
            _currLayoutInfo.GetFormAppearance().Menu.GetBarItem("tbButton_1");
            _currLayoutInfo.GetFormAppearance().Menu.GetBarItem("tbSplitButton_1");
            base.View.GetMainBarItem("tbNew");
            BarButtonItem barButtonItem = new BarButtonItem();
            barButtonItem.Key = "tbDdd";
            barButtonItem.Name = "tbDdd";
            barButtonItem.Description = new LocaleValue("测试");
            barButtonItem.Caption = new LocaleValue("测试");
            barButtonItem.Style = EnumBarItemStyle.BarButtonItem;
            barButtonItem.IsShowTitle = true;
            barButtonItem.Visible = -1;
            barButtonItem.Seq = 16;
            _currLayoutInfo.GetFormAppearance().Menu.AddBarItem(barButtonItem);
            _currLayoutInfo.Appearances.Add(barButtonItem);
            _currLayoutInfo.GetFormAppearance().Menu.GetAllBarItems();
            _currLayoutInfo.GetFormAppearance().Menu.GetTopLevelBarItems();
        }

        public static DynamicObject[] GetQueryDatas(Context ctx, string formId, string filter)
        {
            FormMetadata formMetadata = MetaDataServiceHelper.Load(ctx, formId, true) as FormMetadata;
            QueryBuilderParemeter queryBuilderParemeter = new QueryBuilderParemeter();
            queryBuilderParemeter.FormId = formId;
            queryBuilderParemeter.FilterClauseWihtKey = filter;
            queryBuilderParemeter.BusinessInfo = formMetadata.BusinessInfo;
            QueryBuilderParemeter queryBuilderParemeter2 = queryBuilderParemeter;
            return BusinessDataServiceHelper.Load(ctx, formMetadata.BusinessInfo.GetDynamicObjectType(), queryBuilderParemeter2);
        }

        public override void BeforeUpdateValue(BeforeUpdateValueEventArgs e)
        {
            string text = ((e.Value != null) ? e.Value.ToString() : "");
            if (StringUtils.EqualsIgnoreCase(e.Key, "FObjectTypeId"))
            {
                FillFilterGridData(GetFieldData(e.Value));
            }

            if (StringUtils.EqualsIgnoreCase(e.Key, "FFilterGrid"))
            {
                AnalyzeFilterSetting(text);
                base.View.GetControl("FFilterGrid");
                _listFilterModel.FilterObject.Setting = text;
                _listFilterModel.FilterObject.GetFilterSQLString(base.Context, TimeServiceHelper.GetSystemDateTime(base.Context));
                _listFilterModel.FilterObject.GetFilterRows();
            }

            if (StringUtils.EqualsIgnoreCase(e.Key, "FEntitySelect"))
            {
                _dataRule.SelectEntitis = text;
            }

            base.BeforeUpdateValue(e);
        }

        public override void AfterCreateNewData(EventArgs e)
        {
            if (base.View.ParentFormView != null)
            {
                object customParameter = base.View.ParentFormView.OpenParameter.GetCustomParameter("FObjectTypeId");
                if (customParameter != null && !StringUtils.IsEmpty(customParameter.ToString()))
                {
                    base.View.Model.SetValue("FObjectTypeId", customParameter);
                }
            }

            base.AfterCreateNewData(e);
        }

        public override void AfterBindData(EventArgs e)
        {
            object pKValue = base.View.Model.GetPKValue();
            _dataRule = new DataRule
            {
                Id = ((pKValue == null) ? "" : pKValue.ToString()),
                DataRuleTable = base.View.Model.BusinessInfo.GetEntity(0).TableName
            };
            _dataRule = PermissionServiceHelper.GetDataRule(base.Context, _dataRule);
            if (FromXML && !StringUtils.IsEmpty(_dataRule.CustomFilterSetting))
            {
                base.View.Model.DataObject = DeserializeCustomFilter(_dataRule.CustomFilterSetting);
            }

            if (base.View.Model.DataObject["FObjectTypeId_Id"] != null)
            {
                FillFilterGridData(base.View.Model.DataObject["FObjectTypeId_Id"].ToString());
            }

            if (base.View.Model.GetValue("FObjectTypeId") == null || string.IsNullOrWhiteSpace(base.View.Model.GetValue("FObjectTypeId").ToString()))
            {
                base.View.GetControl("FFilterGrid").Enabled = false;
            }

            base.AfterBindData(e);
        }

        private void InitialFilterMetaData()
        {
            if (_filterMetaData == null)
            {
                _filterMetaData = CommonFilterServiceHelper.GetFilterMetaData(base.Context, "");
                JSONObject jSONObject = _filterMetaData.ToJSONObject();
                jSONObject.TryGetValue(CommonFilterConst.JSONKey_CompareTypes, out _compareTypes);
                jSONObject.TryGetValue(CommonFilterConst.JSONKey_Logics, out _logicData);
            }
        }

        private void InitialFilterGrid()
        {
            FilterGrid control = base.View.GetControl<FilterGrid>(CommonFilterConst.ControlKey_FilterGrid);
            control.SetCompareTypes(_compareTypes);
            control.SetLogicData(_logicData);
        }

        private void InitialFilterGrid(ListFilterModel listFilterModel)
        {
            FilterGrid control = base.View.GetControl<FilterGrid>(CommonFilterConst.ControlKey_FilterGrid);
            JSONArray filterFields = GetFilterFields(listFilterModel);
            control.SetFilterFields(filterFields);
            if (StringUtils.IsEmpty(_dataRule.SelectEntitis))
            {
                _dataRule.SelectEntitis = listFilterModel.EntityObject.Setting;
            }

            _listFilterModel.FilterObject.SetSelectEntity(_dataRule.SelectEntitis);
            control.SetSelectEntities(_dataRule.SelectEntitis);
            if (!StringUtils.IsEmpty(_dataRule.FilterSetting))
            {
                _listFilterModel.FilterObject.Setting = _dataRule.FilterSetting;
                control.SetFilterRows(_listFilterModel.FilterObject.GetFilterRows());
            }
        }

        protected virtual JSONArray GetFilterFields(ListFilterModel listFilterModel)
        {
            JSONArray jSONArray = new JSONArray();
            foreach (Entity entry in listFilterModel.BillBusinessInfo.Entrys)
            {
                if (entry is HeadEntity || entry is SubHeadEntity)
                {
                    jSONArray.AddRange(listFilterModel.FilterObject.GetFilterFieldListByEntityKey(entry.Key));
                }
            }

            return jSONArray;
        }

        private void FillFilterGridData(string formid)
        {
            if (!StringUtils.IsEmpty(formid))
            {
                _listFilterModel = CreateListFilterModel(formid);
                base.View.GetControl<FilterGrid>(CommonFilterConst.ControlKey_FilterGrid);
                InitialFilterGrid(_listFilterModel);
                InitialEntitySelect(_listFilterModel);
                base.View.GetControl("FFilterGrid").Enabled = true;
            }
        }

        protected string GetFieldData(object value)
        {
            if (value == null)
            {
                return "";
            }

            if (value is DynamicObject)
            {
                return ((DynamicObject)value)["Id"].ToString();
            }

            return value.ToString();
        }

        private ListFilterModel CreateListFilterModel(string formid)
        {
            ListFilterModel listFilterModel = new ListFilterModel();
            FormMetadata bizObjectMetaData = GetBizObjectMetaData(formid);
            listFilterModel.FilterObject.FilterMetaData = _filterMetaData;
            listFilterModel.SetContext(base.Context, bizObjectMetaData.BusinessInfo, bizObjectMetaData.BusinessInfo.GetForm().GetFormServiceProvider());
            listFilterModel.InitFieldList(bizObjectMetaData, null);
            return listFilterModel;
        }

        public override void BeforeFilterGridF7Select(BeforeFilterGridF7SelectEventArgs e)
        {
            base.BeforeFilterGridF7Select(e);
            e.CommonFilterModel = _listFilterModel;
        }

        private void InitialEntitySelect(ListFilterModel listFilterModel)
        {
            EntitySelect control = base.View.GetControl<EntitySelect>(CommonFilterConst.ControlKey_EntitySelect);
            JSONArray allEntities = listFilterModel.EntityObject.GetAllEntities();
            InitEntitisSetting(listFilterModel, control, allEntities);
            JSONArray jSONArray = new JSONArray();
            jSONArray.Add("FFilterGrid");
            control.SetListeners(jSONArray);
        }

        protected virtual void InitEntitisSetting(ListFilterModel listFilterModel, EntitySelect entityselect, JSONArray entities)
        {
            string headEntitiesKey = GetHeadEntitiesKey(listFilterModel);
            JSONArray jSONArray = new JSONArray();
            foreach (object entity in entities)
            {
                if (headEntitiesKey.Contains(((JSONObject)entity)["Key"].ToString()))
                {
                    jSONArray.Add(entity);
                }
            }

            entityselect.SetEntities(jSONArray);
            if (!StringUtils.IsEmpty(_dataRule.SelectEntitis))
            {
                listFilterModel.EntityObject.Setting = _dataRule.SelectEntitis;
            }

            entityselect.SetSelectEntities(listFilterModel.EntityObject.Setting);
        }

        private string GetHeadEntitiesKey(ListFilterModel listFilterModel)
        {
            string text = ",";
            foreach (Entity entry in listFilterModel.BillBusinessInfo.Entrys)
            {
                if (entry is HeadEntity || entry is SubHeadEntity)
                {
                    text = text + entry.Key.ToUpper() + ",";
                }
            }

            return text;
        }

        private void AnalyzeFilterSetting(string strFilterSetting)
        {
            isDataRuleSuccess = true;
            if (StringUtils.IsEmpty(strFilterSetting))
            {
                return;
            }

            _dataRule.FilterSetting = strFilterSetting;
            if (_listFilterModel == null || _listFilterModel.FilterObject.AllFilterFieldList == null)
            {
                return;
            }

            string selectEntitis = _dataRule.SelectEntitis;
            if (!StringUtils.IsEmpty(selectEntitis))
            {
                _listFilterModel.FilterObject.SetSelectEntity(selectEntitis);
            }

            _listFilterModel.FilterObject.Setting = strFilterSetting;
            try
            {
                string filterSQLString = _listFilterModel.FilterObject.GetFilterSQLString(base.Context, TimeServiceHelper.GetSystemDateTime(base.Context));
                _dataRule.FilterString = filterSQLString;
            }
            catch (Exception ex)
            {
                base.View.ShowErrMessage(ex.Message);
                isDataRuleSuccess = false;
            }
        }

        protected FormMetadata GetBizObjectMetaData(string strObjectTypeId)
        {
            if (dctObjectMetaData.ContainsKey(strObjectTypeId))
            {
                return dctObjectMetaData[strObjectTypeId];
            }

            FormMetadata cachedFormMetaData = FormMetaDataCache.GetCachedFormMetaData(base.Context, strObjectTypeId);
            dctObjectMetaData[strObjectTypeId] = cachedFormMetaData;
            return cachedFormMetaData;
        }

        public override void BeforeSave(BeforeSaveEventArgs e)
        {
            e.Cancel = !isDataRuleSuccess;
            base.BeforeSave(e);
        }

        public override void AfterSave(AfterSaveEventArgs e)
        {
            _dataRule.CustomFilterSetting = SerializeCustomFilter();
            _dataRule.Id = base.View.Model.GetPKValue().ToString();
            _dataRule.DataRuleTable = base.View.Model.BusinessInfo.GetEntity(0).TableName;
            PermissionInnerServiceHelper.SaveDataRule(base.Context, _dataRule);
            base.AfterSave(e);
        }

        private string GetString(object obj)
        {
            if (obj == null)
            {
                return "";
            }

            return obj.ToString();
        }

        private string SerializeCustomFilter()
        {
            base.View.GetControl("FFilterGrid");
            DcxmlBinder dcxmlBinder = new DynamicObjectDcxmlBinder(base.View.Model.BusinessInfo);
            dcxmlBinder.OnlyDbProperty = false;
            DcxmlSerializer dcxmlSerializer = new DcxmlSerializer(dcxmlBinder);
            CultureInfo culture = new CultureInfo(2052);
            dcxmlBinder.Culture = culture;
            string text = dcxmlSerializer.SerializeToString(base.View.Model.DataObject, null);
            if (!StringUtils.IsEmpty(text))
            {
                return text;
            }

            return "";
        }

        private DynamicObject DeserializeCustomFilter(string xml)
        {
            DcxmlBinder dcxmlBinder = new DynamicObjectDcxmlBinder(base.View.Model.BusinessInfo);
            dcxmlBinder.OnlyDbProperty = false;
            DcxmlSerializer dcxmlSerializer = new DcxmlSerializer(dcxmlBinder);
            CultureInfo culture = new CultureInfo(2052);
            dcxmlBinder.Culture = culture;
            DynamicObject dynamicObject = (DynamicObject)dcxmlSerializer.DeserializeFromString(xml);
            OrmUtils.DataEntityWalker(new DynamicObject[1] { dynamicObject }, dynamicObject.DynamicObjectType, delegate (DataEntityWalkerEventArgs e)
            {
                foreach (object dataEntity in e.DataEntities)
                {
                    ((DynamicObject)dataEntity).GetDataEntityType().SetFromDatabase(dataEntity);
                }
            });
            dynamicObject.GetDataEntityType().SetPkSnapshot(dynamicObject, base.View.Model.DataObject.GetDataEntityType().GetPkSnapshot(base.View.Model.DataObject));
            return dynamicObject;
        }
    }
}