import {
  __record__,
  getDataSourceListWithAllPath,
  handleOriginList,
  isArrayNotEmpty,
  isRecursionComponent,
} from '../util/util';
import React from 'react';
import {
  __arrayTableCurrentRow__,
  __dataSource__,
  __extraParam__,
  __flowData__,
  __tableCurrentRow__,
  currentFormCardLabel,
  currentPageLabel,
  formDialogStateLabel,
  getFormExprNameByPosition,
  leftTreeAfterDropDataSourceLabel,
  leftTreeStateLabel,
  openDialogModeLabel,
  pageSizeLabel,
} from '@/common/util/expr-const';
import ExprSetter from '@/common/setter/expr-setter';
import { getItem } from '@/common/manager/button';
import {
  getFormStateSetterSnippet,
  getJSXTemplate,
} from '@/common/manager/setter-snippet';
import { DisplayPosition } from '@/type/display-position';
import { ButtonPosition } from '@/type/button-position';
import { ParamSelectSetter } from '@/common/setter/param-select-setter';
import { allowQuickComponentList } from '@/common/util/const';
import DocSetter from '@/common/setter/doc-setter';

const type = {
  name: 'type',
  title: '按钮样式',
  // supportVariable: true,
  display: 'inline',
  initialValue: 'normal',
  position: [
    ButtonPosition.dialog,
    ButtonPosition.formDialog,
    ButtonPosition.form,
    ButtonPosition.tableOperate,
    ButtonPosition.tableBatchArea,
    ButtonPosition.tableToolArea,
    ButtonPosition.cardAction,
  ],
  setter: {
    componentName: 'SelectSetter',
    props: {
      options: [
        {
          title: '普通按钮',
          value: 'normal',
        },
        {
          title: '主按钮',
          value: 'primary',
        },
        {
          title: '次按钮',
          value: 'secondary',
        },
      ],
    },
  },
};
const tableOperateHidden = {
  name: 'hidden',
  title: '隐藏',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'columns'}
          //   labelKey={'title'}
          //   valueKey={'dataIndex'}
          //   groupName={'当前行数据'}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  dataKey: 'columns',
                  labelKey: 'title',
                  valueKey: 'dataIndex',
                  groupName: '当前行数据',
                  groupExprName: __tableCurrentRow__,
                  needSecondParam: false,
                },
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'table' }),
      ],
    },
  },
  position: [ButtonPosition.tableOperate],
};
const tableOperateDisabled = {
  name: 'disabled',
  title: '禁用',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'columns'}
          //   labelKey={'title'}
          //   valueKey={'dataIndex'}
          //   groupName={'当前行数据'}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  dataKey: 'columns',
                  labelKey: 'title',
                  valueKey: 'dataIndex',
                  groupName: '当前行数据',
                  groupExprName: __tableCurrentRow__,
                  needSecondParam: false,
                },
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'table' }),
      ],
    },
  },
  position: [ButtonPosition.tableOperate],
};

const arrayTableOperateHidden = (position) => {
  return {
    name: 'hidden',
    title: '隐藏',
    display: 'inline',
    // supportVariable: true,
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            componentName: 'BoolSetter',
            title: '布尔（true/false）',
          },
          {
            componentName: (
              <ExprSetter
                configList={[
                  {
                    dataKey: 'arrayTable',
                    labelKey: 'label',
                    valueKey: 'name',
                    groupName: '表格当前行数据',
                    groupExprName: __arrayTableCurrentRow__,
                    needSecondParam: false,
                  },
                  {
                    dataKey: 'config',
                    labelKey: 'label',
                    valueKey: 'name',
                    groupName: '表单字段',
                    groupExprName: getFormExprNameByPosition({ position }),
                    needSecondParam: false,
                  },
                  {
                    groupName: '其他数据',
                    groupExprName: __dataSource__,
                    needSecondParam: true,
                  },
                ]}
              />
            ),
            title: '简单表达式',
          },
          getJSExpressionPrototype({ type: 'arrayTableOperate' }),
        ],
      },
    },
    position: [ButtonPosition.arrayTableOperate],
  };
};
const arrayTableOperateDisabled = (position) => {
  return {
    name: 'disabled',
    title: '禁用',
    display: 'inline',
    // supportVariable: true,
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            componentName: 'BoolSetter',
            title: '布尔（true/false）',
          },
          {
            componentName: (
              <ExprSetter
                configList={[
                  {
                    dataKey: 'arrayTable',
                    labelKey: 'label',
                    valueKey: 'name',
                    groupName: '表格当前行数据',
                    groupExprName: __arrayTableCurrentRow__,
                    needSecondParam: false,
                  },
                  {
                    dataKey: 'config',
                    labelKey: 'label',
                    valueKey: 'name',
                    groupName: '表单字段',
                    groupExprName: getFormExprNameByPosition({ position }),
                    needSecondParam: false,
                  },
                  {
                    groupName: '其他数据',
                    groupExprName: __dataSource__,
                    needSecondParam: true,
                  },
                ]}
              />
            ),
            title: '简单表达式',
          },
          getJSExpressionPrototype({ type: 'arrayTableOperate' }),
        ],
      },
    },
    position: [ButtonPosition.arrayTableOperate],
  };
};

// const span = {
//   name: 'span',
//   display: 'inline',
//   title: '网格数',
//   // setter: <NumberSetter min={1} max={2} />,
//   position: [DisplayPosition.filter],
//   setter: {
//     componentName: 'RadioGroupSetter',
//     props: {
//       options: [
//         {
//           title: '1格（窄）',
//           value: 1,
//         },
//         {
//           title: '2格（宽）',
//           value: 2,
//         },
//       ],
//     },
//   },
// };

const quick = {
  name: 'quick',
  display: 'inline',
  title: '是否快速过滤',
  position: [DisplayPosition.filter],
  setter: 'BoolSetter',
  condition(prop) {
    if (
      allowQuickComponentList.includes(
        prop?.parent?.parent?.getPropValue?.('componentName'),
      )
    ) {
      return true;
    }
    return false;
  },
};
const required = {
  name: 'required',
  position: [],
  display: 'inline',
  title: '必填',
  // supportVariable: true,
  setter: 'BoolSetter',
};

const requiredMessage = {
  position: [],
  name: 'requiredMessage',
  display: 'inline',
  title: '必填提示',
  tip: '未填写时报的错误提示文案',
  // supportVariable: true,
  setter: 'CnI18nSetter',
};
const hidden = {
  name: 'hidden',
  title: '隐藏',
  display: 'inline',
  // position: [DisplayPosition.form, DisplayPosition.filter,DisplayPosition.formDialog],
  // supportVariable: true,
  setter: 'BoolSetter',
};

const labelAlign = {
  name: 'labelAlign',
  display: 'inline',
  title: '标签位置',
  position: [DisplayPosition.form, DisplayPosition.formDialog],
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'RadioGroupSetter',
          props: {
            options: [
              { title: '输入框上方', value: 'top' },
              { title: '输入框左侧', value: 'left' },
            ],
          },
        },
      ],
    },
  },
};

const placeholder = {
  position: [
    DisplayPosition.filter,
    DisplayPosition.form,
    DisplayPosition.formDialog,
    DisplayPosition.cnArrayTable,
  ],
  name: 'placeholder',
  title: '空提示信息',
  display: 'inline',
  // supportVariable: true,
  setter: 'CnI18nSetter',
};
const tip = {
  position: [
    DisplayPosition.form,
    DisplayPosition.formDialog,
    DisplayPosition.filter,
    DisplayPosition.cnArrayTable,
  ],
  name: 'tip',
  title: '标签提示信息',
  display: 'inline',
  // supportVariable: true,
  setter: 'CnI18nSetter',
};
const extra = () => {
  const linkGetPrototypeList = getItem(
    ButtonPosition.form,
    'link',
    'getPrototypeList',
  );
  return {
    position: [DisplayPosition.form, DisplayPosition.formDialog],
    name: 'extra',
    title: '右侧额外辅助信息',
    display: 'inline',
    // supportVariable: true,
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            title: '文本',
            condition() {
              return true;
            },
            componentName: 'CnI18nSetter',
            props: {},
          },
          {
            title: '超链接',
            componentName: 'ObjectSetter',
            props: {
              config: {
                items: [
                  {
                    name: 'text',
                    title: '链接文案',
                    display: 'inline',
                    setter: {
                      componentName: 'MixedSetter',
                      props: {
                        setters: [
                          {
                            componentName: 'CnI18nSetter',
                            title: '文本',
                          },
                          getJSExpressionPrototype({ type: 'formRequest' }),
                        ],
                      },
                    },
                  },
                  ...linkGetPrototypeList(ButtonPosition.form),
                ],
              },
            },
          },
          getJSXTemplate({
            position: ButtonPosition.form,
          }),
        ],
      },
    },
  };
};

// const disabled = {
//   name: 'disabled',
//   title: '禁用',
//   display: 'inline',
//   // supportVariable: true,
//   // setter: {
//   //   componentName: "MixedSetter",
//   //   props: {
//   //     setters: ["BoolSetter"],
//   //   },
//   // },
//   setter: 'BoolSetter',
//   position: [DisplayPosition.formDialog],
// };

const filterItemHidden = (position) => {
  const configList = [
    {
      dataKey: 'config',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表单字段',
      groupExprName: getFormExprNameByPosition({ position }),
      needSecondParam: false,
    },
    {
      groupName: '其他数据',
      groupExprName: __dataSource__,
      needSecondParam: true,
    },
  ];
  if (DisplayPosition.formDialog === position) {
    configList.splice(1, 0, getFormStateSetterSnippet());
  }
  let jsExpressionPrototype = getJSExpressionPrototype({ type: 'form' });
  if (DisplayPosition.cnArrayTable === position) {
    configList.unshift({
      dataKey: 'arrayTable',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表格当前行数据',
      groupExprName: __arrayTableCurrentRow__,
      needSecondParam: false,
    });
    jsExpressionPrototype = getJSExpressionPrototype({ type: 'arrayTable' });
  } else if (DisplayPosition.cnArraySubAreaCard === position) {
    configList.unshift({
      dataKey: 'arrayTable',
      labelKey: 'label',
      valueKey: 'name',
      groupName: currentFormCardLabel,
      groupExprName: __arrayTableCurrentRow__,
      needSecondParam: false,
    });
    jsExpressionPrototype = getJSExpressionPrototype({ type: 'arrayTable' });
  }
  return {
    name: 'hidden',
    title: '隐藏',
    display: 'inline',
    // supportVariable: true,
    className: 'cn-text-expr-setter',
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            componentName: 'BoolSetter',
            title: '布尔（true/false）',
          },
          {
            // componentName: <TextExprSetter
            //   dataKey={'config'}
            //   labelKey={'label'}
            //   valueKey={'name'}
            //   groupName={'表单字段'}
            // />,
            componentName: <ExprSetter configList={configList} />,
            title: '简单表达式',
          },
          jsExpressionPrototype,
        ],
      },
    },
    position: [
      DisplayPosition.filter,
      DisplayPosition.formDialog,
      DisplayPosition.form,
      DisplayPosition.cnArrayTable,
      DisplayPosition.cnArraySubAreaCard,
    ],
  };
};

const filterItemDisabled = (position) => {
  const configList = [
    {
      dataKey: 'config',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表单字段',
      groupExprName: getFormExprNameByPosition({ position }),
      needSecondParam: false,
    },
    {
      groupName: '其他数据',
      groupExprName: __dataSource__,
      needSecondParam: true,
    },
  ];
  if (DisplayPosition.formDialog === position) {
    configList.splice(1, 0, getFormStateSetterSnippet());
  }
  let jsExpressionPrototype = getJSExpressionPrototype({ type: 'form' });
  if (DisplayPosition.cnArrayTable === position) {
    configList.unshift({
      dataKey: 'arrayTable',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表格当前行数据',
      groupExprName: __arrayTableCurrentRow__,
      needSecondParam: false,
    });
    jsExpressionPrototype = getJSExpressionPrototype({ type: 'arrayTable' });
  } else if (DisplayPosition.cnArraySubAreaCard === position) {
    configList.unshift({
      dataKey: 'arrayTable',
      labelKey: 'label',
      valueKey: 'name',
      groupName: currentFormCardLabel,
      groupExprName: __arrayTableCurrentRow__,
      needSecondParam: false,
    });
    jsExpressionPrototype = getJSExpressionPrototype({ type: 'arrayTable' });
  }
  return {
    name: 'disabled',
    title: '禁用',
    display: 'inline',
    // supportVariable: true,
    className: 'cn-text-expr-setter',
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            componentName: 'BoolSetter',
            title: '布尔（true/false）',
          },
          {
            // componentName: <TextExprSetter
            //   dataKey={'config'}
            //   labelKey={'label'}
            //   valueKey={'name'}
            //   groupName={'表单字段'}
            // />,
            componentName: <ExprSetter configList={configList} />,
            title: '简单表达式',
          },
          jsExpressionPrototype,
        ],
      },
    },
    position: [
      DisplayPosition.filter,
      DisplayPosition.formDialog,
      DisplayPosition.form,
      DisplayPosition.cnArrayTable,
      DisplayPosition.cnArraySubAreaCard,
    ],
  };
};

const filterItemReadOnly = (position) => {
  const configList = [
    {
      dataKey: 'config',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表单字段',
      groupExprName: getFormExprNameByPosition({ position }),
      needSecondParam: false,
    },
    {
      groupName: '其他数据',
      groupExprName: __dataSource__,
      needSecondParam: true,
    },
  ];
  if (DisplayPosition.formDialog === position) {
    configList.splice(1, 0, getFormStateSetterSnippet());
  }
  let jsExpressionPrototype = getJSExpressionPrototype({ type: 'form' });
  if (DisplayPosition.cnArrayTable === position) {
    configList.unshift({
      dataKey: 'arrayTable',
      labelKey: 'label',
      valueKey: 'name',
      groupName: '表格当前行数据',
      groupExprName: __arrayTableCurrentRow__,
      needSecondParam: false,
    });
    jsExpressionPrototype = getJSExpressionPrototype({ type: 'arrayTable' });
  }
  return {
    name: 'readOnly',
    title: '只读',
    display: 'inline',
    // supportVariable: true,
    className: 'cn-text-expr-setter',
    setter: {
      componentName: 'MixedSetter',
      props: {
        setters: [
          {
            componentName: 'RadioGroupSetter',
            props: {
              options: [
                {
                  title: '是',
                  value: true,
                },
                {
                  title: '否',
                  value: false,
                },
                {
                  title: '不设置',
                },
              ],
            },
            title: '布尔（true/false）',
          },
          {
            // componentName: <TextExprSetter
            //   dataKey={'config'}
            //   labelKey={'label'}
            //   valueKey={'name'}
            //   groupName={'表单字段'}
            // />,
            componentName: <ExprSetter configList={configList} />,
            title: '简单表达式',
          },
          jsExpressionPrototype,
        ],
      },
    },
    position: [
      DisplayPosition.formDialog,
      DisplayPosition.form,
      DisplayPosition.cnArrayTable,
    ],
  };
};

const filterItemNotSubmitWhenHidden = (position) => {
  return {
    name: 'notSubmitWhenHidden',
    title: '隐藏时数据不提交',
    display: 'inline',
    // supportVariable: true,
    // className: 'cn-text-expr-setter',
    // setter: {
    //   componentName: 'MixedSetter',
    //   props: {
    //     setters: [
    //       {
    //         componentName: 'RadioGroupSetter',
    //         props: {
    //           options: [
    //             { title: '是', value: 'none' },
    //             { title: '否', value: '' },
    //             { title: '不设置' },
    //           ],
    //         },
    //       },
    //     ],
    //   },
    // },
    setter: 'BoolSetter',
    condition(prop) {
      return prop?.parent?.getPropValue?.('hidden') !== undefined;
    },
    position: [
      DisplayPosition.formDialog,
      DisplayPosition.form,
      DisplayPosition.cnArrayTable,
    ],
  };
};

const hasClear = {
  position: [
    DisplayPosition.filter,
    DisplayPosition.form,
    DisplayPosition.formDialog,
    DisplayPosition.cnArrayTable,
  ],
  name: 'hasClear',
  title: '允许清空',
  display: 'inline',
  // supportVariable: true,
  tip: '设计规范规定，不建议修改',
  setter: 'BoolSetter',
};
// const readOnly = {
//   position: [DisplayPosition.form, DisplayPosition.formDialog,DisplayPosition.cnArrayTable],
//   name: 'readOnly',
//   title: '只读',
//   display: 'inline',
//   // supportVariable: true,
//   tip: '',
//   className: 'cn-text-expr-setter',
//   setter: {
//     componentName: 'MixedSetter',
//     props: {
//       setters: [
//         {
//           // componentName: 'BoolSetter',
//           // title: '布尔（true/false）',
//           title: '是 或 否',
//           componentName: 'RadioGroupSetter',
//           props: {
//             options: [
//               { value: true, title: '是' },
//               { value: false, title: '否' },
//               { title: '不设置' },
//             ],
//           },
//         },
//         {
//           // componentName: <TextExprSetter
//           //   dataKey={'config'}
//           //   labelKey={'label'}
//           //   valueKey={'name'}
//           //   groupName={'表单字段'}
//           // />,
//           componentName: <ExprSetter
//             configList={[
//               {
//                 dataKey:'config',
//                 labelKey:'label',
//                 valueKey:'name',
//                 groupName:'表单字段',
//                 groupExprName: getFormExprNameByPosition({}),
//                 needSecondParam:false,
//               },
//               {
//                 groupName:'其他数据',
//                 groupExprName: __dataSource__,
//                 needSecondParam:true,
//               }
//             ]}
//           />,
//           title: '简单表达式',
//         },
//         getJSExpressionPrototype({ type: 'form' }),
//       ],
//     },
//   },
// };
const tableToolbarHidden = {
  name: 'hidden',
  title: '隐藏',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'aa'}
          //   labelKey={'aa'}
          //   valueKey={'aa'}
          //   groupName={' '}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'form' }),
      ],
    },
  },
  position: [ButtonPosition.tableToolArea, ButtonPosition.tableBatchArea],
};
const tableToolbarDisabled = {
  name: 'disabled',
  title: '禁用',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'aa'}
          //   labelKey={'aa'}
          //   valueKey={'aa'}
          //   groupName={' '}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'form' }),
      ],
    },
  },
  position: [ButtonPosition.tableToolArea, ButtonPosition.tableBatchArea],
};

const formButtonHidden = {
  name: 'hidden',
  title: '隐藏',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'config'}
          //   labelKey={'label'}
          //   valueKey={'name'}
          //   groupName={'表单字段列表'}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  dataKey: 'config',
                  labelKey: 'label',
                  valueKey: 'name',
                  groupName: '表单字段',
                  groupExprName: getFormExprNameByPosition({}),
                  needSecondParam: false,
                },
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'form' }),
      ],
    },
  },
  position: [
    ButtonPosition.formDialog,
    ButtonPosition.form,
    ButtonPosition.cardAction,
    ButtonPosition.subCardAction,
  ],
};
const formButtonDisabled = {
  name: 'disabled',
  title: '禁用',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          // componentName: <TextExprSetter
          //   dataKey={'config'}
          //   labelKey={'label'}
          //   valueKey={'name'}
          //   groupName={'表单字段列表'}
          // />,
          componentName: (
            <ExprSetter
              configList={[
                {
                  dataKey: 'config',
                  labelKey: 'label',
                  valueKey: 'name',
                  groupName: '表单字段',
                  groupExprName: getFormExprNameByPosition({}),
                  needSecondParam: false,
                },
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'form' }),
      ],
    },
  },
  position: [
    ButtonPosition.formDialog,
    ButtonPosition.form,
    ButtonPosition.cardAction,
    ButtonPosition.subCardAction,
  ],
};

const stepButtonHidden = {
  name: 'hidden',
  title: '隐藏',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          componentName: (
            <ExprSetter
              configList={[
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'step' }),
      ],
    },
  },
  position: [ButtonPosition.step],
};
const stepButtonDisabled = {
  name: 'disabled',
  title: '禁用',
  display: 'inline',
  // supportVariable: true,
  setter: {
    componentName: 'MixedSetter',
    props: {
      setters: [
        {
          componentName: 'BoolSetter',
          title: '布尔（true/false）',
        },
        {
          componentName: (
            <ExprSetter
              configList={[
                {
                  groupName: '其他数据',
                  groupExprName: __dataSource__,
                  needSecondParam: true,
                },
              ]}
            />
          ),
          title: '简单表达式',
        },
        getJSExpressionPrototype({ type: 'step' }),
      ],
    },
  },
  position: [ButtonPosition.step],
};

const width = {
  name: 'width',
  title: '列宽度',
  display: 'inline',
  setter: 'NumberSetter',
  position: [DisplayPosition.cnArrayTable],
};

const size = {
  name: 'size',
  title: '尺寸',
  display: 'inline',
  setter: {
    componentName: 'RadioGroupSetter',
    props: {
      options: [
        {
          title: '小',
          value: 'small',
        },
        {
          title: '中',
          value: 'medium',
        },
        {
          title: '大',
          value: 'large',
        },
      ],
    },
    title: '布尔（true/false）',
  },
  position: [DisplayPosition.form, DisplayPosition.formDialog],
};

const iconType = {
  name: 'iconType',
  title: '按钮图标',
  display: 'inline',
  setter: 'StringSetter',
  position: [ButtonPosition.cnCardItemsSubAction],
};

const iconTypeHelp = {
  display: 'none',
  setter: (
    <DocSetter
      content={
        <div className=''>
          请到{' '}
          <a
            target={'_blank'}
            href={
              'https://done.alibaba-inc.com/dsm/74296/components/detail/cnicon?themeid=55809&tabActiveKey=component'
            }
            rel='noreferrer'
          >
            图标库
          </a>{' '}
          中寻找想用的图标，填写图标type即可。
          <a
            target={'_blank'}
            href={
              'https://alidocs.dingtalk.com/i/nodes/NkPaj7GAXdpWOkPeZ6p0Wqwgylnomz9B?utm_scene=team_space&iframeQuery=anchorId%3Dlfrq5i85k9wvpej2u0h'
            }
            rel='noreferrer'
          >
            体验Demo
          </a>
        </div>
      }
    />
  ),
  position: [ButtonPosition.cnCardItemsSubAction],
};

const colSpan = {
  name: 'colSpan',
  title: '当前组件在一行占几列',
  display: 'inline',
  setter: {
    componentName: 'RadioGroupSetter',
    props: {
      options: [
        { title: '无', value: undefined },
        { title: '一', value: 1 },
        { title: '二', value: 2 },
        { title: '三', value: 3 },
        { title: '四', value: 4 },
        { title: '五', value: 5 },
        { title: '六', value: 6 },
      ],
    },
  },
  position: [DisplayPosition.formDialog, DisplayPosition.form],
};

const allStyleMap = {
  quick,
  // size,
  // width,
  type,
  tableOperateHidden,
  tableOperateDisabled,
  // span,
  required,
  requiredMessage,
  hidden,
  placeholder,
  tip,
  extra,
  hasClear,
  // disabled,
  filterItemHidden,
  // filterItemNotSubmitWhenHidden,
  filterItemDisabled,
  filterItemReadOnly,
  labelAlign,
  // readOnly,
  tableToolbarHidden,
  tableToolbarDisabled,
  formButtonHidden,
  formButtonDisabled,
  arrayTableOperateHidden,
  arrayTableOperateDisabled,
  stepButtonDisabled,
  stepButtonHidden,
  iconType,
  iconTypeHelp,
  // colSpan,
};

// 获取列表
export function getStyleListByPosition(position) {
  const defaultStyleList = Object.keys(allStyleMap);
  const result = [];
  if (position !== undefined) {
    defaultStyleList.forEach((name) => {
      let item = allStyleMap[name];
      if (typeof item === 'function') {
        item = item(position);
      }
      if (item && item.position && item.position.includes(position)) {
        result.push(item);
      }
    });
  }
  return result;
}

export function getJSExpressionPrototype(config) {
  const { type: configType, prototypeConfig } = config || {};
  if (configType === 'form') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state) => {
  return formValues.xxxx === "xxxx";
}`,
      tip: `当前函数需要返回 true/false。
formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'table') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(record, state, index) => {
  return record.id === "xxxx";
}`,
      tip: `当前函数需要返回 true/false。
record：表格当前行的数据。
state：全部的数据，在左侧列表中选择使用。
index：表格当前行的位置。

`,
    });
  } else if (configType === 'formRequest') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state) => {
  // return formValues.xxxx;
}`,
      tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'tableRequest') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(record, state, index) => {
  // return record.xxxx;
}`,
      tip: `record：表格当前行的数据。
state：全部的数据，在左侧列表中选择使用。
index：表格当前行的位置。

`,
    });
  } else if (configType === 'formJSX') {
    return {
      title: 'JSX代码',
      componentName: 'CnRowDataSetter',
      props: () => {
        const stateList = getDataSourceListWithAllPath({
          needChildren: true,
          prototypeConfig,
        });
        return {
          list: stateList,
          initialCode: `(formValues, state) => {
  // return <div>xxx字段的数据是：{formValues.xxxx}</div>;
}`,
          tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
`,
        };
      },
    };
  } else if (configType === 'select') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(state) => {
  // 需要返回数组，格式如下
  return [
    {
      label: '选项一',
      value: 'first'
    }
  ]
}`,
      tip: `当前函数需要返回数组。
`,
    });
  } else if (configType === 'tableBatchArea') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state, selectedRowKeys, selectedRowRecords) => {
  // return formValues.xxxx;
}`,
      tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
selectedRowKeys：当前选择的数据主键列表。
selectedRowRecords：当前选择的数据列表。
`,
    });
  } else if (configType === 'base') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(arg, state) => {
  // return state.urlParams.xxx;
}`,
      tip: `
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'arrayTable') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state, record) => {
  return record.xxxx === "xxxx";
}`,
      tip: `当前函数需要返回 true/false。
formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
record：表格当前行数据。
`,
    });
  } else if (configType === 'breadcrumb') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `() => {
  // 需要返回数组，格式如下
  return [
    {
      children: '页面1',
    },
    {
      children: '页面2'
    }
  ]
}`,
      tip: `当前函数需要返回数组。
`,
    });
  } else if (configType === 'datepicker') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(date, mode, formValues, state) => {

}`,
      tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'step') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(current, state) => {
  return current === 0;
}`,
      tip: `当前函数需要返回 true/false。
current：当前步骤条。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'arrayTableOperate') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(record, state, index, formValues) => {
  return record.id === "xxxx";
}`,
      tip: `当前函数需要返回 true/false。
record：表格当前行的数据。
state：全部的数据，在左侧列表中选择使用。
index：表格当前行的位置。
formValues：当前表单的数据。

`,
    });
  } else if (configType === 'tab') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(currentSelectTab, state) => {
  // return state.urlParams.xxx;
}`,
      tip: `
currentSelectTab：当前选中的tab项。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'formDialogTitle') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(openDialogMode, state) => {
  // return openDialogMode;
}`,
      tip: `
openDialogMode：本次打开的弹窗的用途: 新增(new)、编辑(edit)、详情(detail)。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'tableInitRequest') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state, { currentPage, pageSize }) => {
  // return formValues.xxxx;
}`,
      tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
currentPage：${currentPageLabel}。
pageSize：${pageSizeLabel}。
`,
    });
  } else if (configType === 'messageContent') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state) => {
  // success:：成功；warning：警告；error：错误；notice：通知；help：帮助；
  // return 'success';
}`,
      tip: `formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'arrayTableCurrentRow') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(formValues, state, { ${__arrayTableCurrentRow__} }) => {
  return formValues.xxxx === "xxxx";
}`,
      tip: `当前函数需要返回 true/false。
formValues：当前筛选栏/表单的数据。
state：全部的数据，在左侧列表中选择使用。
__arrayTableCurrentRow__：可编辑表格当前行的数据。
`,
    });
  } else if (configType === 'headers') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(arg, state) => {
  // return { }
}`,
      tip: `
返回值（return）必须是JSON对象格式
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'props') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(oldProps, state) => {
  // 返回额外的props属性即可，返回值将会和原props合并；
  // return {};
}`,
      tip: `
oldProps: 组件的原始oldProps
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'enterPointsItemClick') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(enterPointsItem, state) => {
  return enterPointsItem.xxxx;
}`,
      tip: `
enterPointsItem：当前点击项数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  } else if (configType === 'listItemClick') {
    return getJSExpressionPrototypeTemplate({
      prototypeConfig,
      initialCode: `(listItem, state) => {
  return listItem.xxxx;
}`,
      tip: `
listItem：当前点击项数据。
state：全部的数据，在左侧列表中选择使用。
`,
    });
  }

  return {};
}

export function getParamSetterPrototype(config) {
  const { type, prototypeConfig } = config || {};
  const { flowList, currentFlowIndex, additionalPosition } =
    prototypeConfig || {};
  if (type === 'formDialog') {
    return {
      componentName: 'ParamSelectSetter',
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList: [
          {
            dataKey: 'config',
            labelKey: 'label',
            valueKey: 'name',
            groupName: '当前表单',
          },
          {
            groupName: formDialogStateLabel,
            handleCustomGroup: (extra) => {
              if (Array.isArray(extra?.children)) {
                extra.children.push({
                  label: openDialogModeLabel,
                  value: `${__extraParam__}.openDialogMode`,
                });
              }
            },
          },
          {
            groupName: '动作编排的数据',
            groupExprName: __flowData__,
            needSecondParam: true,
            flowList,
            currentFlowIndex,
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  } else if (type === 'form') {
    return {
      componentName: 'ParamSelectSetter',
      // props: {
      //   dataKey: 'config',
      //   labelKey: 'label',
      //   valueKey: 'name',
      //   groupName: '当前表单',
      // },
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList: [
          {
            dataKey: 'config',
            labelKey: 'label',
            valueKey: 'name',
            groupName: '当前表单',
          },
          {
            groupName: '动作编排的数据',
            groupExprName: __flowData__,
            needSecondParam: true,
            flowList,
            currentFlowIndex,
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  } else if (type === 'table') {
    const configList = [
      {
        dataKey: 'columns',
        labelKey: 'title',
        valueKey: 'dataIndex',
        groupName: '当前行数据',
        // groupExprName: __tableCurrentRow__,
        needSecondParam: false,
      },
      {
        groupName: '动作编排的数据',
        groupExprName: __flowData__,
        needSecondParam: true,
        flowList,
        currentFlowIndex,
      },
      {
        groupName: '其他数据',
        groupExprName: __dataSource__,
        needSecondParam: true,
      },
    ];
    if (additionalPosition === ButtonPosition.childTableOperate) {
      configList[0] = {
        groupName: '当前行数据',
        groupExprName: __record__,
        handleCustomGroup: (extra, field) => {
          if (Array.isArray(extra?.children) && field) {
            const originList = field
              ?.getNode?.()
              ?.getPropValue?.('childTable')?.columns;
            if (isArrayNotEmpty(configList)) {
              extra.children = handleOriginList(
                originList,
                'title',
                'dataIndex',
                __record__,
              );
            }
          }
        },
      };
    }
    return {
      componentName: 'ParamSelectSetter',
      // props: {
      //   dataKey: 'columns',
      //   labelKey: 'title',
      //   valueKey: 'dataIndex',
      //   groupName: '当前行数据',
      // },
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList,
      },
      title: '选择参数',
    };
  } else if (type === 'filter') {
    return {
      componentName: 'ParamSelectSetter',
      props: {
        dataKey: 'config',
        labelKey: 'label',
        valueKey: 'name',
        groupName: '筛选栏',
        relativeDataSourceName: '_bindFilterDataSourceName',
        relativeDataSourceNameKey: '_dataSourceName',
      },
      // props: {
      //   configList:[
      //     {
      //       dataKey: 'config',
      //       labelKey: 'label',
      //       valueKey: 'name',
      //       groupName: '筛选栏',
      //       relativeDataSourceName: '_bindFilterDataSourceName',
      //       relativeDataSourceNameKey: '_dataSourceName',
      //     },
      //     {
      //       groupName:'动作编排的数据',
      //       groupExprName: __flowData__,
      //       needSecondParam:true,
      //       flowList,
      //       currentFlowIndex,
      //     },
      //     {
      //       groupName:'其他数据',
      //       groupExprName: __dataSource__,
      //       needSecondParam:true,
      //     },
      //   ]
      // },
      title: '选择参数',
    };
  } else if (type === 'arrayTable') {
    return {
      componentName: 'ParamSelectSetter',
      props: {
        dataKey: 'arrayTable',
        labelKey: 'label',
        valueKey: 'name',
        groupName: '当前行数据',
      },
      title: '选择参数',
    };
  } else if (type === 'arrayTableItemEvent') {
    return {
      componentName: 'ParamSelectSetter',
      // props: {
      //   dataKey: 'arrayTable',
      //   labelKey: 'label',
      //   valueKey: 'name',
      //   groupName: '当前行数据',
      // },
      props: {
        configList: [
          {
            groupName: '当前行数据',
            groupExprName: __arrayTableCurrentRow__,
            handleCustomGroup: (extra, field) => {
              const path = field?.path;
              if (
                Array.isArray(path) &&
                path.length > 5 &&
                path[0] === 'config' &&
                path[2] === 'options' &&
                (path[3] === 'config' || path[3] === 'buttons')
              ) {
                const arrayTableIndex = path[1];
                if (typeof arrayTableIndex === 'number') {
                  const formConfig = field
                    ?.getNode?.()
                    ?.getPropValue?.('config');
                  const arrayTableConfig = formConfig?.[arrayTableIndex] || {};
                  if (
                    isRecursionComponent(arrayTableConfig?.componentName) &&
                    arrayTableConfig?.options?.config?.length > 0
                  ) {
                    const originList = arrayTableConfig?.options?.config;
                    const tempList = handleOriginList(
                      originList,
                      'label',
                      'name',
                      `${__extraParam__}.${__arrayTableCurrentRow__}`,
                    );
                    if (isArrayNotEmpty(tempList)) {
                      extra.children = tempList;
                    }
                  }
                }
              }
            },
          },
          {
            groupName: '动作编排的数据',
            groupExprName: __flowData__,
            needSecondParam: true,
            flowList,
            currentFlowIndex,
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  } else if (type === 'base') {
    return {
      componentName: 'ParamSelectSetter',
      // props: {
      //   dataKey: 'aa',
      //   labelKey: 'aa',
      //   valueKey: 'aa',
      //   groupName: '参数列表',
      // },
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList: [
          {
            groupName: '动作编排的数据',
            groupExprName: __flowData__,
            needSecondParam: true,
            flowList,
            currentFlowIndex,
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  } else if (type === 'filterWithPagination') {
    return {
      componentName: 'ParamSelectSetter',
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList: [
          {
            dataKey: 'config',
            labelKey: 'label',
            valueKey: 'name',
            groupName: '筛选栏',
            relativeDataSourceName: '_bindFilterDataSourceName',
            relativeDataSourceNameKey: '_dataSourceName',
          },
          {
            groupName: '当前表格的的分页信息',
            groupExprName: __extraParam__,
            handleCustomGroup: (extra) => {
              if (Array.isArray(extra?.children)) {
                extra.children.push({
                  label: currentPageLabel,
                  value: `${__extraParam__}.currentPage`,
                });
                extra.children.push({
                  label: pageSizeLabel,
                  value: `${__extraParam__}.pageSize`,
                });
              }
            },
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  } else if (type === 'tree') {
    return {
      componentName: 'ParamSelectSetter',
      props: {
        ParamSelectSetterComponent: ParamSelectSetter,
        configList: [
          {
            groupName: leftTreeStateLabel,
            handleCustomGroup: (extra) => {
              if (Array.isArray(extra?.children)) {
                extra.children.push({
                  label: leftTreeAfterDropDataSourceLabel,
                  value: `${__extraParam__}.afterDropDataSource`,
                });
              }
            },
          },
          {
            groupName: '动作编排的数据',
            groupExprName: __flowData__,
            needSecondParam: true,
            flowList,
            currentFlowIndex,
          },
          {
            groupName: '其他数据',
            groupExprName: __dataSource__,
            needSecondParam: true,
          },
        ],
      },
      title: '选择参数',
    };
  }
}

function getJSExpressionPrototypeTemplate(config) {
  const { title, initialCode, tip, prototypeConfig } = config || {};
  return {
    title: title || '写js表达式',
    componentName: 'CnRowDataSetter',
    props: () => {
      const stateList = getDataSourceListWithAllPath({
        needChildren: true,
        prototypeConfig,
      });
      return {
        list: stateList,
        initialCode,
        tip,
      };
    },
  };
}