import { greet } from './utils'
const message = greet() // 隠れany
function hello() {
  const message = greet() // 隠れany
}

~/g/typescript-anycop ❯❯❯ tree -L 1
├── app
└── lib

$ ts-node src/index.ts
--------------------
totalVarDeclCount: 2
totalAnyDeclCount: 2
coverage: 0
--------------------
/~/app/src/index.ts:3 👮‍♂️ < 御用だ！
/~/app/src/index.ts:6 👮‍♂️ < 御用だ！
--------------------

/~/lib/src/index.ts:36
        throw message;
        ^
こちらany警察👮‍♂️！2件のanyをタイーホしました。

const checker: ts.TypeChecker = program.getTypeChecker()
const { flags } = checker.getTypeAtLocation(node)
if (flags === ts.TypeFlags.Any) {
  // 「node: ts.VariableDeclaration」 の TypeFlags が
  // ts.TypeFlags.Any と一致した場合の処理
}

import * as ts from 'typescript'
import * as path from 'path'
import { removeUndefined } from './arrayFilters'
import { createProgram } from './createProgram'
import { getAllAnyDiagnostics } from './getAllAnyDiagnostics'
import { log } from './log'
// ______________________________________________________
//
// 対象となるプロジェクトのパス
const srcDir = path.resolve('../app')
const program: ts.Program = createProgram(srcDir)
const checker: ts.TypeChecker = program.getTypeChecker()

// ts.Program から ts.SourceFile[] を捻出
const sources: ts.SourceFile[] = program
  .getRootFileNames()
  .map(fileName => program.getSourceFile(fileName))
  .filter(removeUndefined)

if (sources.length) {
  const diagnostics = getAllAnyDiagnostics(checker, sources)
  if (diagnostics.coverage !== 1) {
    // 少しでも any があればログ出力する
    log(diagnostics)
  }
}

import * as ts from 'typescript'
import { createConfigFileHost } from './createConfigFileHost'
// ______________________________________________________
//
export function createProgram(
  searchPath: string,
  configName = 'tsconfig.json'
) {
  // 調べる対象になるプロジェクトディレクトリから tsconfig を探す
  const configPath = ts.findConfigFile(
    searchPath,
    ts.sys.fileExists,
    configName
  )
  if (!configPath) {
    throw new Error("Could not find 'tsconfig.json'.")
  }
  // 見つけた tsconfig を元に
  // ts.ParsedCommandLine を取得
  const parsedCommandLine = ts.getParsedCommandLineOfConfigFile(
    configPath,
    {},
    createConfigFileHost()
  )
  if (!parsedCommandLine) {
    throw new Error('invalid parsedCommandLine.')
  }
  if (parsedCommandLine.errors.length) {
    throw new Error('parsedCommandLine has errors.')
  }
  // ts.Program を作成
  return ts.createProgram({
    rootNames: parsedCommandLine.fileNames,
    options: parsedCommandLine.options
  })
}

export function getAllAnyDiagnostics(
  checker: ts.TypeChecker,
  sources: readonly ts.SourceFile[]
) {
  let totalVarDeclCount = 0
  let totalAnyDeclCount = 0
  let allDiagnostics: string[][] = []
  sources.forEach(source => {
    const {
      srcDiagnostics, // string[]
      srcVarDeclCount // number
    } = getSourceAnyDiagnostics(checker, source)
    // 得られたany診断メッセージ配列
    allDiagnostics.push(srcDiagnostics)
    // src に書かれている変数を加算
    totalVarDeclCount += srcVarDeclCount
  })
  let _allDiagnostics = allDiagnostics.flat()
  // 得られたany診断メッセージ数
  totalAnyDeclCount = _allDiagnostics.length
  // ログ出力用のメッセージを整形
  const errorMessage = totalAnyDeclCount
    ? _allDiagnostics.reduce((a, b) => `${a}\n${b}`)
    : null
  // 全変数推論の非anyカバレッジを0〜1で表す
  const coverage = totalVarDeclCount
    ? 1 - totalAnyDeclCount / totalVarDeclCount
    : 1
  return {
    totalVarDeclCount,
    totalAnyDeclCount,
    allDiagnostics: _allDiagnostics,
    errorMessage,
    coverage
  }
}

function getSourceAnyDiagnostics(
  checker: ts.TypeChecker,
  source: ts.SourceFile
) {
  let srcVarDeclCount = 0
  let srcDiagnostics: string[][] = []
  function visit(node: ts.Node) {
    const { diagnostics, varDeclCount } = getAnyDiagnostics(
      checker,
      source,
      node
    )
    // 収集した any診断を追加
    srcDiagnostics.push(diagnostics)
    // ファイル内変数宣言数を加算
    srcVarDeclCount += varDeclCount
    // visit関数の再帰呼び出し
    ts.forEachChild(node, visit)
  }
  // ts.SourceFile を起点に実行
  visit(source)
  return {
    srcDiagnostics: srcDiagnostics.flat(),
    srcVarDeclCount
  }
}

function getAnyDiagnostics(
  checker: ts.TypeChecker,
  source: ts.SourceFile,
  node: ts.Node
) {
  let varDeclCount = 0
  let diagnostics: string[] = []
  if (ts.isVariableDeclarationList(node)) {
    ts.forEachChild(node, child => {
      // 変数宣言であれば
      if (ts.isVariableDeclaration(child)) {
        // 変数宣言数をインクリメント
        varDeclCount++
        try {
          // ts.TypeChecker を利用し
          // ts.Node(child) に推論されている型を調べる
          const { flags } = checker.getTypeAtLocation(child)
          // ts.TypeFlags は enum
          if (flags === ts.TypeFlags.Any) {
            const start = node.getStart()
            const {
              line // any が見つかった行
            } = source.getLineAndCharacterOfPosition(start)
            const location = `${source.fileName}:${line + 1}`
            const message = `👮‍♂️ < 御用だ！`
            // ログ出力用の文字列
            const diagnostic = `${location} ${message}`
            diagnostics.push(diagnostic)
          }
        } catch (err) {
          // TODO: checker.getTypeAtLocation(child) で以下エラーがでる Node がある
          // TypeError: Cannot read property 'flags' of undefined
        }
      }
    })
  }
  return {
    diagnostics,
    varDeclCount
  }
}