import { ElMessage } from 'element-plus'
import { computed, inject, type InjectionKey } from 'vue'

import { useConfigDrawer } from '@/composables/useConfigDrawer'
import { useCrawlerController } from '@/composables/useCrawlerController'
import { useReportStudio } from '@/composables/useReportStudio'
import { useResearchWorkspace } from '@/composables/useResearchWorkspace'
import { useSystemController } from '@/composables/useSystemController'
import type {
  AppName,
  CrawlerFormState,
  CrawlerRecoveryActionKey,
  ResearchTaskDraft,
} from '@/types'
import { statusTone } from '@/utils/format'

export type CardTone = 'neutral' | 'success' | 'running' | 'danger'

export interface WorkbenchMetric {
  label: string
  value: string
  detail: string
  tone: CardTone
}

function normalizeTone(status: string): CardTone {
  const tone = statusTone(status)
  if (tone === 'success' || tone === 'running' || tone === 'danger') {
    return tone
  }
  return 'neutral'
}

function resolveErrorMessage(error: unknown, fallback: string): string {
  return error instanceof Error ? error.message : fallback
}

function notify(message: string, type: 'success' | 'info' | 'warning' | 'error' = 'info') {
  ElMessage({
    message,
    type,
    duration: 2800,
    showClose: true,
    grouping: true,
  })
}

export function createWorkbenchController() {
  const research = useResearchWorkspace()
  const crawler = useCrawlerController()
  const system = useSystemController()
  const reports = useReportStudio()
  const config = useConfigDrawer()

  let workspaceTimer: number | null = null

  const busy = computed(() => (
    system.actionPending.value
    || crawler.acting.value
    || reports.generating.value
    || config.saving.value
  ))

  const currentReportTask = computed(() => (
    reports.selectedTask.value || reports.status.value.current_task || null
  ))

  const engineOverview = computed(() => (
    system.appCards.value.map((item) => ({
      ...item,
      tone: normalizeTone(item.status),
    }))
  ))

  const crawlerHistory = computed(() => crawler.snapshot.value.storage.history.slice(0, 8))

  const overviewMetrics = computed<WorkbenchMetric[]>(() => {
    const activeVenue = research.activeTask.value?.venue_name || research.draft.venue_name || '待创建场馆'
    const researchDetail = research.activeTask.value
      ? `${research.activeTask.value.city || '待定城市'} · ${research.activeTask.value.research_focus_label}`
      : '先保存研究任务，系统会把它作为采集、分析和报告的统一上下文。'

    const crawlerSnapshot = crawler.snapshot.value
    const crawlerValue = crawlerSnapshot.crawler.platform_label
      || (crawlerSnapshot.login.active_task.running ? '登录处理中' : '待启动')
    const crawlerDetail = crawlerSnapshot.crawler.message
      || crawler.selectedPlatformState.value?.message
      || '尚未启动采集，当前保留最近一次的历史配置。'

    const runningEngines = (['insight', 'media', 'query'] as AppName[]).filter(
      (name) => system.appStatus.value[name]?.status === 'running',
    ).length
    const engineTone: CardTone = system.systemStatus.value.started
      ? (runningEngines === 3 ? 'success' : 'running')
      : 'neutral'

    const reportTone = currentReportTask.value ? normalizeTone(currentReportTask.value.status) : 'neutral'
    const reportValue = currentReportTask.value ? `${currentReportTask.value.progress}%` : '待生成'
    const reportDetail = currentReportTask.value
      ? `${currentReportTask.value.query || '未命名报告任务'} · ${currentReportTask.value.status}`
      : '等待三引擎输出与模板确认，生成后会自动加入历史列表。'

    return [
      {
        label: '当前研究对象',
        value: activeVenue,
        detail: researchDetail,
        tone: research.activeTask.value ? 'success' : 'neutral',
      },
      {
        label: '采集状态',
        value: crawlerValue,
        detail: crawlerDetail,
        tone: normalizeTone(crawlerSnapshot.crawler.status),
      },
      {
        label: '分析引擎',
        value: `${runningEngines}/3 已运行`,
        detail: system.systemStatus.value.started
          ? 'Insight、Media、Query 会持续同步当前研究指令和运行状态。'
          : '先启动系统，再把当前研究指令分发给三引擎。',
        tone: engineTone,
      },
      {
        label: '报告进度',
        value: reportValue,
        detail: reportDetail,
        tone: reportTone,
      },
    ]
  })

  async function runWithNotice<T>(
    action: () => Promise<T>,
    successMessage: string,
    fallbackError = '操作失败',
  ) {
    try {
      const result = await action()
      notify(successMessage, 'success')
      return result
    } catch (error) {
      notify(resolveErrorMessage(error, fallbackError), 'error')
      return undefined
    }
  }

  async function bootWorkspace() {
    await Promise.all([
      research.loadOptions(),
      research.refreshTasks(),
      crawler.loadOptions(),
      crawler.refreshState(),
      system.initialize(),
      reports.refreshStatus(),
    ])
    await Promise.all([
      research.refreshActiveTaskCrawlerResource(),
      research.refreshActiveTaskReportResource(),
    ])
  }

  async function initializeWorkspace() {
    try {
      await bootWorkspace()
    } catch (error) {
      notify(resolveErrorMessage(error, '初始化失败'), 'error')
    }
  }

  async function start() {
    await initializeWorkspace()
    system.startPolling()

    if (workspaceTimer === null) {
      workspaceTimer = window.setInterval(() => {
        void research.refreshActiveTaskCrawlerResource()
        void research.refreshActiveTaskReportResource()
        void crawler.refreshState()
        void reports.refreshTasks()
      }, 4000)
    }
  }

  function stop() {
    system.stopPolling()
    reports.stopPolling()

    if (workspaceTimer !== null) {
      window.clearInterval(workspaceTimer)
      workspaceTimer = null
    }
  }

  async function refreshAll() {
    await runWithNotice(bootWorkspace, '系统状态已刷新', '刷新状态失败')
  }

  async function startSystem() {
    await runWithNotice(async () => {
      await system.startSystem()
      await Promise.allSettled([
        crawler.refreshState(),
        reports.refreshStatus(),
      ])
    }, '系统启动完成', '启动系统失败')
  }

  async function shutdownSystem() {
    await runWithNotice(async () => {
      await system.shutdownSystem()
      await Promise.allSettled([
        system.initialize(),
        crawler.refreshState(),
        reports.refreshStatus(),
      ])
    }, '系统关闭指令已下发', '关闭系统失败')
  }

  async function saveResearchTask() {
    await runWithNotice(async () => {
      const task = await research.saveTask()
      crawler.syncFromResearchTask(task)
      await Promise.all([
        research.refreshActiveTaskCrawlerResource(task.task_id),
        research.refreshActiveTaskReportResource(task.task_id),
      ])
      return task
    }, '场馆研究任务已保存', '保存研究任务失败')
  }

  async function activateResearchTask(taskId: string) {
    await runWithNotice(async () => {
      await research.activateTask(taskId)
      crawler.syncFromResearchTask(research.activeTask.value)
      await Promise.all([
        research.refreshActiveTaskCrawlerResource(taskId),
        research.refreshActiveTaskReportResource(taskId),
      ])
    }, '已切换到目标研究任务', '切换研究任务失败')
  }

  function syncResearchToCrawler() {
    crawler.syncFromResearchTask(research.activeTask.value)
    notify('已按当前研究任务回填爬虫配置', 'success')
  }

  async function runResearch() {
    const query = research.searchQuery.value.trim()
    if (!query) {
      notify('请先填写研究指令，或先保存一条场馆研究任务。', 'warning')
      return
    }

    await runWithNotice(async () => {
      await system.search(query, research.activeTask.value?.task_id ?? '')
      await research.refreshTasks(research.activeTask.value?.task_id ?? '')
      await research.refreshActiveTaskCrawlerResource()
    }, '研究指令已分发到运行中的引擎', '执行研究失败')
  }

  async function checkCrawlerLogin() {
    await runWithNotice(() => crawler.checkLogin(), '平台登录状态已刷新', '检查登录状态失败')
  }

  async function startCrawlerLogin() {
    await runWithNotice(() => crawler.startLogin(), '登录流程已启动', '启动登录流程失败')
  }

  async function cancelCrawlerLogin() {
    await runWithNotice(() => crawler.cancelLogin(), '登录流程已取消', '取消登录流程失败')
  }

  async function startCrawlerTask() {
    await runWithNotice(async () => {
      const taskId = research.activeTask.value?.task_id ?? ''
      await crawler.startCrawler(taskId)
      await Promise.all([
        research.refreshTasks(taskId),
        research.refreshActiveTaskCrawlerResource(taskId),
      ])
    }, '爬虫任务已启动', '启动爬虫任务失败')
  }

  async function stopCrawlerTask() {
    await runWithNotice(async () => {
      const taskId = research.activeTask.value?.task_id ?? ''
      await crawler.stopCrawler()
      await Promise.all([
        research.refreshTasks(taskId),
        research.refreshActiveTaskCrawlerResource(taskId),
      ])
    }, '爬虫任务已停止', '停止爬虫任务失败')
  }

  async function applyCrawlerRecoveryAction(actionKey: CrawlerRecoveryActionKey) {
    switch (actionKey) {
      case 'switch-to-headed':
        crawler.form.headless = false
        notify('已切换到可视化浏览器，更适合扫码和排查登录异常', 'success')
        return
      case 'switch-to-headless':
        crawler.form.headless = true
        notify('已切换到无头浏览器，适合稳定后台执行', 'success')
        return
      case 'switch-to-qrcode':
        crawler.form.login_type = 'qrcode'
        notify('已切换到二维码登录', 'success')
        return
      case 'switch-to-phone':
        crawler.form.login_type = 'phone'
        notify('已切换到手机号登录，请确认验证码链路可用', 'success')
        return
      case 'switch-to-cookie':
        crawler.form.login_type = 'cookie'
        notify('已切换到 Cookie 登录，请补充有效凭据', 'success')
        return
      case 'restore-last-login':
        crawler.restoreLastLoginConfig()
        notify('已恢复最近一次登录方案', 'success')
        return
      case 'check-login':
        await checkCrawlerLogin()
        return
      case 'start-login':
        await startCrawlerLogin()
        return
      case 'cancel-login':
        await cancelCrawlerLogin()
        return
      default:
        return
    }
  }

  async function refreshReports() {
    await runWithNotice(async () => {
      const taskId = research.activeTask.value?.task_id ?? ''
      await Promise.all([
        reports.refreshStatus(),
        taskId ? research.refreshTasks(taskId) : Promise.resolve(),
        taskId ? research.refreshActiveTaskReportResource(taskId) : Promise.resolve(),
      ])
    }, '报告状态已刷新', '刷新报告状态失败')
  }

  async function generateReport() {
    const taskId = research.activeTask.value?.task_id ?? ''
    const query = research.searchQuery.value.trim()
      || research.activeTask.value?.generated_query
      || `${research.activeTask.value?.venue_name || research.draft.venue_name || '场馆'}运营反馈调研报告`

    await runWithNotice(async () => {
      await reports.generate(query, taskId)
      if (!taskId) {
        return
      }

      await Promise.all([
        research.refreshTasks(taskId),
        research.refreshActiveTaskReportResource(taskId),
      ])
    }, '报告任务已启动', '生成报告失败')
  }

  async function loadConfigIfNeeded() {
    if (Object.keys(config.values.value).length > 0) {
      return
    }

    try {
      await config.loadConfig()
    } catch (error) {
      notify(resolveErrorMessage(error, '加载配置失败'), 'error')
    }
  }

  async function refreshConfig() {
    await runWithNotice(() => config.loadConfig(), '配置已刷新', '加载配置失败')
  }

  async function saveConfig() {
    await runWithNotice(() => config.saveConfig(), '配置已保存', '保存配置失败')
  }

  function updateResearchDraft(value: ResearchTaskDraft) {
    Object.assign(research.draft, value)
  }

  function updateSearchQuery(value: string) {
    research.searchQuery.value = value
  }

  function updateCrawlerForm(value: CrawlerFormState) {
    Object.assign(crawler.form, value)
  }

  function updateCrawlerCollapsed(value: boolean) {
    crawler.collapsed.value = value
  }

  function updateActiveApp(value: AppName) {
    system.selectApp(value)
  }

  function updateSelectedReportTask(value: string) {
    reports.selectTask(value)
  }

  function updateCustomTemplate(value: string) {
    reports.customTemplate.value = value
  }

  return {
    research,
    crawler,
    system,
    reports,
    config,
    busy,
    currentReportTask,
    engineOverview,
    crawlerHistory,
    overviewMetrics,
    start,
    stop,
    refreshAll,
    startSystem,
    shutdownSystem,
    saveResearchTask,
    activateResearchTask,
    syncResearchToCrawler,
    runResearch,
    checkCrawlerLogin,
    startCrawlerLogin,
    cancelCrawlerLogin,
    startCrawlerTask,
    stopCrawlerTask,
    applyCrawlerRecoveryAction,
    refreshReports,
    generateReport,
    loadConfigIfNeeded,
    refreshConfig,
    saveConfig,
    updateResearchDraft,
    updateSearchQuery,
    updateCrawlerForm,
    updateCrawlerCollapsed,
    updateActiveApp,
    updateSelectedReportTask,
    updateCustomTemplate,
  }
}

export type WorkbenchController = ReturnType<typeof createWorkbenchController>

export const workbenchControllerKey: InjectionKey<WorkbenchController> = Symbol('workbench-controller')

export function useWorkbenchControllerContext() {
  const controller = inject(workbenchControllerKey)

  if (!controller) {
    throw new Error('Workbench controller has not been provided.')
  }

  return controller
}