const fs = require('fs')
const path = require('path')

const ROOT = path.resolve(__dirname, '..')
const DOCS_DIR = path.join(ROOT, 'docs')
const OUT_FILE = path.join(DOCS_DIR, 'wc-spc-knowledge-base.json')

function ensureDir(dir) {
  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
}

function walk(dir, predicate, result) {
  result = result || []
  if (!fs.existsSync(dir)) return result
  fs.readdirSync(dir, { withFileTypes: true }).forEach(entry => {
    const fullPath = path.join(dir, entry.name)
    if (entry.isDirectory()) {
      if (entry.name === 'node_modules' || entry.name === 'dist') return
      walk(fullPath, predicate, result)
    } else if (!predicate || predicate(fullPath)) {
      result.push(fullPath)
    }
  })
  return result
}

function readText(file) {
  try {
    return fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '')
  } catch (error) {
    return ''
  }
}

function rel(file) {
  return path.relative(ROOT, file).replace(/\//g, '\\')
}

function lineNumber(text, index) {
  return text.slice(0, index).split(/\r?\n/).length
}

function csvEscape(value) {
  const text = String(value == null ? '' : value)
  return '"' + text.replace(/"/g, '""') + '"'
}

function writeCsv(file, headers, rows) {
  const body = [headers.map(csvEscape).join(',')]
  rows.forEach(row => {
    body.push(headers.map(header => csvEscape(row[header])).join(','))
  })
  fs.writeFileSync(path.join(DOCS_DIR, file), body.join('\n'), 'utf8')
}

function unique(values) {
  return Array.from(new Set(values.filter(Boolean)))
}

function normalizeSlash(value) {
  return String(value || '').replace(/\//g, '\\')
}

function moduleFromView(view) {
  const match = normalizeSlash(view).match(/^src\\views\\([^\\]+)/)
  return match ? match[1] : ''
}

function viewToRoutePath(view) {
  const normalized = normalizeSlash(view)
  const match = normalized.match(/^src\\views\\(.+)\\index\.vue$/i)
  if (!match) return ''
  return '/' + match[1].replace(/\\/g, '/')
}

function displayTitleFromView(view) {
  const normalized = normalizeSlash(view)
  const match = normalized.match(/^src\\views\\(.+?)\\index\.vue$/i)
  if (!match) return normalized.replace(/^src\\views\\/, '').replace(/\\/g, ' / ')
  return match[1].replace(/\\/g, ' / ')
}

function keywordsFromText(text) {
  const raw = String(text || '')
    .replace(/[^\w\u4e00-\u9fa5]+/g, ' ')
    .split(/\s+/)
    .map(item => item.trim())
    .filter(item => item && item.length > 1)
  const grams = []
  raw.forEach(item => {
    if (/[\u4e00-\u9fa5]/.test(item) && item.length > 2) {
      for (let size = 2; size <= Math.min(4, item.length); size++) {
        for (let index = 0; index <= item.length - size; index++) {
          grams.push(item.substr(index, size))
        }
      }
    }
  })
  return unique(raw.concat(grams)).slice(0, 120)
}

function inferAction(name) {
  const text = String(name || '')
  if (/删除|delete/i.test(text)) return '删除'
  if (/修改|编辑|更新|update/i.test(text)) return '修改'
  if (/增加|新增|添加|insert|add/i.test(text)) return '增加'
  if (/导入|上传|upload/i.test(text)) return '导入'
  if (/导出|下载|download|excel/i.test(text)) return '导出'
  if (/select|查询|获取|列表|综合|分页|统计|明细|检索/i.test(text)) return '查询'
  return ''
}

function isQueryAction(action, type, name) {
  if (/删除|修改|增加|导入|上传|提交|审核|执行|启用|禁用/.test(action)) return false
  if (/^\s*select\b/i.test(String(name || ''))) return true
  return action === '查询' || type === '11' || type === '2001' || type === '3'
}

function inferDomain(name, fallback) {
  const text = String(name || '')
  if (text.indexOf('_') > -1) return text.split('_')[0]
  if (text.indexOf('SPC') > -1) return 'SPC分析'
  if (text.indexOf('质量') > -1) return '质量管理'
  return fallback || ''
}

function extractTables(sql) {
  const tables = []
  const re = /\b(?:from|join)\s+((?:\[?[A-Za-z0-9_\u4e00-\u9fa5]+\]?\.)?\[?[A-Za-z0-9_\u4e00-\u9fa5]+\]?)/gi
  let match
  while ((match = re.exec(String(sql || '')))) {
    tables.push(match[1].replace(/\[/g, '').replace(/\]/g, ''))
  }
  return unique(tables)
}

function inferObjectFromName(name) {
  const value = String(name || '').trim()
  if (!value || /^\s*select\b/i.test(value)) return ''
  return value
    .replace(/_查询数据.*$/, '')
    .replace(/_查询.*$/, '')
    .replace(/_分页.*$/, '')
    .replace(/_列表.*$/, '')
    .replace(/_综合.*$/, '')
    .replace(/_统计.*$/, '')
    .replace(/_增加.*$/, '')
    .replace(/_修改.*$/, '')
    .replace(/_删除.*$/, '')
}

function extractApiMappings() {
  const apiRoots = [
    path.join(ROOT, 'src', 'api'),
    path.join(ROOT, 'src', 'assets', 'img', 'api')
  ]
  const rows = []
  apiRoots.forEach(root => {
    walk(root, file => /\.js$/i.test(file)).forEach(file => {
      const text = readText(file)
      const relative = rel(file)
      const endpointMatches = []
      const endpointRe = /['"`]([^'"`]*\/submit\/([^'"`?]+\.ashx)\?type=([^'"`&]+)[^'"`]*)['"`]/gi
      let endpointMatch
      while ((endpointMatch = endpointRe.exec(text))) {
        endpointMatches.push({
          line: lineNumber(text, endpointMatch.index),
          endpoint: endpointMatch[2],
          type: endpointMatch[3],
          url: endpointMatch[1]
        })
      }
      const functionRe = /export\s+function\s+([A-Za-z0-9_$\u4e00-\u9fa5]+)\s*\(([^)]*)\)/g
      let fnMatch
      while ((fnMatch = functionRe.exec(text))) {
        const line = lineNumber(text, fnMatch.index)
        const nearest = endpointMatches
          .map(item => Object.assign({ distance: Math.abs(item.line - line) }, item))
          .sort((a, b) => a.distance - b.distance)[0]
        const action = inferAction((nearest && nearest.type) || fnMatch[1])
        rows.push({
          ApiFile: relative,
          Line: line,
          FunctionName: fnMatch[1],
          Params: fnMatch[2].replace(/\s+/g, ' '),
          Endpoint: nearest ? nearest.endpoint : '',
          Type: nearest ? nearest.type : '',
          Action: action,
          Domain: inferDomain((nearest && nearest.endpoint) || relative, moduleFromView(relative)),
          ApiNameOrSql: nearest ? nearest.type : fnMatch[1],
          InferredObject: inferObjectFromName((nearest && nearest.type) || fnMatch[1]),
          ParamExpression: fnMatch[2].replace(/\s+/g, ' ')
        })
      }
    })
  })
  return rows
}

function extractViewCalls() {
  const rows = []
  const imports = []
  walk(path.join(ROOT, 'src', 'views'), file => /\.vue$/i.test(file)).forEach(file => {
    const text = readText(file)
    const relative = rel(file)
    const moduleName = moduleFromView(relative)
    const importRe = /from\s+['"]@\/(api\/[^'"]+)['"]/g
    let importMatch
    while ((importMatch = importRe.exec(text))) {
      imports.push({
        View: relative,
        ApiFile: ('src\\' + importMatch[1]).replace(/\//g, '\\'),
        Line: lineNumber(text, importMatch.index)
      })
    }
    const createDataRe = /CreateData\s*\(\s*['"]([^'"]*)['"]\s*,\s*(['"`])([\s\S]*?)\2/g
    let match
    while ((match = createDataRe.exec(text))) {
      const name = match[3].replace(/\s+/g, ' ').trim()
      const action = inferAction(name)
      rows.push({
        View: relative,
        ViewModule: moduleName,
        RoutePath: viewToRoutePath(relative),
        Line: lineNumber(text, match.index),
        Source: 'CreateData',
        Type: match[1],
        Action: action,
        Domain: inferDomain(name, moduleName),
        NameOrSql: name,
        Queryable: isQueryAction(action, match[1], name)
      })
    }
    const rawSqlRe = /(['"`])\s*(select\s+[\s\S]{10,}?)\1/gi
    while ((match = rawSqlRe.exec(text))) {
      const sql = match[2].replace(/\s+/g, ' ').trim()
      if (!/\bfrom\b/i.test(sql)) continue
      rows.push({
        View: relative,
        ViewModule: moduleName,
        RoutePath: viewToRoutePath(relative),
        Line: lineNumber(text, match.index),
        Source: 'RawSQL',
        Type: '3',
        Action: '查询',
        Domain: 'RawSQL',
        NameOrSql: sql,
        Queryable: true
      })
    }
  })
  return { rows, imports }
}

function buildSpcMappings(apiMappings, viewCalls) {
  const known = [
    { chartType: 'basicTrend', title: '基本趋势图', apiFile: 'src\\api\\SPCanalysis\\basicTrendTap.js', endpoint: 'QualityData_TrendPictureBasic.ashx' },
    { chartType: 'sampleTrend', title: '样本趋势图', apiFile: 'src\\api\\SPCanalysis\\sampleTrendChart.js', endpoint: 'QualityData_TrendPicture.ashx' },
    { chartType: 'histogram', title: '直方图', apiFile: 'src\\api\\SPCanalysis\\histogram.js', endpoint: 'QualityData_Histogram.ashx' },
    { chartType: 'normalDistribution', title: '正态分布图', apiFile: 'src\\api\\SPCanalysis\\normal_distribution.js', endpoint: 'QualityData_NormalDistribution.ashx' },
    { chartType: 'processCapability', title: '过程能力分析', apiFile: 'src\\api\\SPCanalysis\\processCapabilityAnalysis.js', endpoint: 'QualityData_NormalDistribution.ashx' },
    { chartType: 'pareto', title: '排列图', apiFile: 'src\\api\\SPCanalysis\\arrangeChart.js', endpoint: 'QualityData_Pareto.ashx' },
    { chartType: 'xr', title: 'X-R 控制图', apiFile: 'src\\api\\SPCanalysis\\QualityData_XR.js', endpoint: 'QualityData_XR.ashx' },
    { chartType: 'xs', title: 'X-S 控制图', apiFile: 'src\\api\\SPCanalysis\\QualityData_XS.js', endpoint: 'QualityData_XS.ashx' }
  ]
  return known.map(item => {
    const apiRows = apiMappings.filter(row => normalizeSlash(row.ApiFile) === item.apiFile)
    const views = unique(viewCalls.filter(row => normalizeSlash(row.View).indexOf('SearchData') > -1 && row.NameOrSql.indexOf('SPC') > -1).map(row => row.View))
    return Object.assign({}, item, {
      functions: unique(apiRows.map(row => row.FunctionName)).join('|'),
      types: unique(apiRows.map(row => row.Type)).join('|'),
      views: views.join('|')
    })
  })
}

function buildQualityModules(viewCalls) {
  const map = {}
  viewCalls.forEach(row => {
    const text = [row.View, row.Domain, row.NameOrSql].join(' ')
    const quality = /Quality|质量|SPC|Andon|巡检|条码|LineQuality|QualityData/i.test(text)
    if (!quality) return
    if (!map[row.View]) {
      map[row.View] = {
        View: row.View,
        Module: row.ViewModule,
        RoutePath: row.RoutePath,
        Title: displayTitleFromView(row.View),
        Domains: [],
        QueryNames: [],
        Queryable: false
      }
    }
    map[row.View].Domains.push(row.Domain)
    if (row.Queryable) {
      map[row.View].Queryable = true
      map[row.View].QueryNames.push(row.NameOrSql)
    }
  })
  return Object.keys(map).sort().map(key => {
    const item = map[key]
    item.Domains = unique(item.Domains).join('|')
    item.QueryNames = unique(item.QueryNames).join('|')
    return item
  })
}

function main() {
  ensureDir(DOCS_DIR)
  const apiMappings = extractApiMappings()
  const viewData = extractViewCalls()
  const viewCalls = viewData.rows
  const viewImports = viewData.imports
  const summaryMap = {}
  viewCalls.forEach(row => {
    if (!summaryMap[row.View]) {
      summaryMap[row.View] = {
        View: row.View,
        ViewModule: row.ViewModule,
        RoutePath: row.RoutePath,
        Count: 0,
        Domains: [],
        Names: []
      }
    }
    summaryMap[row.View].Count++
    summaryMap[row.View].Domains.push(row.Domain)
    summaryMap[row.View].Names.push(row.NameOrSql)
  })
  const viewSummary = Object.keys(summaryMap).sort().map(key => {
    const item = summaryMap[key]
    item.Domains = unique(item.Domains).join('|')
    item.Names = unique(item.Names).join('|')
    return item
  })
  const rawSqlRows = []
  viewCalls.filter(row => row.Source === 'RawSQL').forEach(row => {
    rawSqlRows.push({
      ApiFile: row.View,
      Line: row.Line,
      Tables: extractTables(row.NameOrSql).join('|'),
      Sql: row.NameOrSql
    })
  })
  const spcMappings = buildSpcMappings(apiMappings, viewCalls)
  const qualityModules = buildQualityModules(viewCalls)
  const modules = viewSummary.map(row => {
    const calls = viewCalls.filter(call => call.View === row.View)
    const primaryQueries = calls.filter(call => call.Queryable).map(call => ({
      kind: call.Source === 'RawSQL' ? 'raw-sql' : 'create-data',
      view: call.View,
      line: Number(call.Line || 0),
      source: call.Source,
      type: call.Type,
      action: call.Action,
      domain: call.Domain,
      nameOrSql: call.NameOrSql,
      queryTables: call.Source === 'RawSQL' ? extractTables(call.NameOrSql) : [inferObjectFromName(call.NameOrSql)].filter(Boolean),
      keywords: keywordsFromText([call.View, call.Domain, call.NameOrSql].join(' '))
    }))
    return {
      module: row.ViewModule,
      view: row.View,
      title: displayTitleFromView(row.View),
      routePath: row.RoutePath,
      callCount: Number(row.Count || calls.length || 0),
      domains: row.Domains ? row.Domains.split('|') : [],
      functionNames: row.Names ? row.Names.split('|') : [],
      calls,
      primaryQueries,
      queryable: primaryQueries.length > 0,
      queryTables: unique(primaryQueries.flatMap(query => query.queryTables || [])),
      qualityRelated: qualityModules.some(item => item.View === row.View),
      keywords: keywordsFromText([row.ViewModule, row.View, row.Domains, row.Names].join(' '))
    }
  })
  const sqlTables = []
  rawSqlRows.forEach(row => {
    row.Tables.split('|').filter(Boolean).forEach(table => {
      sqlTables.push({
        table,
        sourceFile: row.ApiFile,
        line: row.Line,
        sql: row.Sql,
        source: 'raw-sql',
        queryable: true,
        keywords: keywordsFromText([table, row.ApiFile, row.Sql].join(' '))
      })
    })
  })
  modules.forEach(module => {
    module.primaryQueries.forEach(query => {
      ;(query.queryTables || []).forEach(table => {
        if (!table) return
        sqlTables.push({
          table,
          sourceFile: module.view,
          line: query.line,
          sql: query.kind === 'raw-sql' ? query.nameOrSql : '',
          source: query.kind === 'raw-sql' ? 'raw-sql' : 'inferred-object',
          queryable: true,
          keywords: keywordsFromText([table, module.view, query.nameOrSql].join(' '))
        })
      })
    })
  })
  const tableMap = {}
  sqlTables.forEach(item => {
    if (!tableMap[item.table]) tableMap[item.table] = Object.assign({}, item, { references: [] })
    tableMap[item.table].references.push({
      sourceFile: item.sourceFile,
      line: item.line,
      source: item.source,
      sql: item.sql
    })
  })
  const dedupedTables = Object.keys(tableMap).sort().map(key => tableMap[key])
  const knowledgeBase = {
    generatedAt: new Date().toISOString(),
    project: 'WC-SPC MES-Manager_View',
    modules,
    apiMappings: apiMappings.map(row => ({
      apiFile: row.ApiFile,
      line: Number(row.Line || 0),
      functionName: row.FunctionName,
      params: row.Params,
      endpoint: row.Endpoint,
      type: row.Type,
      action: row.Action,
      domain: row.Domain,
      apiNameOrSql: row.ApiNameOrSql,
      inferredObject: row.InferredObject,
      queryable: isQueryAction(row.Action, row.Type, row.ApiNameOrSql),
      keywords: keywordsFromText([row.ApiFile, row.FunctionName, row.Endpoint, row.Type].join(' '))
    })),
    sqlTables: dedupedTables,
    qualityModules,
    spcCharts: spcMappings,
    queryHints: modules.map(item => ({
      kind: 'module',
      key: item.view,
      title: item.title,
      keywords: item.keywords,
      tableCandidates: item.queryTables
    }))
  }
  writeCsv('api-name-mapping.csv', ['ApiFile', 'Line', 'FunctionName', 'Params', 'Endpoint', 'Type', 'Action', 'Domain', 'ApiNameOrSql', 'InferredObject', 'ParamExpression'], apiMappings)
  writeCsv('view-api-imports.csv', ['View', 'ApiFile', 'Line'], viewImports)
  writeCsv('view-database-calls.csv', ['View', 'ViewModule', 'RoutePath', 'Line', 'Source', 'Type', 'Action', 'Domain', 'NameOrSql', 'Queryable'], viewCalls)
  writeCsv('view-database-calls-summary.csv', ['View', 'ViewModule', 'RoutePath', 'Count', 'Domains', 'Names'], viewSummary)
  writeCsv('raw-sql-table-mapping.csv', ['ApiFile', 'Line', 'Tables', 'Sql'], rawSqlRows)
  writeCsv('spc-chart-mapping.csv', ['chartType', 'title', 'apiFile', 'endpoint', 'functions', 'types', 'views'], spcMappings)
  writeCsv('quality-module-mapping.csv', ['View', 'Module', 'RoutePath', 'Title', 'Domains', 'QueryNames', 'Queryable'], qualityModules)
  fs.writeFileSync(OUT_FILE, JSON.stringify(knowledgeBase, null, 2), 'utf8')
  const report = [
    '# WC-SPC 项目静态分析',
    '',
    '生成时间：' + new Date().toLocaleString('zh-CN', { hour12: false }),
    '',
    '## 结论',
    '',
    '- 项目为 Vue 2 + Element UI 前端和 ASP.NET Web Site 后端组合。',
    '- 前端通用业务接口通过 `src/utils/request.js` 调用 `MESCommonBase.ashx`。',
    '- SPC 专项接口位于 `src/api/SPCanalysis`，后端对应 `QualityData_*.ashx`。',
    '- 本文件由 `mcp-server/build-knowledge-base.js` 自动生成，用于 AI MCP 服务。',
    '',
    '## 统计',
    '',
    '| 项目 | 数量 |',
    '| --- | ---: |',
    '| 页面查询调用 | ' + viewCalls.length + ' |',
    '| 页面汇总 | ' + viewSummary.length + ' |',
    '| API 映射 | ' + apiMappings.length + ' |',
    '| Raw SQL | ' + rawSqlRows.length + ' |',
    '| 质量相关模块 | ' + qualityModules.length + ' |',
    '| SPC 图表类型 | ' + spcMappings.length + ' |'
  ].join('\n')
  fs.writeFileSync(path.join(DOCS_DIR, 'wc-spc-static-analysis.md'), report, 'utf8')
  console.log('Knowledge base generated: ' + OUT_FILE)
  console.log('modules=' + modules.length)
  console.log('apiMappings=' + apiMappings.length)
  console.log('qualityModules=' + qualityModules.length)
  console.log('spcCharts=' + spcMappings.length)
}

main()