// 判断节点是否是 IfStatement 就可以调用 islfStatement 或者 assertlfStatement, isXxx 会返回 boolean 表示结果，而 assertXxx 则会在类型不一致时抛异常。
t.isIfstatement(node, opts);

// opts 可以指定一些属性是什么值，增加更多限制条件，做更精确的判断。
t.isIdentifier(node, { name: "paths" })

const parser = require('@babel/parser');
const { transformFromAstSync } = require('@babel/core');
// 编写的插件
const plugin = require('./plugin');

function transformCode(source) {
  // 使用@babel/parser解析代码
  const ast = parser.parse(source, {
    sourceType: 'module',
    presets: ['@babel/preset-env', '@babel/preset-react', '@babel/preset-typescript'],
    plugins: [
      // react 项目需要引入相关插件，babel自带
      'jsx', // Enable JSX syntax
      'classProperties', // Enable class properties syntax
      'typescript', // Enable TypeScript syntax
      'moduleStringNames', // Enable module string names syntax
      'exportNamespaceFrom', // Enable export namespace from syntax
      'exportDefaultFrom', // Enable export default from syntax
      'dynamicImport', // Enable dynamic import syntax
      'asyncGenerators', // Enable async generators syntax
      ['decorators', { decoratorsBeforeExport: !1 }], // Enable decorators syntax
      'asyncDoExpressions', // Enable async do expressions syntax
      'doExpressions', // Enable do expressions syntax
      'functionBind', // Enable function bind syntax
      'throwExpressions', // Enable throw expressions syntax
    ],
  });

  const { code } = transformFromAstSync(ast, source, {
    plugins: [[plugin, {}]],
  });

  return code;
}

const { types: t } = babel;
const stringValue = '客户';
const regex = new RegExp(stringValue, 'g');

// plugin.js
Program(path) {
  let lastImportIndex = -1;
  let hasImport = false;
  path.traverse({
    ImportDeclaration(path) {
    // 判断是否已经引入文件
      lastImportIndex = path.key;
      if (path?.node?.source.value === '@/constants/version') {
        hasImport = true;
      }
    },
  });
  if (hasImport) return;
  // 构建引入模版
  const importStatement = t.importDeclaration(
    [t.importSpecifier(t.identifier('CUSTOMER_LABEL'), t.identifier('CUSTOMER_LABEL'))],
    t.stringLiteral('@/constants/version'),
  );
  if (lastImportIndex > -1) {
    // 在最后一个 import 语句后面插入新的 import 语句
    path.get('body')[lastImportIndex].insertAfter(importStatement);
  } else {
    path.unshiftContainer('body', importStatement);
  }
},

StringLiteral(path) {
  const { node } = path;
  // 判断字符串中是否包含"客户"
  if (node.value.includes(stringValue)) {
	// 判断是否是JSX属性值
    if (t.isJSXAttribute(path.parent)) {
      const elementList = node.value.split(stringValue);
      const newElementList = elementList.map((item, index) =>
        index === elementList.length - 1
          ? t.templateElement({ raw: item }, true)
          : t.templateElement({ raw: item }),
      );
      const count = (node.value.match(regex) || []).length;
      // 转换为模版字符串
      const templateLiteral = t.templateLiteral(
        newElementList,
        new Array(count).fill(t.identifier('CUSTOMER_LABEL')),
      );
      const jsxExpressionContainer = t.jsxExpressionContainer(templateLiteral);
      // 进行AST节点替换
      path.replaceWith(jsxExpressionContainer);
    } else {
	  // 普通字符串的处理
      const elementList = node.value.split(stringValue);
      const newElementList = elementList.map((item, index) =>
        index === elementList.length - 1
          ? t.templateElement({ raw: item }, true)
          : t.templateElement({ raw: item }),
      );
      const count = (node.value.match(regex) || []).length;
      const templateLiteral = t.templateLiteral(
        newElementList,
        new Array(count).fill(t.identifier('CUSTOMER_LABEL')),
      );
      path.replaceWith(templateLiteral);
    }
  }
},

TemplateLiteral(path) {
  const { node } = path;
  // 遍历模板字符串中的所有模板元素
  for (let i = 0; i < node.quasis.length; i++) {
    const templateElement = node.quasis[i];
    const { value } = templateElement;

    // 判断模板元素中是否包含"客户"
    if (value.raw.includes(stringValue)) {
      // 将模板元素中的"客户"替换为`${CUSTOMER_LABEL}`
      const updatedValue = value.raw.replace(regex, '${CUSTOMER_LABEL}');
      // 更新模板元素的值
      templateElement.value.raw = updatedValue;
      templateElement.value.cooked = updatedValue;
    }
  }
},

const generator = require('@babel/generator').default;

JSXElement(path) {
  path.traverse({
    JSXText(textPath) {
      const textValue = textPath.node.value.trim();
      if (textValue.includes(stringValue)) {
        const variable = t.jsxExpressionContainer(t.identifier('CUSTOMER_LABEL'));

        const newText = textValue.replace(stringValue, `${generator(variable).code}`);
        textPath.replaceWith(t.jsxText(newText));
      }
    },
  });
},