"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getValidFiles = exports.isValidHook = exports.genModels = exports.sort = exports.genExtraModels = exports.genImports = exports.getPath = exports.getName = void 0;

function _react() {
  const data = _interopRequireDefault(require("react"));

  _react = function _react() {
    return data;
  };

  return data;
}

function _path() {
  const data = _interopRequireDefault(require("path"));

  _path = function _path() {
    return data;
  };

  return data;
}

function _os() {
  const data = require("os");

  _os = function _os() {
    return data;
  };

  return data;
}

function _fs() {
  const data = require("fs");

  _fs = function _fs() {
    return data;
  };

  return data;
}

function _umi() {
  const data = require("umi");

  _umi = function _umi() {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const t = _umi().utils.t,
      parser = _umi().utils.parser,
      traverse = _umi().utils.traverse,
      winPath = _umi().utils.winPath;

const getFileName = name => {
  const fileName = _path().default.basename(name, _path().default.extname(name));

  if (fileName.endsWith('.model') || fileName.endsWith('.models')) {
    return fileName.split('.').slice(0, -1).join('.');
  }

  return fileName;
};

const getName = (absPath, absSrcPath) => {
  const relativePath = _path().default.relative(absSrcPath, absPath); // model files with namespace


  const dirList = _path().default.dirname(relativePath).split(_path().default.sep);

  try {
    const validDirs = dirList.filter(ele => !['src', 'page', 'pages', 'model', 'models'].includes(ele));

    if (validDirs && validDirs.length) {
      return `${validDirs.join('.')}.${getFileName(relativePath)}`;
    }

    return getFileName(relativePath);
  } catch (e) {
    return getFileName(relativePath);
  }
};

exports.getName = getName;

const getPath = absPath => {
  const info = _path().default.parse(absPath);

  return winPath(_path().default.join(info.dir, info.name).replace(/'/, "'"));
};

exports.getPath = getPath;

const genImports = imports => imports.map((ele, index) => `import model${index} from "${winPath(getPath(ele))}";`).join(_os().EOL);

exports.genImports = genImports;

const genExtraModels = (models = [], absSrcPath) => models.map(ele => {
  if (typeof ele === 'string') {
    return {
      importPath: getPath(ele),
      importName: _path().default.basename(ele).split('.')[0],
      namespace: getName(ele, absSrcPath)
    };
  }

  return {
    importPath: getPath(ele.absPath),
    importName: _path().default.basename(ele.absPath).split('.')[0],
    namespace: ele.namespace,
    exportName: ele.exportName
  };
});

exports.genExtraModels = genExtraModels;

const sort = ns => {
  let final = [];
  ns.forEach((item, index) => {
    if (item.use && item.use.length) {
      const itemGroup = [...item.use, item.namespace];
      const cannotUse = [item.namespace];

      for (let i = 0; i <= index; i += 1) {
        if (ns[i].use.filter(v => cannotUse.includes(v)).length) {
          if (!cannotUse.includes(ns[i].namespace)) {
            cannotUse.push(ns[i].namespace);
            i = -1;
          }
        }
      }

      const errorList = item.use.filter(v => cannotUse.includes(v));

      if (errorList.length) {
        throw Error(`Circular dependencies: ${item.namespace} can't use ${errorList.join(', ')}`);
      }

      const intersection = final.filter(v => itemGroup.includes(v));

      if (intersection.length) {
        // first intersection
        const finalIndex = final.indexOf(intersection[0]); // replace with groupItem

        final = final.slice(0, finalIndex).concat(itemGroup).concat(final.slice(finalIndex + 1));
      } else {
        final.push(...itemGroup);
      }
    }

    if (!final.includes(item.namespace)) {
      // first occurance append to the end
      final.push(item.namespace);
    }
  });
  return [...new Set(final)];
};

exports.sort = sort;

const genModels = (imports, absSrcPath) => {
  const contents = imports.map(absPath => ({
    namespace: getName(absPath, absSrcPath),
    content: (0, _fs().readFileSync)(absPath).toString()
  }));
  const allUserModel = imports.map(absPath => getName(absPath, absSrcPath));

  const checkDuplicates = list => new Set(list).size !== list.length;

  const raw = contents.map((ele, index) => {
    const ast = parser.parse(ele.content, {
      sourceType: 'module',
      plugins: ['jsx', 'typescript']
    });
    const use = [];
    traverse.default(ast, {
      enter(astPath) {
        if (astPath.isIdentifier({
          name: 'useModel'
        })) {
          try {
            // string literal
            const ns = astPath.parentPath.node.arguments[0].value;

            if (allUserModel.includes(ns)) {
              use.push(ns);
            }
          } catch (e) {// console.log(e)
          }
        }
      }

    });
    return {
      namespace: ele.namespace,
      use,
      importName: `model${index}`
    };
  });
  const models = sort(raw);

  if (checkDuplicates(contents.map(ele => ele.namespace))) {
    throw Error('umi: models 中包含重复的 namespace！');
  }

  return raw.sort((a, b) => models.indexOf(a.namespace) - models.indexOf(b.namespace));
};

exports.genModels = genModels;

const isValidHook = filePath => {
  const isTS = _path().default.extname(filePath) === '.ts';
  const isTSX = _path().default.extname(filePath) === '.tsx';
  const content = (0, _fs().readFileSync)(filePath, {
    encoding: 'utf-8'
  }).toString();
  const ast = parser.parse(content, {
    sourceType: 'module',
    plugins: [// .ts 不能加 jsx，因为里面可能有 `<Type>{}` 这种写法
    // .tsx, .js, .jsx 可以加
    isTS ? false : 'jsx', // 非 ts 不解析 typescript
    isTS || isTSX ? 'typescript' : false, // 支持更多语法
    'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'functionBind', 'nullishCoalescingOperator', 'objectRestSpread', 'optionalChaining', 'decorators-legacy'].filter(Boolean)
  });
  let valid = false;
  let identifierName = '';
  traverse.default(ast, {
    enter(p) {
      if (p.isExportDefaultDeclaration()) {
        const type = p.node.declaration.type;

        try {
          if (type === 'ArrowFunctionExpression' || type === 'FunctionDeclaration') {
            valid = true;
          } else if (type === 'Identifier') {
            identifierName = p.node.declaration.name;
          }
        } catch (e) {
          console.error(e);
        }
      }
    }

  });

  try {
    if (identifierName) {
      ast.program.body.forEach(ele => {
        if (ele.type === 'FunctionDeclaration') {
          var _ele$id;

          if (((_ele$id = ele.id) === null || _ele$id === void 0 ? void 0 : _ele$id.name) === identifierName) {
            valid = true;
          }
        }

        if (ele.type === 'VariableDeclaration') {
          if (ele.declarations[0].id.name === identifierName && ele.declarations[0].init.type === 'ArrowFunctionExpression') {
            valid = true;
          }
        }
      });
    }
  } catch (e) {
    valid = false;
  }

  return valid;
};

exports.isValidHook = isValidHook;

const getValidFiles = (files, modelsDir) => files.map(file => {
  const filePath = _path().default.join(modelsDir, file);

  const valid = isValidHook(filePath);

  if (valid) {
    return filePath;
  }

  return '';
}).filter(ele => !!ele);

exports.getValidFiles = getValidFiles;