<template>
  <div class="container_wrap full" v-loading="fullscreenLoading">
    <div class="content_main">
      <ContentWrap id="id-baseInfo" title="逻辑空间信息" description="" :isExpand="baseInfoExpand" :expand-swicth="true"
        class="mb16" @expand="(v) => baseInfoExpand = v">
        <Form ref="baseInfoFormRef" :itemList="baseInfoFormItems" formId="base-info-form" :rules="baseInfoFormRules"
          col="col3" />
        <el-tabs v-model="activeTabName" class="param-tabs">
          <el-tab-pane label="成员权限" name="member">
            <Table ref="memberTableRef" :tableInfo="memberTableInfo" class="fiveRow-table" />
            <div class="row-add-btn">
              <el-button link @click="addMember" :icon="CirclePlus" v-preReClick>添加</el-button>
            </div>
          </el-tab-pane>
          <el-tab-pane label="策略配置" name="strategy">
            <StrategyTable ref="strategyTableRef" :value="detailInfo.policyRSVOS || []"
              :operatorOptionList="operatorOptionList" :actionOptionsList="actionOptionsList"
              :constraintOptionsList="constraintOptionsList"></StrategyTable>
          </el-tab-pane>
        </el-tabs>
      </ContentWrap>
      <!-- 可信空间需要显示 -->
      <!-- <ContentWrap id="id-approveInfo" title="流程审批" expandSwicth style="margin-top: 15px" :isExpand="expandApprove"
        @expand="(v) => expandApprove = v">
        <ApprovalProcess ref="approvalProcessRef" v-if="deploymentId" :deploymentId="deploymentId"
          :processInstanceId="processInstanceId">
        </ApprovalProcess>
      </ContentWrap> -->
    </div>
    <div class="bottom_tool_wrap">
      <el-button @click="cancel">取消</el-button>
      <el-button v-show="detailInfo.bizApproveState !== 'Y' && detailInfo.bizApproveState !== 'C' && detailInfo.bizApproveState !== 'R'" @click="save" v-preReClick>保存草稿</el-button>
      <el-button type="primary" @click="submit" v-preReClick>提交</el-button>
    </div>
  </div>
</template>

<script lang="ts" setup name="productSpaceEdit">
import { CirclePlus } from "@element-plus/icons-vue";
import { getCamundaDeploymentId } from "@/api/modules/workFlowService";
import {
  getParamsList
} from "@/api/modules/queryService";
import {
  getActionPolicyList,
  getConstraintPolicyList,
  getContractTenantListExcludeSelf
} from "@/api/modules/dataSmartContract"
import useUserStore from "@/store/modules/user";
import useDataProductSpaceStore from "@/store/modules/productSpace";
import { useValidator } from '@/hooks/useValidator';
import { TableColumnWidth } from "@/utils/enum";
import { scrollLastRowToView } from "@/utils/common";
import StrategyTable from "../data_smart_contract/components/strategyTable.vue";
import { getLogicSpaceDetail, saveLogicSpace, updateLogicSpace, updateLogicSpaceMember } from "@/api/modules/dataAsset";

const { required } = useValidator();

const { proxy } = getCurrentInstance() as any;

const userStore = useUserStore();
const productSpaceStore = useDataProductSpaceStore();
const route = useRoute();
const router = useRouter();
const userData = JSON.parse(localStorage.userData);
const fullPath = route.fullPath;

const detailInfo: any = ref({});

const fullscreenLoading = ref(false);
const baseInfoExpand = ref(true);
const expandApprove = ref(true);

/** 约束运算符字典下拉 */
const operatorOptionList: any = ref([]);

/** 约束行为下拉列表 */
const constraintOptionsList: any = ref([]);

/** 策略操作行为下拉列表 */
const actionOptionsList: any = ref([]);

/** 页签当前活跃的有成员权限和策略配置 */
const activeTabName = ref('member');

const deploymentId = ref('');
const processInstanceId = ref('');

/** 策略表格组件引用 */
const strategyTableRef = ref();

const baseInfoFormRef = ref();

const domainDictList: any = ref([]);

const baseInfoFormItems = ref([
  {
    label: '逻辑空间名称',
    type: 'input',
    placeholder: '请输入',
    field: 'spaceName',
    maxlength: 50,
    default: '',
    clearable: true,
    required: true
  },
  {
    label: '所属领域',
    type: 'select',
    placeholder: '请选择',
    field: 'domain',
    default: '003',
    options: domainDictList.value,
    props: {
      value: 'value',
      label: 'label',
      children: 'children'
    },
    required: true,
    filterable: true,
    clearable: true,
    visible: true
  },
  {
    label: '创建企业',
    type: 'input',
    placeholder: '请输入',
    field: 'tenantName',
    default: userData.tenantName,
    required: true,
    disabled: true
  },
  {
    label: '是否开启',
    type: 'switch',
    field: 'isActivate',
    default: 'Y',
    placeholder: '请选择',
    activeValue: 'Y',
    inactiveValue: 'N',
    required: true,
    switchWidth: 32,
  },
  {
    label: '逻辑空间描述',
    type: 'textarea',
    placeholder: '该逻辑空间主要为医疗机构的数据产品，限制了数据产品以及只有进行查看操作。参与方为某某医药企业、某某医疗机构以及运营方。',
    field: 'spaceDescription',
    default: '',
    block: true,
    maxlength: 500,
    clearable: true,
    required: true,
  },
])

const baseInfoFormRules = ref({
  spaceName: [required('请输入逻辑空间名称')],
  domain: [required('请选择所属领域')],
  spaceDescription: [required('请输入逻辑空间描述')]
})

const cancel = () => {
  proxy.$openMessageBox("当前页面尚未保存，确定放弃修改吗？", () => {
    userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
    router.push({
      name: 'productSpaceManage'
    });
  }, () => {
    proxy.$ElMessage.info("已取消");
  });
}

const memberTenantList: any = ref([]);

const roleTypeList: any = ref([{
  value: '1',
  label: '数据使用方'
}, {
  value: '2',
  label: '数据提供方'
}]);

/** 对表格组件的引用 */
const memberTableRef = ref();

/** 成员权限表格 */
const memberTableData: any = ref([]);

/** 成员权限表格 */
const memberTableInfo = ref({
  id: "input-params-table",
  height: '214px',
  fields: [
    { label: "序号", type: "index", width: TableColumnWidth.INDEX, align: "center" },
    { label: "成员名称", field: "memberGuid", width: 200, required: true, columClass: 'edit-colum', type: 'edit' },
    { label: "角色类型", field: "characterType", width: 160, required: true, columClass: 'edit-colum', type: 'edit' },
    { label: "描述", field: "description", width: 300, required: false, columClass: 'edit-colum', type: 'edit' },
  ],
  editInfo: {
    memberGuid: {
      label: '',
      type: 'select',
      field: 'memberGuid',
      default: '',
      options: memberTenantList.value,
      props: {
        label: 'tenantName',
        value: 'guid'
      },
      placeholder: '请选择',
      clearable: true,
      filterable: true
    },
    characterType: {
      label: '',
      type: 'select',
      field: 'characterType',
      default: '',
      options: roleTypeList.value,
      props: {
        label: 'label',
        value: 'value'
      },
      placeholder: '请选择',
      clearable: true,
      filterable: true
    },
    description: {
      label: '',
      type: 'input',
      field: 'description',
      default: '',
      maxlength: 200,
      placeholder: '请输入',
      clearable: true,
    }
  },
  STATUS: 'edit',
  data: memberTableData.value,
  showPage: false,
  actionInfo: {
    show: true,
    label: "操作",
    type: "btn",
    width: 60,
    fixed: 'right',
    btns: [
      {
        label: "删除", value: "remove", click: (scope) => {
          let index = scope.$index;
          proxy.$openMessageBox("此操作将永久删除, 是否继续?", () => {
            memberTableData.value.splice(index, 1);
            memberTableInfo.value.data = memberTableData.value;
            proxy.$ElMessage.success('参数删除成功');
          }, () => {
            proxy.$ElMessage.info("已取消");
          });
        }
      },
    ]
  },
  loading: false
});

/** 给表格添加一行入参定义。 */
const addMember = () => {
  memberTableData.value.push({ memberGuid: '', roleType: '', description: '' });
  memberTableInfo.value.data = memberTableData.value;
  nextTick(() => {
    scrollLastRowToView(memberTableRef.value?.tableRef, memberTableData.value.length);
  })
}

// 检查数据是否被修改
const checkIfModified = (formInline: any, policyRQVOS: any[]) => {
  // 检查formInline中的字段
  for (let key in formInline) {
    if (formInline[key] !== detailInfo.value[key]) {
      return true;
    }
  }

  // 检查policyRQVOS
  const originalPolicies = detailInfo.value?.policyRSVOS || [];
  if (policyRQVOS.length !== originalPolicies.length) {
    return true;
  }

  for (let i = 0; i < policyRQVOS.length; i++) {
    const current = policyRQVOS[i];
    const original = originalPolicies[i];
    if (!original) {
      return true;
    }

    // 比较策略数据的每个字段
    for (let key in current) {
      if (key !== 'childIndex' && key !== 'index' && key !== 'orderNum' && current[key] !== original[key]) {
        return true;
      }
    }
  }

  // // 检查成员权限数据
  // const currentMembers = memberTableInfo.value.data || [];
  // const originalMembers = detailInfo.value?.permissionRSVOS || [];
  // if (currentMembers.length !== originalMembers.length) {
  //   return true;
  // }

  // for (let i = 0; i < currentMembers.length; i++) {
  //   const current = currentMembers[i];
  //   const original = originalMembers[i];
  //   if (!original) {
  //     return true;
  //   }

  //   // 比较成员数据的每个字段
  //   for (let key in current) {
  //     if (current[key] !== original[key]) {
  //       return true;
  //     }
  //   }
  // }

  return false;
};

const save = () => {
  // 保存不检验。
  let formInline = baseInfoFormRef.value.formInline;
  let params = { ...formInline };
  if (!params.spaceName) {
    proxy.$ElMessage.error('逻辑空间名称不能为空');
    return;
  }
  params.permissionRQVOS = memberTableInfo.value.data || [];
  params.policyRQVOS = strategyTableRef.value.strategyData?.map((d, index) => {
    return Object.assign({}, d, { orderNum: index + 1 })
  });
  params.tenantGuid = userData.tenantGuid;
  fullscreenLoading.value = true;
  if (route.query.guid) {
    params.guid = route.query.guid;
    updateLogicSpace(params).then((res: any) => {
      fullscreenLoading.value = false;
      if (res?.code == proxy.$passCode) {
        proxy.$ElMessage.success('编辑保存成功');
        userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
        router.push({
          name: 'productSpaceManage'
        });
        productSpaceStore.setIsRefresh(true);
      } else {
        res?.msg && proxy.$ElMessage.error(res.msg);
      }
    })
  } else {
    saveLogicSpace(params).then((res: any) => {
      fullscreenLoading.value = false;
      if (res?.code == proxy.$passCode) {
        proxy.$ElMessage.success('保存成功');
        userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
        router.push({
          name: 'productSpaceManage'
        });
        productSpaceStore.setIsRefresh(true);
      } else {
        res?.msg && proxy.$ElMessage.error(res.msg);
      }
    })
  }
}

const submit = () => {
  baseInfoFormRef.value?.ruleFormRef?.validate().then((valid, errorItem) => {
    if (valid) {
      let formInline = baseInfoFormRef.value.formInline;
      // for循环判断相同成员不能重复添加相同的角色类型，且每行数据的成员guid和角色类型不能出现为空的，若为空则提示。
      for (let data of memberTableData.value) {
        if (!data.memberGuid || !data.characterType) {
          proxy.$ElMessage.error('成员名称和角色类型请填写完整');
          activeTabName.value = 'member';
          return;
        }
        let isExist = memberTableData.value.find((item: any) => data !== item && item.memberGuid == data.memberGuid && item.characterType == data.characterType);
        if (isExist) {
          proxy.$ElMessage.error('相同成员不能重复添加相同的角色类型');
          activeTabName.value = 'member';
          return;
        }
      }
      let validate = strategyTableRef.value?.validateValue();
      if (!validate) {
        activeTabName.value = 'strategy';
        return;
      }
      let params = { ...formInline };
      params.permissionRQVOS = memberTableInfo.value.data || [];
      params.policyRQVOS = strategyTableRef.value.strategyData?.map((d, index) => {
        return Object.assign({}, d, { orderNum: index + 1 })
      });
      params.immediateApprove = true;
      params.tenantGuid = userData.tenantGuid;
      fullscreenLoading.value = true;
      if (route.query.guid) {
        params.guid = route.query.guid;
        /** 需要判断是审批通过之后的编辑，若是只改成员信息，则不需要提交审批，只需要调用编辑即可。 */
        if (detailInfo.value.bizApproveState != 'Y' || checkIfModified(formInline, params.policyRQVOS)) {
          updateLogicSpace(params).then((res: any) => {
            fullscreenLoading.value = false;
            if (res?.code == proxy.$passCode) {
              proxy.$ElMessage.success('编辑提交审批成功');
              userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
              router.push({
                name: 'productSpaceManage'
              });
              productSpaceStore.setIsRefresh(true);
            } else {
              res?.msg && proxy.$ElMessage.error(res.msg);
            }
          })
        } else {
          // 未修改过基础信息，只修改成员，或者任何修改都没有时，直接调用提交成员
          updateLogicSpaceMember(params).then((res: any) => {
            fullscreenLoading.value = false;
            if (res?.code == proxy.$passCode) {
              proxy.$ElMessage.success('编辑提交成功');
              userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
              router.push({
                name: 'productSpaceManage'
              });
              productSpaceStore.setIsRefresh(true);
            } else {
              res?.msg && proxy.$ElMessage.error(res.msg);
            }
          }).catch(() => {
            fullscreenLoading.value = false;
          });
        }
      } else {
        saveLogicSpace(params).then((res: any) => {
          fullscreenLoading.value = false;
          if (res?.code == proxy.$passCode) {
            proxy.$ElMessage.success('提交审批成功');
            userStore.setTabbar(userStore.tabbar.filter((tab: any) => tab.fullPath !== fullPath));
            router.push({
              name: 'productSpaceManage'
            });
            productSpaceStore.setIsRefresh(true);
          } else {
            res?.msg && proxy.$ElMessage.error(res.msg);
          }
        })
      }
    } else {
      var obj = Object.keys(errorItem);
      baseInfoFormRef.value.ruleFormRef.scrollToField(obj[0]);
    }
  })
}

onActivated(() => {
  let tab: any = userStore.tabbar.find((tab: any) => tab.fullPath == fullPath);
  let name = route.query.name;
  if (tab) {
    tab.meta.title = route.query.guid ? `编辑-${name}` : '新增逻辑空间';
  }
  document.title = tab.meta.title;
})

onBeforeMount(() => {
  // 可信空间需要
  // getCamundaDeploymentId('10034', userData.tenantGuid, userData.staffGuid).then((res: any) => {
  //   if (res.code == proxy.$passCode) {
  //     deploymentId.value = res.data;
  //   } else {
  //     proxy.$ElMessage.error(res.msg);
  //   }
  // })
  if (route.query.guid) {
    fullscreenLoading.value = true;
    getLogicSpaceDetail({ guid: route.query.guid }).then((res: any) => {
      fullscreenLoading.value = false;
      if (res?.code == proxy.$passCode) {
        detailInfo.value = res.data || {};
        baseInfoFormItems.value.forEach((item: any) => {
          item.default = detailInfo.value[item.field] || '';
        })
        memberTableData.value = detailInfo.value?.permissionRSVOS || [];
        memberTableInfo.value.data = memberTableData.value;
        strategyTableRef.value.strategyData = detailInfo.value?.policyRSVOS || [];
      } else {
        res?.msg && proxy.$ElMessage.error(res?.msg);
      }
    })
  }

  getParamsList({ dictType: '领域' }).then((res: any) => {
    if (res?.code == proxy.$passCode) {
      domainDictList.value = res.data || [];
      let itemIndex = baseInfoFormItems.value.findIndex(item => item.field == 'domain');
      let item = baseInfoFormItems.value[itemIndex];
      item && (item.options = domainDictList.value);
    } else {
      res?.msg && proxy.$ElMessage.error(res?.msg);
    }
  });

  getParamsList({ dictType: '约束运算符' }).then((res: any) => {
    if (res?.code == proxy.$passCode) {
      const data = res.data || [];
      operatorOptionList.value = data;
    } else {
      res?.msg && proxy.$ElMessage.error(res?.msg);
    }
  })
  getActionPolicyList().then((res: any) => {
    if (res?.code == proxy.$passCode) {
      const data = res.data || [];
      actionOptionsList.value = data;
    } else {
      res?.msg && proxy.$ElMessage.error(res?.msg);
    }
  })
  getConstraintPolicyList().then((res: any) => {
    if (res?.code == proxy.$passCode) {
      const data = res.data || [];
      constraintOptionsList.value = data;
    } else {
      res?.msg && proxy.$ElMessage.error(res?.msg);
    }
  })
  /** 获取可选择的成员下拉列表 */
  getContractTenantListExcludeSelf().then((res: any) => {
    if (res?.code == proxy.$passCode) {
      memberTenantList.value = res.data || [];
      memberTableInfo.value.editInfo.memberGuid.options = memberTenantList.value;
    } else {
      res?.msg && proxy.$ElMessage.error(res.msg);
    }
  })
})

</script>

<style lang="scss" scoped>
.content_main {
  height: calc(100% - 40px);
  padding: 16px;
  overflow: hidden auto;
  position: sticky;
}

.bottom_tool_wrap {
  height: 40px;
  padding: 0 16px;
  border-top: 1px solid #d9d9d9;
  display: flex;
  justify-content: center;
  align-items: center;
}

.row-add-btn {
  .el-button--default {
    padding: 4px 0px;
    margin-top: 4px;
  }

  :deep(.el-icon) {
    width: 16px;
    height: 16px;

    svg {
      width: 16px;
      height: 16px;
    }
  }
}

:deep(.el-tabs) {
  margin-top: 0px;

  .el-tabs__header {
    margin-bottom: 8px;
  }

  .el-tabs__item {
    height: 32px;

    &:nth-child(2) {
      padding-left: 16px;
    }

  }
}
</style>