async function scanDirs() {
  if (dirs?.length) {
    // 调用完此函数后会将解析的import规则全部放入ctx.dynamicImports中
    await unimport.modifyDynamicImports(async (imports) => {
      const exports_ = await scanDirExports(dirs, {
        filePatterns: ['*.{tsx,jsx,ts,js,mjs,cjs,mts,cts}'],
      }) as ImportExtended[]

      exports_.forEach(i => i.__source = 'dir')
      return modifyDefaultExportsAlias([
        ...imports.filter((i: ImportExtended) => i.__source !== 'dir'),
        ...exports_,
      ], options)
    })
  }
  writeConfigFilesThrottled()
}

async function modifyDynamicImports (fn: (imports: Import[]) => Thenable<void | Import[]>) {
  const result = await fn(ctx.dynamicImports)
  if (Array.isArray(result)) {
    ctx.dynamicImports = result
  }
  ctx.invalidate()
}

export async function scanDirExports (dir: string | string[], options?: ScanDirExportsOptions) {
  const files = await scanFilesFromDir(dir, options)
  const fileExports = await Promise.all(files.map(i => scanExports(i)))
  return fileExports.flat()
}

export async function scanFilesFromDir (dir: string | string[], options?: ScanDirExportsOptions) {
  const dirs = (Array.isArray(dir) ? dir : [dir]).map(d => normalize(d))

  const fileFilter = options?.fileFilter || (() => true)
  const filePatterns = options?.filePatterns || ['*.{ts,js,mjs,cjs,mts,cts}']

  const result = await Promise.all(
    // Do multiple glob searches to persist the order of input dirs
    dirs.map(async i => await fg(
      // 扫描的路径
      [i, ...filePatterns.map(p => join(i, p))],
      {
        absolute: true, // 以绝对路径返回
        cwd: options?.cwd || process.cwd(), // 当前工作路径
        onlyFiles: true, // 只会返回扫描的文件，忽略文件夹
        followSymbolicLinks: true // 这个配置不是很清楚作用 :(
      })
      .then(r => r
        .map(f => normalize(f))
        .sort()
      )
    )
  )

  return Array.from(new Set(result.flat())).filter(fileFilter)
}

export async function scanExports (filepath: string, seen = new Set<string>()): Promise<Import[]> {
  if (seen.has(filepath)) {
    // eslint-disable-next-line no-console
    console.warn(`[unimport] "${filepath}" is already scanned, skipping`)
    return []
  }

  seen.add(filepath)
  const imports: Import[] = []
  const code = await readFile(filepath, 'utf-8')
  const exports = findExports(code)
  const defaultExport = exports.find(i => i.type === 'default')

  if (defaultExport) {
    let name = parsePath(filepath).name
    if (name === 'index') {
      name = parsePath(filepath.split('/').slice(0, -1).join('/')).name
    }
    // Only camel-case name if it contains separators by which scule would split,
    // see STR_SPLITTERS: https://github.com/unjs/scule/blob/main/src/index.ts
    const as = /[-_.]/.test(name) ? camelCase(name) : name
    imports.push({ name: 'default', as, from: filepath })
  }

  for (const exp of exports) {
    if (exp.type === 'named') {
      for (const name of exp.names) {
        imports.push({ name, as: name, from: filepath })
      }
    } else if (exp.type === 'declaration') {
      if (exp.name) {
        imports.push({ name: exp.name, as: exp.name, from: filepath })
      }
    } else if (exp.type === 'star' && exp.specifier) {
      if (exp.name) {
        // export * as foo from './foo'
        imports.push({ name: exp.name, as: exp.name, from: filepath })
      } else {
        // export * from './foo', scan deeper
        const subfile = exp.specifier
        let subfilepath = resolve(dirname(filepath), subfile)

        if (!extname(subfilepath)) {
          for (const ext of FileExtensionLookup) {
            if (existsSync(`${subfilepath}${ext}`)) {
              subfilepath = `${subfilepath}${ext}`
              break
            } else if (existsSync(`${subfilepath}/index${ext}`)) {
              subfilepath = `${subfilepath}/index${ext}`
              break
            }
          }
        }

        if (!existsSync(subfilepath)) {
          // eslint-disable-next-line no-console
          console.warn(`[unimport] failed to resolve "${subfilepath}", skip scanning`)
          continue
        }

        imports.push(...await scanExports(subfilepath, seen))
      }
    }
  }

  return imports
}

function modifyDefaultExportsAlias(imports: ImportExtended[], options: Options): Import[] {
  if (options.defaultExportByFilename) {
    imports.forEach((i) => {
      if (i.name === 'default')
        i.as = i.from.split('/').pop()?.split('.')?.shift() ?? i.as
    })
  }

  return imports as Import[]
}

let lastDTS: string | undefined
let lastESLint: string | undefined
async function writeConfigFiles() {
  const promises: any[] = []
  if (dts) {
    promises.push(
      generateDTS(dts).then((content) => {
        if (content !== lastDTS) {
          lastDTS = content
          return writeFile(dts, content)
        }
      }),
    )
  }
  if (eslintrc.enabled && eslintrc.filepath) {
    promises.push(
      generateESLint().then((content) => {
        content = `${content}\n`
        if (content.trim() !== lastESLint?.trim()) {
          lastESLint = content
          return writeFile(eslintrc.filepath!, content)
        }
      }),
    )
  }
  return Promise.all(promises)
}

async function generateDTS(file: string) {
  await importsPromise
  const dir = dirname(file)
  const originalContent = existsSync(file) ? await fs.readFile(file, 'utf-8') : ''
  const originalDTS = parseDTS(originalContent)
  const currentContent = await unimport.generateTypeDeclarations({
    resolvePath: (i) => {
      if (i.from.startsWith('.') || isAbsolute(i.from)) {
        const related = slash(relative(dir, i.from).replace(/\.ts(x)?$/, ''))
        return !related.startsWith('.')
                ? `./${related}`
                : related
      }
      return i.from
    },
  })
  const currentDTS = parseDTS(currentContent)!
  if (originalDTS) {
    Object.keys(currentDTS).forEach((key) => {
      originalDTS[key] = currentDTS[key]
    })
    const dtsList = Object.keys(originalDTS).sort().map(k => `  ${k}: ${originalDTS[k]}`)
    return currentContent.replace(dtsReg, () => `declare global {\n${dtsList.join('\n')}\n}`)
  }

  return currentContent
}

const importsPromise = flattenImports(options.imports)
  .then((imports) => {
    if (!imports.length && !resolvers.length && !dirs?.length)
      console.warn('[auto-import] plugin installed but no imports has defined, see https://github.com/antfu/unplugin-auto-import#configurations for configurations')

    options.ignore?.forEach((name) => {
      const i = imports.find(i => i.as === name)
      if (i)
        i.disabled = true
    })

    return unimport.getInternalContext().replaceImports(imports)
  })

export async function flattenImports (map: Options['imports']): Promise<Import[]> {
  const promises = await Promise.all(toArray(map)
          .map(async (definition) => {
            if (typeof definition === 'string') {
              if (!presets[definition])
                throw new Error(`[auto-import] preset ${ definition } not found`)
              const preset = presets[definition]
              definition = typeof preset === 'function' ? preset() : preset
            }
            if ('from' in definition && 'imports' in definition) {
              return await resolvePreset(definition as InlinePreset)
            } else {
              const resolved: Import[] = []
              for (const mod of Object.keys(definition)) {
                for (const id of definition[mod]) {
                  const meta = {
                    from: mod
                  } as Import
                  if (Array.isArray(id)) {
                    meta.name = id[0]
                    meta.as = id[1]
                  } else {
                    meta.name = id
                    meta.as = id
                  }
                  resolved.push(meta)
                }
              }
              return resolved
            }
          }))

  return promises.flat()
}

async function replaceImports (imports: UnimportOptions['imports']) {
  ctx.staticImports = [ ...(imports || []) ].filter(Boolean)
  ctx.invalidate()
  await resolvePromise
  return updateImports()
}

const multilineCommentsRE = /\/\*.*?\*\//gms
const singlelineCommentsRE = /\/\/.*$/gm
const dtsReg = /declare\s+global\s*{(.*?)}/s
function parseDTS(dts: string) {
  dts = dts
          .replace(multilineCommentsRE, '')
          .replace(singlelineCommentsRE, '')
  const code = dts.match(dtsReg)?.[0]
  if (!code)
    return
  return Object.fromEntries(Array.from(code.matchAll(/['"]?(const\s*[^\s'"]+)['"]?\s*:\s*(.+?)[,;\r\n]/g)).map(i => [i[1], i[2]]))
}

async function generateTypeDeclarations (options?: TypeDeclarationOptions) {
  const opts: TypeDeclarationOptions = {
    resolvePath: i => i.from,
    ...options
  }
  const {
    typeReExports = true
  } = opts
  // 获取储存的依赖数据
  const imports = await ctx.getImports()
  let dts = toTypeDeclarationFile(imports.filter(i => !i.type), opts)
  const typeOnly = imports.filter(i => i.type)
  if (typeReExports && typeOnly.length) {
    dts += '\n' + toTypeReExports(typeOnly, opts)
  }
  for (const addon of ctx.addons) {
    dts = await addon.declaration?.call(ctx, dts, opts) ?? dts
  }
  return dts
}

async function parseESLint() {
  const configStr = existsSync(eslintrc.filepath!) ? await fs.readFile(eslintrc.filepath!, 'utf-8') : ''
  const config = JSON.parse(configStr || '{ "globals": {} }')
  return config.globals as Record<string, ESLintGlobalsPropValue>
}

async function generateESLint () {
  return generateESLintConfigs(await unimport.getImports(), eslintrc, await parseESLint())
}

export function generateESLintConfigs(
        imports: Import[],
        eslintrc: ESLintrc,
        globals: Record<string, ESLintGlobalsPropValue> = {},
) {
  const eslintConfigs = { globals }

  imports
          .map(i => i.as ?? i.name)
          .filter(Boolean)
          .sort()
          .forEach((name) => {
            eslintConfigs.globals[name] = eslintrc.globalsPropValue || true
          })
  const jsonBody = JSON.stringify(eslintConfigs, null, 2)
  return jsonBody
}