text: /* eslint-disable no-unused-vars */
  /* eslint-disable no-undefined */
  /* eslint-disable no-else-return */
  /* eslint-disable no-eval */
  /* eslint-disable prefer-const */
  import { WordCloud } from '@ant-design/plots';
  import React, { Component } from 'react';
  import PropTypes from 'prop-types';
  import { isUndefined, omitBy, intersection, cloneDeep } from 'lodash';
  import {
      metaBasePropTypes,
      legendBasePropTypes,
      labelBasePropTypes,
      tooltipBasePropTypes,
      annotationsBasePropTypes
  } from './BasePropTypes.react';
  import { difference } from './utils';
  
  // 定义不触发重绘的参数数组
  const preventUpdateProps = ['loading_state', 'recentlyWordClickRecord'];
  
  // 定义词云图组件AntdWordCloud，部分API参数参考https://charts.ant.design/zh/examples/more-plots/word-cloud#basic
  export default class AntdWordCloud extends Component {
  
      constructor(props) {
          super(props);
          this.chartRef = React.createRef();
      }
  
      shouldComponentUpdate(nextProps) {
  
          // 计算发生变化的参数名
          const changedProps = Object.keys(difference(this.props, nextProps))
  
          // 若无变化的props，则不触发重绘
          if (changedProps.length === 0) {
              return false;
          }
  
          // 计算发生变化的参数名与需要阻止重绘的参数名数组的交集
          let changedPreventUpdateProps = intersection(
              changedProps,
              preventUpdateProps
          )
  
          // 若有交集，则不触发重绘
          if (changedPreventUpdateProps.length !== 0) {
              return false;
          } else {
              // 取得plot实例
              const chart = this.chartRef.current.getChart()
              // 检查data参数是否发生更新
              if (changedProps.indexOf('data') !== -1) {
                  // 动态调整数据
                  chart.changeData(nextProps.data)
                  return false;
              } else {
                  chart.update({
                      ...nextProps
                  })
              }
          }
          return true;
      }
  
      render() {
          // 取得必要属性或参数
          const {
              id,
              className,
              style,
              data,
              meta,
              wordField,
              weightField,
              colorField,
              spiral,
              placementStrategy,
              width,
              height,
              autoFit,
              padding,
              appendPadding,
              renderer,
              locale,
              wordStyle,
              imageMask,
              color,
              legend,
              label,
              tooltip,
              annotations,
              setProps,
              loading_state
          } = this.props;
  
          // 初始化config参数对象，每次渲染前的参数解析变动只在config中生效
          let config = {};
  
          // 预处理元信息
          if (meta) {
              config.meta = cloneDeep(meta);
              for (let i in Object.keys(meta)) {
                  // 若meta中当前字段属性下的formatter具有自定义函数func属性
                  if (meta[Object.keys(meta)[i]]?.formatter?.func) {
                      config.meta[Object.keys(meta)[i]].formatter = eval(meta[Object.keys(meta)[i]].formatter.func)
                  }
              }
          }
  
          // 刷新基础参数
          config = {
              ...config,
              data,
              wordField,
              weightField,
              colorField,
              spiral,
              width,
              height,
              autoFit,
              padding,
              appendPadding,
              renderer,
              locale,
              imageMask
          }
  
          config.placementStrategy = cloneDeep(placementStrategy)
          // 若placementStrategy具有自定义函数func属性
          if (placementStrategy?.func) {
              config.placementStrategy = eval(placementStrategy.func)
          }
  
          // 折线样式
          config.wordStyle = cloneDeep(wordStyle)
  
          // 色彩样式
          config.color = cloneDeep(color)
          // 若color具有自定义函数func属性
          if (color?.func) {
              config.color = eval(color.func)
          }
  
          // 图例样式
          config.legend = cloneDeep(legend)
          // 若legend.itemName.formatter具有自定义函数func属性
          if (legend?.itemName?.formatter?.func) {
              config.legend.itemName.formatter = eval(legend.itemName.formatter.func)
          }
          // 若legend.itemValue.formatter具有自定义函数func属性
          if (legend?.itemValue?.formatter?.func) {
              config.legend.itemValue.formatter = eval(legend.itemValue.formatter.func)
          }
  
          // 数据标签
          config.label = cloneDeep(label)
          // 若label.formatter具有自定义函数func属性
          if (label?.formatter?.func) {
              config.label.formatter = eval(label.formatter.func)
          }
  
          // 悬浮提示
          config.tooltip = cloneDeep(tooltip)
          // 若tooltip.formatter具有自定义函数func属性
          if (tooltip?.formatter?.func) {
              config.tooltip.formatter = eval(tooltip.formatter.func)
          }
          // 若tooltip.customItems具有自定义函数func属性
          if (tooltip?.customItems?.func) {
              config.tooltip.customItems = eval(tooltip.customItems.func)
          }
  
          // 标注
          config.annotations = cloneDeep(annotations)
  
          // 利用lodash移除所有值为undefined的属性
          config = omitBy(config, isUndefined)
  
          return <WordCloud
              id={id}
              className={className}
              style={style}
              data-dash-is-loading={
                  (loading_state && loading_state.is_loading) || undefined
              }
              ref={this.chartRef}
              // 绑定常用事件
              onReady={(plot) => {
                  plot.on('element:click', (e) => {
  
                      // 绑定文字点击事件
                      setProps({
                          recentlyWordClickRecord: {
                              timestamp: (new Date()).valueOf(),
                              data: e.data.mappingData._origin.datum
                          }
                      })
                  });
              }}
              {...config} />;
      }
  }
  
  // 定义参数或属性
  AntdWordCloud.propTypes = {
      // 部件id
      id: PropTypes.string,
  
      // css类名
      className: PropTypes.string,
  
      // 自定义css字典
      style: PropTypes.object,
  
      // 设置和弦图绘图所需数据
      data: PropTypes.arrayOf(PropTypes.object),
  
      // 定义字段预处理元信息
      meta: metaBasePropTypes,
  
      // 设置作为词云图文字内容的字段，必填
      wordField: PropTypes.string.isRequired,
  
      // 设置作为词云图权重字段的字段，必填
      weightField: PropTypes.string.isRequired,
  
      // 设置作为文字色彩映射的字段
      colorField: PropTypes.string,
  
      // 用于设置词云图更为接近的形状模式，可选的有'archimedean'（椭圆）、'rectangular'（矩形）
      // 默认为'archimedean'
      spiral: PropTypes.oneOf(['archimedean', 'rectangular']),
  
      // 用于自定义每个词语坐标、样式等信息的回调函数
      placementStrategy: PropTypes.exact({
          // 字符串格式的回调函数
          func: PropTypes.string
      }),
  
      // 定义图表容器像素宽度，默认为400
      width: PropTypes.number,
  
      // 定义图表容器像素高度，默认为400
      height: PropTypes.number,
  
      // 设置图表是否自适应容器宽高，当设置为true时，width与height参数将失效，默认为true
      autoFit: PropTypes.bool,
  
      // 定义图表四个方向的空白间距值，可以为单个数字譬如16，也可以为四个数字构成的数组，按顺序代表上-右-下-左分别的像素间距
      padding: PropTypes.oneOfType([
          PropTypes.number,
          PropTypes.arrayOf(PropTypes.number),
          PropTypes.oneOf(['auto'])
      ]),
  
      // 定义在padding基础上额外的像素填充间距
      appendPadding: PropTypes.oneOfType([
          PropTypes.number,
          PropTypes.arrayOf(PropTypes.number)
      ]),
  
      // 设置图表渲染方式为'canvas'或'svg'模式，默认为'canvas'
      renderer: PropTypes.oneOf(['canvas', 'svg']),
  
      // 设置语言，可选的有'zh-CN'与'en-US'
      locale: PropTypes.oneOf(['zh-CN', 'en-US']),
  
      // 配置词云图文字样式
      wordStyle: PropTypes.exact({
          fontFamily: PropTypes.string,
          fontWeight: PropTypes.string,
          padding: PropTypes.number,
          fontSize: PropTypes.arrayOf(PropTypes.number)
      }),
  
      // 配置蒙版图片（url、base64字符串等）
      imageMask: PropTypes.string,
  
      // 用于手动设置调色方案，接受css中合法的所有颜色值，当传入单个字符串时，所有折线沿用此颜色值
      // 当传入数组时，会视作调色盘方案对colorField区分的不同系列进行着色
      // 当传入对象时，会解析出其'func'属性对应的字符串，解析为函数，以支持更为自由的colorField->色彩映射
      color: PropTypes.oneOfType([
          PropTypes.string,
          PropTypes.arrayOf(PropTypes.string),
          PropTypes.exact({
              // 传入字符串形式的js函数体源码，例如
              // (ref) => {
              //     if (ref.series === '系列一'){
              //         return 'red'
              //     }
              //     return 'blue'
              // }
              func: PropTypes.string
          })
      ]),
  
      // 配置图例相关参数
      legend: legendBasePropTypes,
  
      // 配置文字标签相关参数
      label: labelBasePropTypes,
  
      // 设置tooltip相关参数
      tooltip: tooltipBasePropTypes,
  
      // 配置标注相关参数
      annotations: annotationsBasePropTypes,
  
      // 单独文字点击事件
      recentlyWordClickRecord: PropTypes.exact({
          // 事件触发的时间戳信息
          timestamp: PropTypes.number,
  
          // 对应的数据点信息
          data: PropTypes.object
      }),
  
      loading_state: PropTypes.shape({
          /**
           * Determines if the component is loading or not
           */
          is_loading: PropTypes.bool,
          /**
           * Holds which property is loading
           */
          prop_name: PropTypes.string,
          /**
           * Holds the name of the component that is loading
           */
          component_name: PropTypes.string
      }),
  
      /**
       * Dash-assigned callback that should be called to report property changes
       * to Dash, to make them available for callbacks.
       */
      setProps: PropTypes.func
  };
  
  // 设置默认参数
  AntdWordCloud.defaultProps = {
  }