package tqq9.lc123.cloud.app.plugin.form.sys;

import kd.bos.bill.AbstractBillPlugIn;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.dataentity.entity.LocaleString;
import kd.bos.dataentity.metadata.IDataEntityProperty;
import kd.bos.dataentity.metadata.dynamicobject.DynamicProperty;
import kd.bos.entity.datamodel.events.ChangeData;
import kd.bos.entity.datamodel.events.PropertyChangedArgs;
import kd.bos.entity.property.MulBasedataProp;
import kd.bos.form.control.events.BeforeItemClickEvent;
import kd.bos.form.control.events.ItemClickEvent;
import kd.bos.form.events.AfterDoOperationEventArgs;
import kd.bos.form.events.BeforeDoOperationEventArgs;
import kd.bos.form.operate.FormOperate;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.bos.servicehelper.MetadataServiceHelper;
import kd.bos.servicehelper.operation.SaveServiceHelper;
import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.util.*;


/**
 * 物料界面插件
 */
public class MaterialBillPlugin extends AbstractBillPlugIn {
    @Override
    public void itemClick(ItemClickEvent evt) {
        super.itemClick(evt);
        String itemKey = evt.getItemKey();
        if ("tqq9_xggxzd".equals(itemKey)) {
                DynamicObject material = this.getModel().getDataEntity(true);
                String status= material.getString("status");
                if("C".equals(status)){
                    material.set("tqq9_checkboxfield", true);
                    SaveServiceHelper.save(new DynamicObject[]{material});
                    this.getView().updateView();
                }else {
                    this.getView().showTipNotification("当前物料不是已审核状态，不允许修改个性字段！");
                }
            }

    }
    @Override
    public void beforeItemClick(BeforeItemClickEvent evt) {
        super.beforeItemClick(evt);
        String itemKey = evt.getItemKey();
        if ("tqq9_copyandchange".equals(itemKey)) {
            String number = (String) this.getModel().getValue("number");
            String tqq9_srcnumber = (String) this.getModel().getValue("tqq9_srcnumber");
            String status = (String) this.getModel().getValue("status");
            if (!"C".equals(status)) {
                evt.setCancel(true);
                this.getView().showTipNotification("当前物料不是已审核状态，不允许复制变更！");
            } else {
                QFilter f = new QFilter("tqq9_srcnumber", "=", number);
                DynamicObject[] materialArr = BusinessDataServiceHelper.load("bd_material", "id", new QFilter[]{f});
                if (materialArr != null && materialArr.length > 0) {
                    this.getView().showTipNotification("当前物料已经存在变更信息，不允许复制变更！");
                    evt.setCancel(true);
                } else {
                    if (org.apache.commons.lang3.StringUtils.isNotBlank(tqq9_srcnumber)) {
                        this.getView().showTipNotification("当前物料为其他物料的变更信息，不允许复制变更！");
                        evt.setCancel(true);
                    }
                }
            }
        }
    }


    @Override
    public void beforeDoOperation(BeforeDoOperationEventArgs args) {
        super.beforeDoOperation(args);
        FormOperate source = (FormOperate) args.getSource();
        String operateKey = source.getOperateKey();
        if ("submit".equals(operateKey)) {
            //复制后修改数据在提交时记录修改的内容，如果修改内容为空，则不记录
//            LinkedHashMap changeMap = new LinkedHashMap();
            DynamicObject dataEntity = this.getModel().getDataEntity(true);
            String tqq9_srcnumber = dataEntity.getString("tqq9_srcnumber");
            if (StringUtils.isNotBlank(tqq9_srcnumber)) {
                //查询原单
                QFilter qFilter = new QFilter("number", "=", tqq9_srcnumber);
                DynamicObject[] srcMaterialArr = BusinessDataServiceHelper.load("bd_material", "id", new QFilter[]{qFilter});
                if (srcMaterialArr != null && srcMaterialArr.length > 0) {
                    DynamicObject srcMaterial = srcMaterialArr[0];
                    srcMaterial = BusinessDataServiceHelper.loadSingle(srcMaterial.getPkValue(), "bd_material");
                    //获取实体中所有变更的属性
                    List<IDataEntityProperty> iDataEntityProperties = dataEntity.getDataEntityState().GetDirtyProperties();
                    if (iDataEntityProperties.size() > 0) {
                        DynamicObjectCollection changeEntries = dataEntity.getDynamicObjectCollection("tqq9_changeentry");
                        //获取变更内容分录，撤回后再次变更相同的字段，就取最新的变更内容
                        Map<String, DynamicObject> changEntryMap = new HashMap<>();
                        for (DynamicObject changeEntry : changeEntries) {
                            String tqq9_fieldnumber = changeEntry.getString("tqq9_fieldnumber");//字段标识
                            changEntryMap.put(tqq9_fieldnumber, changeEntry);
                        }
//                        changeEntries.clear();//清空变更明细，重新添加

                        for (IDataEntityProperty prop : iDataEntityProperties) {
                            String name = prop.getName();//字段标识
                            if ("number".equals(name) || "status".equals(name) || "useorg".equals(name) || "modifytime".equals(name)
                                    || "tqq9_changereason".equals(name) || "tqq9_changereason_tag".equals(name)
                                    || "simplepinyin".equals(name) || "approverid".equals(name) || "approvedate".equals(name)) {
                                continue;
                            }
                            LocaleString displayNameLocaleStr = prop.getDisplayName();
                            if (displayNameLocaleStr == null) {
                                continue;
                            }

                            //判断是否已经存在该字段对应的变更明细，如果没有就新建明细，如果有就用旧的明细
                            DynamicObject changeEntry;
                            DynamicObject oldChangeEntry = changEntryMap.get(name);
                            if(oldChangeEntry != null){
                                changeEntry = oldChangeEntry;
                            }else{
                                changeEntry = new DynamicObject(changeEntries.getDynamicObjectType());
                            }
                            String tqq9_oldvalue = changeEntry.getString("tqq9_oldvalue");//变更明细中的原值

                            String displayName = displayNameLocaleStr.get("zh_CN");//字段名称
                            String propTypeName = prop.getPropertyType().getName();
                            String oldValue = "";
                            String newValue = "";
                            String fieldtype = null;
//                            DynamicProperty property = MetadataServiceHelper.getDataEntityType("bd_material").getProperty(name);
                            if ("kd.bos.dataentity.entity.DynamicObject".equals(propTypeName)) {
                                String aClass = MetadataServiceHelper.getDataEntityType("bd_material").getProperty(name).getClass().getName();
                                if ("kd.bos.entity.property.MulBasedataProp".equals(aClass)) {
                                    //多选 基础资料
                                    fieldtype = "kd.bos.entity.property.MulBasedataProp";
                                    String selectFields = "name";
                                    String baseEntityId = ((MulBasedataProp) prop).getBaseEntityId();
                                    if ("bd_operator".equals(baseEntityId)) {
                                        selectFields = "operatorname";
                                    }
                                    DynamicObjectCollection dynamicObjectColl = dataEntity.getDynamicObjectCollection(name);
                                    DynamicObjectCollection dynamicObjectColl1 = srcMaterial.getDynamicObjectCollection(name);
                                    if (dynamicObjectColl != null && dynamicObjectColl.size() > 0) {
                                        for (DynamicObject dynamicObject : dynamicObjectColl) {
                                            long id = dynamicObject.getLong("fbasedataid_id");
                                            DynamicObject obj = BusinessDataServiceHelper.loadSingle(id, baseEntityId, selectFields);
                                            String objName = obj.getString(selectFields);
                                            newValue = newValue + "," + objName;
                                        }
                                        if(newValue.startsWith(",")){
                                            newValue = newValue.substring(1);
                                        }

                                        if (dynamicObjectColl1 != null && dynamicObjectColl1.size() > 0) {
                                            for (DynamicObject dynamicObject1 : dynamicObjectColl1) {
                                                long id = dynamicObject1.getLong("fbasedataid_id");
                                                DynamicObject obj = BusinessDataServiceHelper.loadSingle(id, baseEntityId, selectFields);
                                                String objName = obj.getString(selectFields);
                                                oldValue = oldValue + "," + objName;
                                            }
                                            if(oldValue.startsWith(",")){
                                                oldValue = oldValue.substring(1);
                                            }
                                            if (oldValue.equals(newValue)) {
                                                if(oldChangeEntry != null){
                                                    //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                    changeEntries.remove(oldChangeEntry);
                                                }
                                                continue;
                                            }
                                        } else {
                                            if(newValue.startsWith(",")){
                                                newValue = newValue.substring(1);
                                            }
                                        }
                                    } else {
                                        if(StringUtils.isBlank(tqq9_oldvalue)){
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            continue;
                                        }
                                        if (dynamicObjectColl1 != null && dynamicObjectColl1.size() > 0) {
                                            oldValue = "";
                                            for (DynamicObject dynamicObject1 : dynamicObjectColl1) {
                                                long id = dynamicObject1.getLong("fbasedataid_id");
                                                DynamicObject obj = BusinessDataServiceHelper.loadSingle(id, baseEntityId, "id,name,number");
                                                String objName = null;
                                                if("baseEntityId".equals(baseEntityId)){
                                                    objName = obj.getString("operatorname");
                                                }else{
                                                    objName = obj.getString("name");
                                                }
                                                oldValue = oldValue + "," + objName;
                                            }
                                            if(oldValue.startsWith(",")){
                                                oldValue = oldValue.substring(1);
                                            }
                                        }else{
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            continue;
                                        }
                                    }
                                } else {
                                    //基础资料 单选
                                    fieldtype = "kd.bos.dataentity.entity.DynamicObject";
                                    DynamicObject dynamicObject = dataEntity.getDynamicObject(name);//新值
                                    DynamicObject dynamicObject1 = srcMaterial.getDynamicObject(name);//原值
                                    if (dynamicObject != null) {
                                        newValue = dynamicObject.getString("name");
                                        if (dynamicObject1 != null) {
                                            oldValue = dynamicObject1.getString("name");
                                        }
                                    } else {
                                        if(StringUtils.isBlank(tqq9_oldvalue)){
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            //如果原值为空，且变更后的值为空，也不需要添加到变更明细
                                            continue;
                                        }
                                        if (dynamicObject1 != null) {
                                            oldValue = dynamicObject1.getString("name");
                                        }else {
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            continue;
                                        }
                                    }
                                }
                            } else if ("java.util.Date".equals(propTypeName)) {
                                fieldtype = "java.util.Date";
                                Date newValueDate = dataEntity.getDate(name);
                                Date oldValueDate = srcMaterial.getDate(name);
                                if (newValueDate != null) {
                                    newValue = newValueDate.toString();
                                    if (oldValueDate != null) {
                                        oldValue = oldValueDate.toString();
                                        if (oldValue.equals(newValue)) {
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            continue;
                                        }
                                    }
                                } else {
                                    if(StringUtils.isBlank(tqq9_oldvalue)){
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        //如果原值为空，且变更后的值为空，也不需要添加到变更明细
                                        continue;
                                    }
                                    if (oldValueDate != null) {
                                        oldValue = oldValueDate.toString();
                                    }else {
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        continue;
                                    }
                                }
                            } else if ("java.lang.Integer".equals(propTypeName)) {
                                fieldtype = "java.lang.Integer";
                                int newInt = dataEntity.getInt(name);
                                int oldInt = srcMaterial.getInt(name);
                                if (newInt == oldInt) {
                                    if(oldChangeEntry != null){
                                        //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                        changeEntries.remove(oldChangeEntry);
                                    }
                                    continue;
                                }
                                newValue = String.valueOf(newInt);
                                oldValue = String.valueOf(oldInt);
                            } else if ("java.lang.Long".equals(propTypeName)) {
                                fieldtype = "java.lang.Long";
                                long newLong = dataEntity.getLong(name);
                                long oldLong = srcMaterial.getLong(name);
                                if (newValue == oldValue) {
                                    if(oldChangeEntry != null){
                                        //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                        changeEntries.remove(oldChangeEntry);
                                    }
                                    continue;
                                }
                                newValue = String.valueOf(newLong);
                                oldValue = String.valueOf(oldLong);
                            } else if ("java.math.BigDecimal".equals(propTypeName)) {
                                fieldtype = "java.math.BigDecimal";
                                BigDecimal newValueDec = dataEntity.getBigDecimal(name);
                                BigDecimal oldValueDec = srcMaterial.getBigDecimal(name);
                                if (newValueDec != null) {
                                    newValue = newValueDec.toString();
                                    if (oldValueDec != null) {
                                        oldValue = oldValueDec.toString();
                                    }else {
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        continue;
                                    }
                                } else {
                                    if(StringUtils.isBlank(tqq9_oldvalue)){
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        //如果原值为空，且变更后的值为空，也不需要添加到变更明细
                                        continue;
                                    }
                                    if (oldValueDec != null) {
                                        oldValue = oldValueDec.toString();
                                    }else{
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        continue;
                                    }
                                }
                            } else if ("boolean".equals(propTypeName)) {
                                fieldtype = "boolean";
                                boolean newValueBol = dataEntity.getBoolean(name);
                                boolean oldValueBol = srcMaterial.getBoolean(name);
                                if (newValueBol == oldValueBol) {
                                    if(oldChangeEntry != null){
                                        //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                        changeEntries.remove(oldChangeEntry);
                                    }
                                    continue;
                                }
                                newValue = String.valueOf(newValueBol);
                                oldValue = String.valueOf(oldValueBol);
                            } else {
                                fieldtype = "java.lang.String";
                                newValue = dataEntity.getString(name);
                                oldValue = srcMaterial.getString(name);
                                if (StringUtils.isNotBlank(newValue)) {
                                    if ("name".equals(name)) {
                                        newValue = newValue.replaceAll("_copy", "");
                                    }
                                    if(newValue.startsWith(",")){
                                        newValue = newValue.substring(1);
                                    }
                                    if (StringUtils.isNotBlank(oldValue)) {
                                        if(oldValue.startsWith(",")){
                                            oldValue = oldValue.substring(1);
                                        }
                                        if (oldValue.equals(newValue)) {
                                            if(oldChangeEntry != null){
                                                //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                                changeEntries.remove(oldChangeEntry);
                                            }
                                            continue;
                                        }
                                    }
                                } else {
                                    if(StringUtils.isBlank(tqq9_oldvalue)){
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        //如果原值为空，且变更后的值为空，也不需要添加到变更明细
                                        continue;
                                    }
                                    if (StringUtils.isBlank(oldValue)) {
                                        if(oldChangeEntry != null){
                                            //如果变更明细中已经存在这个字段的变更信息，则删除这行明细
                                            changeEntries.remove(oldChangeEntry);
                                        }
                                        continue;
                                    }
                                    if(oldValue.startsWith(",")){
                                        oldValue = oldValue.substring(1);
                                    }
                                }
                            }
                            changeEntry.set("tqq9_fieldname", displayName);//字段名称
                            changeEntry.set("tqq9_fieldnumber", name);//字段标识
                            changeEntry.set("tqq9_oldvalue", oldValue);//修改前值
                            changeEntry.set("tqq9_newvalue", newValue);//修改后值
                            changeEntry.set("tqq9_updatedate", new Date());//修改时间
                            changeEntry.set("tqq9_fieldtype", fieldtype);//字段类型
                            changeEntries.add(changeEntry);
//                            changeMap.put(name, displayName);
                        }
                    }
                }
            }
        }
        if ("copyandchange".equals(operateKey)) {
            super.beforeDoOperation(args);
            this.getPageCache().put("copyMatId", this.getModel().getValue("id").toString());
            FormOperate operate = (FormOperate) args.getSource();
            String operateNo = operate.getOperateKey();
            if (operateNo.equalsIgnoreCase("copyandchange")) {
                DynamicObject bill = this.getModel().getDataEntity();
                this.getView().getFormShowParameter().setCustomParam("copySrcBillName", bill.getString("name"));
                this.getView().getFormShowParameter().setCustomParam("copySrcBillNumber", bill.getString("number"));
//                this.getView().getFormShowParameter().setCustomParam("tqq9_fwrequestid", bill.getString("tqq9_fwrequestid"));
                this.getView().getFormShowParameter().setCustomParam("operateKey", "copyandchange");
            }
        }
    }

    @Override
    public void afterCopyData(EventObject e) {
        super.afterCopyData(e);
        String operateKey = this.getView().getFormShowParameter().getCustomParam("operateKey");
        if ("copyandchange".equals(operateKey)) {
            String copySrcBillName = this.getView().getFormShowParameter().getCustomParam("copySrcBillName");
            String copySrcBillNumber = this.getView().getFormShowParameter().getCustomParam("copySrcBillNumber");
//            String tqq9_fwrequestid = this.getView().getFormShowParameter().getCustomParam("tqq9_fwrequestid");
            DynamicObject dataEntity = this.getModel().getDataEntity(true);
            dataEntity.set("number", copySrcBillNumber + "_copy");
            dataEntity.set("name", copySrcBillName + "_copy");
            dataEntity.set("tqq9_srcnumber", copySrcBillNumber);
            dataEntity.set("tqq9_isfirst", false);
//            dataEntity.set("tqq9_fwrequestid", tqq9_fwrequestid);
//            dataEntity.set("tqq9_issuccess", true);
            this.getView().invokeOperation("save");
        }
    }

    public void afterDoOperation(AfterDoOperationEventArgs evt) {
        super.afterDoOperation(evt);
        String operateKey = evt.getOperateKey();
        if (StringUtils.equals("submit", operateKey)) {
            getModel().setValue("tqq9_isfirst", false);
            SaveServiceHelper.save(new DynamicObject[]{this.getModel().getDataEntity()});
        }
    }

    @Override
    public void propertyChanged(PropertyChangedArgs e) {
        super.propertyChanged(e);
        String name = e.getProperty().getName();
        if ("tqq9_brand".equals(name)) {
            ChangeData changeData = e.getChangeSet()[0];
            Object newValue = changeData.getNewValue();
            if (newValue != null) {
                DynamicObject newValue1 = (DynamicObject) newValue;
                DynamicObject tqq9_brand = BusinessDataServiceHelper.loadSingle("tqq9_brand", new QFilter[]{new QFilter("id", QCP.in, newValue1.getLong("id"))});
                DynamicObjectCollection tqq9_shcg = tqq9_brand.getDynamicObjectCollection("tqq9_shcg");
                DynamicObjectCollection tqq9_bjcg = tqq9_brand.getDynamicObjectCollection("tqq9_bjcg");
                DynamicObjectCollection tqq9_gzcg = tqq9_brand.getDynamicObjectCollection("tqq9_gzcg");
                getModel().setValue("tqq9_shcg", tqq9_shcg);
                getModel().setValue("tqq9_bjcg", tqq9_bjcg);
                getModel().setValue("tqq9_gzcg", tqq9_gzcg);
            }

        }
    }
}