import { randomUUID } from 'node:crypto'
import { hostname } from 'node:os'
import type { Session } from 'next-auth'
import mssql, { type ConnectionPool } from 'mssql'
import { assertBrandCenterDashboardAccess } from '@/lib/brand-center-dashboard-access'
import { prisma } from '@/lib/prisma'
import {
  DING_WORKFLOW_ALLOWED_PROCESS_CODES,
  DING_WORKFLOW_STARTED_AT_CUTOFF_ISO,
  getDingWorkflowSyncMetadata,
  isDingWorkflowApprovedCompletion,
} from '@/lib/ding-workflow-sync'
import {
  BUSINESS_TREND_BRANDS,
  addCalendarMonths,
  compareDateKeys,
  daysBetweenInclusive,
  extractValidProductIds,
  isValidDateKey,
  toShanghaiDateKey,
  type PerformanceConversionBrand,
  type PerformanceConversionDailyMetric,
  type PerformanceConversionTimeseries,
  type PerformanceConversionWorkflowItem,
  type PerformanceConversionWorkflowList,
} from '@/components/department-dashboard/performance-conversion'

const ART_PROCESS_CODE = DING_WORKFLOW_ALLOWED_PROCESS_CODES[0]
const VALID_BRANDS = new Set<string>(BUSINESS_TREND_BRANDS)
const DEFAULT_PAGE_SIZE = 20
const MAX_PAGE_SIZE = 50
const SOURCE_CACHE_TTL_MS = 5 * 60 * 1000
const PERFORMANCE_CONVERSION_SYNC_STATE_ID = 'performance-conversion-daily-v1'
const SYNC_LEASE_DURATION_MS = 20 * 60 * 1000
const SYNC_INITIAL_DELAY_MS = 30 * 1000
const SYNC_INTERVAL_MS = 24 * 60 * 60 * 1000
const SYNC_LOOKBACK_DAYS = 2

export class PerformanceConversionError extends Error {
  status: number

  constructor(message: string, status = 400) {
    super(message)
    this.name = 'PerformanceConversionError'
    this.status = status
  }
}

type SnapshotRow = {
  processInstanceId: string
  businessId: string | null
  title: string | null
  result: string | null
  bizAction: string | null
  status: string
  processCode: string | null
  brand: string | null
  sourceFinishedAtRaw: string | null
  formFields: unknown
}

type SourceMetricRow = {
  sourceRowId: string | null
  metricDate: Date | string | null
  productId: string | null
  productName: string | null
  sourceBrand: string | null
  category1: string | null
  category2: string | null
  category3: string | null
  paymentAmount: string | null
  paymentUsers: string | null
  cartUsers: string | null
  visitors: string | null
  conversionRate: string | null
  favorites: string | null
  impressions: string | null
  clicks: string | null
  clickRate: string | null
  promotionSpend: string | null
  promotionRevenue: string | null
  roi: string | null
}

type CachedSourceRows = { expiresAt: number; rows: SourceMetricRow[] }
const sourceCache = new Map<string, CachedSourceRows>()

type PerformanceConversionSourceCursor = {
  version: 1
  lastSourceDate: string | null
}

export type PerformanceConversionSyncStatus = 'pending' | 'syncing' | 'ready' | 'error'

export type PerformanceConversionSyncMetadata = {
  status: PerformanceConversionSyncStatus
  lastCompletedAt: string | null
  lastSourceDate: string | null
}

function clean(value: unknown) {
  const normalized = String(value ?? '').trim()
  return normalized && normalized.toUpperCase() !== 'NULL' && normalized !== '--' ? normalized : null
}

function formRecord(value: unknown): Record<string, unknown> {
  return value && typeof value === 'object' && !Array.isArray(value)
    ? value as Record<string, unknown>
    : {}
}

function workflowItems(row: SnapshotRow): PerformanceConversionWorkflowItem[] {
  const brand = clean(row.brand)
  const completedAt = clean(row.sourceFinishedAtRaw)
  if (!brand || !VALID_BRANDS.has(brand) || !completedAt) return []
  const monitorStartDate = toShanghaiDateKey(completedAt)
  if (!monitorStartDate) return []
  const fields = formRecord(row.formFields)
  const ids = extractValidProductIds(fields.productId, fields.currentProductId)
  const monitorEndDate = addCalendarMonths(monitorStartDate, 6)
  const today = toShanghaiDateKey(new Date()) || monitorStartDate
  return ids.map((productId) => ({
    key: `${row.processInstanceId}:${productId}`,
    workflowId: row.processInstanceId,
    approvalNumber: clean(row.businessId),
    processCode: clean(row.processCode) || ART_PROCESS_CODE,
    title: clean(row.title) || '未命名流程',
    brand: brand as PerformanceConversionBrand,
    productId,
    spu: clean(fields.spu),
    platform: clean(fields.platform),
    completedAt,
    monitorStartDate,
    monitorEndDate,
    monitoringStatus: compareDateKeys(today, monitorEndDate) <= 0 ? 'monitoring' : 'complete',
  }))
}

function isEligibleSnapshot(row: SnapshotRow) {
  return row.processCode === ART_PROCESS_CODE
    && Boolean(row.sourceFinishedAtRaw)
    && isDingWorkflowApprovedCompletion(row.status, row.result, row.bizAction)
}

async function readEligibleSnapshots(): Promise<SnapshotRow[]> {
  const rows = await prisma.dingWorkflowSnapshot.findMany({
    where: {
      processCode: ART_PROCESS_CODE,
      sourceCreatedAtRaw: { gte: DING_WORKFLOW_STARTED_AT_CUTOFF_ISO },
      sourceFinishedAtRaw: { not: null },
    },
    select: {
      processInstanceId: true,
      businessId: true,
      title: true,
      result: true,
      bizAction: true,
      status: true,
      processCode: true,
      brand: true,
      sourceFinishedAtRaw: true,
      formFields: true,
    },
    orderBy: [
      { sourceFinishedAtRaw: 'desc' },
      { processInstanceId: 'desc' },
    ],
  })
  return rows.filter(isEligibleSnapshot)
}

export async function getPerformanceConversionWorkflows(
  session: Session | null,
  input: {
    brand?: string | null
    page?: number
    pageSize?: number
    query?: string | null
    completedFrom?: string | null
    completedTo?: string | null
  } = {},
): Promise<PerformanceConversionWorkflowList> {
  await assertBrandCenterDashboardAccess(session)
  const brand = clean(input.brand) || BUSINESS_TREND_BRANDS[0]
  if (!VALID_BRANDS.has(brand)) throw new PerformanceConversionError('品牌参数无效')
  const page = Math.max(1, Math.floor(Number(input.page) || 1))
  const pageSize = Math.max(1, Math.min(MAX_PAGE_SIZE, Math.floor(Number(input.pageSize) || DEFAULT_PAGE_SIZE)))
  const query = clean(input.query)?.toLocaleLowerCase('zh-CN') || ''
  const completedFrom = clean(input.completedFrom)
  const completedTo = clean(input.completedTo)
  if (completedFrom && !isValidDateKey(completedFrom)) throw new PerformanceConversionError('完结开始日期格式无效')
  if (completedTo && !isValidDateKey(completedTo)) throw new PerformanceConversionError('完结结束日期格式无效')
  if (completedFrom && completedTo && compareDateKeys(completedFrom, completedTo) > 0) {
    throw new PerformanceConversionError('完结开始日期不能晚于结束日期')
  }
  const [snapshots, workflowSync, performanceSync] = await Promise.all([
    readEligibleSnapshots(),
    getDingWorkflowSyncMetadata(),
    getPerformanceConversionSyncMetadata(),
  ])
  const rangeSnapshots = snapshots.filter((row) => {
    const completedDate = row.sourceFinishedAtRaw ? toShanghaiDateKey(row.sourceFinishedAtRaw) : null
    if (!completedDate) return false
    return (!completedFrom || compareDateKeys(completedDate, completedFrom) >= 0)
      && (!completedTo || compareDateKeys(completedDate, completedTo) <= 0)
  })
  const allItems = rangeSnapshots.flatMap(workflowItems)
  const brandCounts = new Map<PerformanceConversionBrand, number>(
    BUSINESS_TREND_BRANDS.map((item) => [item, 0]),
  )
  allItems.forEach((item) => brandCounts.set(item.brand, (brandCounts.get(item.brand) || 0) + 1))

  const brandSnapshots = rangeSnapshots.filter((row) => row.brand === brand)
  const invalidProductIdCount = brandSnapshots.filter((row) => workflowItems(row).length === 0).length
  const filtered = allItems.filter((item) => item.brand === brand && (!query || [
    item.productId,
    item.spu,
    item.approvalNumber,
    item.workflowId,
    item.title,
  ].some((value) => String(value || '').toLocaleLowerCase('zh-CN').includes(query))))
  const offset = (page - 1) * pageSize
  return {
    brands: BUSINESS_TREND_BRANDS.map((item) => ({ brand: item, count: brandCounts.get(item) || 0 })),
    items: filtered.slice(offset, offset + pageSize),
    total: filtered.length,
    invalidProductIdCount,
    page,
    pageSize,
    hasMore: offset + pageSize < filtered.length,
    workflowSync,
    performanceSync,
  }
}

function sourceDbConfigured() {
  return Boolean(
    process.env.REPORT_DB_SERVER
      && process.env.REPORT_DB_DATABASE
      && process.env.REPORT_DB_USER
      && process.env.REPORT_DB_PASSWORD,
  )
}

function sourceConfig() {
  if (!sourceDbConfigured()) throw new PerformanceConversionError('经营数据源尚未配置', 503)
  return {
    server: process.env.REPORT_DB_SERVER as string,
    database: process.env.REPORT_DB_DATABASE as string,
    user: process.env.REPORT_DB_USER as string,
    password: process.env.REPORT_DB_PASSWORD as string,
    port: Number(process.env.REPORT_DB_PORT || 1433),
    options: {
      encrypt: process.env.REPORT_DB_ENCRYPT === 'true',
      trustServerCertificate: process.env.REPORT_DB_TRUST_SERVER_CERTIFICATE !== 'false',
      enableArithAbort: true,
    },
    connectionTimeout: 15_000,
    requestTimeout: 60_000,
    pool: { max: 4, min: 0, idleTimeoutMillis: 10_000 },
  }
}

async function fetchSourceRows(pool: ConnectionPool, productId: string, startDate: string, endDate: string) {
  const result = await pool.request()
      .input('productId', mssql.NVarChar(255), productId)
      .input('startDate', mssql.NVarChar(10), startDate)
      .input('endDate', mssql.NVarChar(10), endDate)
      .query<SourceMetricRow>(`
        SELECT TOP (5000)
          CONVERT(nvarchar(255), [RowId]) AS sourceRowId,
          [统计日期] AS metricDate,
          CONVERT(nvarchar(255), [商品ID]) AS productId,
          CONVERT(nvarchar(2000), [商品名称]) AS productName,
          CONVERT(nvarchar(500), [品牌名称]) AS sourceBrand,
          CONVERT(nvarchar(500), [一级类目名称]) AS category1,
          CONVERT(nvarchar(500), [二级类目名称]) AS category2,
          CONVERT(nvarchar(500), [叶子类目名称]) AS category3,
          CONVERT(nvarchar(255), [支付金额]) AS paymentAmount,
          CONVERT(nvarchar(255), [支付人数]) AS paymentUsers,
          CONVERT(nvarchar(255), [加购人数]) AS cartUsers,
          CONVERT(nvarchar(255), [商品访客数]) AS visitors,
          CONVERT(nvarchar(255), [支付转化率]) AS conversionRate,
          CONVERT(nvarchar(255), [商品收藏人数]) AS favorites,
          CONVERT(nvarchar(255), [展现量]) AS impressions,
          CONVERT(nvarchar(255), [点击量]) AS clicks,
          CONVERT(nvarchar(255), [点击率]) AS clickRate,
          CONVERT(nvarchar(255), [推广消耗金额]) AS promotionSpend,
          CONVERT(nvarchar(255), [推广引导总成交金额]) AS promotionRevenue,
          CONVERT(nvarchar(255), [推广ROI]) AS roi
        FROM [rpt].[TmallSrcBusinessRoi]
        WHERE LTRIM(RTRIM(CONVERT(nvarchar(255), [商品ID]))) = @productId
          AND [统计日期] >= TRY_CONVERT(date, @startDate)
          AND [统计日期] <= TRY_CONVERT(date, @endDate)
        ORDER BY [统计日期] ASC, [RowId] ASC
      `)
  return result.recordset || []
}

function dateKeyToUtcDate(value: string) {
  return new Date(`${value}T00:00:00.000Z`)
}

function shiftDateKey(value: string, days: number) {
  const date = dateKeyToUtcDate(value)
  date.setUTCDate(date.getUTCDate() + days)
  return date.toISOString().slice(0, 10)
}

function maxDateKey(left: string, right: string) {
  return compareDateKeys(left, right) >= 0 ? left : right
}

function parsePerformanceConversionSourceCursor(value: string | null): PerformanceConversionSourceCursor {
  if (!value) return { version: 1, lastSourceDate: null }
  try {
    const parsed = JSON.parse(value) as Partial<PerformanceConversionSourceCursor>
    return {
      version: 1,
      lastSourceDate: typeof parsed.lastSourceDate === 'string' && isValidDateKey(parsed.lastSourceDate)
        ? parsed.lastSourceDate
        : null,
    }
  } catch {
    return { version: 1, lastSourceDate: null }
  }
}

function serializePerformanceConversionSourceCursor(cursor: PerformanceConversionSourceCursor) {
  return JSON.stringify(cursor)
}

function normalizePerformanceConversionSyncStatus(state: { status: string; lastCompletedAt: Date | null } | null): PerformanceConversionSyncStatus {
  if (!state?.lastCompletedAt) {
    return state?.status === 'syncing' ? 'syncing' : state?.status === 'error' ? 'error' : 'pending'
  }
  if (state.status === 'syncing') return 'syncing'
  if (state.status === 'error') return 'error'
  return 'ready'
}

export async function getPerformanceConversionSyncMetadata(): Promise<PerformanceConversionSyncMetadata> {
  // Keep isolated unit tests and pre-migration local shells readable while the
  // additive table is being introduced. Production Prisma clients always have
  // this delegate after the migration has been applied.
  const syncState = (prisma as typeof prisma & {
    performanceConversionSyncState?: typeof prisma.performanceConversionSyncState
  }).performanceConversionSyncState
  if (!syncState) {
    return { status: 'pending', lastCompletedAt: null, lastSourceDate: null }
  }
  try {
    const state = await syncState.findUnique({
      where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID },
      select: { status: true, lastCompletedAt: true, sourceCursorRaw: true },
    })
    const cursor = parsePerformanceConversionSourceCursor(state?.sourceCursorRaw || null)
    return {
      status: normalizePerformanceConversionSyncStatus(state),
      lastCompletedAt: state?.lastCompletedAt?.toISOString() || null,
      lastSourceDate: cursor.lastSourceDate,
    }
  } catch (error) {
    console.warn('[performance-conversion-sync] 同步状态读取失败，暂按首次同步处理：', error)
    return { status: 'pending', lastCompletedAt: null, lastSourceDate: null }
  }
}

async function readSnapshotRows(productId: string, startDate: string, endDate: string) {
  const rows = await prisma.performanceConversionMetricSnapshot.findMany({
    where: {
      productId,
      metricDate: {
        gte: dateKeyToUtcDate(startDate),
        lte: dateKeyToUtcDate(endDate),
      },
    },
    orderBy: [{ metricDate: 'asc' }, { sourceRowId: 'asc' }],
  })
  return rows.map((row) => ({
    sourceRowId: row.sourceRowId,
    metricDate: row.metricDate,
    productId: row.productId,
    productName: row.productName,
    sourceBrand: row.sourceBrand,
    category1: row.category1,
    category2: row.category2,
    category3: row.category3,
    paymentAmount: row.paymentAmount,
    paymentUsers: row.paymentUsers,
    cartUsers: row.cartUsers,
    visitors: row.visitors,
    conversionRate: row.conversionRate,
    favorites: row.favorites,
    impressions: row.impressions,
    clicks: row.clicks,
    clickRate: row.clickRate,
    promotionSpend: row.promotionSpend,
    promotionRevenue: row.promotionRevenue,
    roi: row.roi,
  })) satisfies SourceMetricRow[]
}

async function readUpstreamSourceRows(productId: string, startDate: string, endDate: string) {
  const cacheKey = `upstream:${productId}:${startDate}:${endDate}`
  const cached = sourceCache.get(cacheKey)
  if (cached && cached.expiresAt > Date.now()) return cached.rows

  const pool = new mssql.ConnectionPool(sourceConfig())
  try {
    await pool.connect()
    const rows = await fetchSourceRows(pool, productId, startDate, endDate)
    sourceCache.set(cacheKey, { rows, expiresAt: Date.now() + SOURCE_CACHE_TTL_MS })
    return rows
  } finally {
    await pool.close().catch(() => undefined)
  }
}

async function readSourceRows(productId: string, startDate: string, endDate: string) {
  const sync = await getPerformanceConversionSyncMetadata()
  if (sync.lastCompletedAt) {
    const localRows = await readSnapshotRows(productId, startDate, endDate)
    if (localRows.length > 0) {
      return localRows
    }
    // A newly synced workflow may not be included in the previous daily run.
    // Keep the old direct read only for that bootstrap gap; the next scheduled
    // run will persist the same product into the local snapshot.
  }
  return readUpstreamSourceRows(productId, startDate, endDate)
}

type MetricProductWindow = {
  productId: string
  startDate: string
  endDate: string
}

function getMetricProductWindows(snapshots: SnapshotRow[], today: string): MetricProductWindow[] {
  const windows = new Map<string, MetricProductWindow>()
  snapshots.flatMap(workflowItems).forEach((item) => {
    const endDate = compareDateKeys(today, item.monitorEndDate) <= 0 ? today : item.monitorEndDate
    const existing = windows.get(item.productId)
    if (!existing) {
      windows.set(item.productId, { productId: item.productId, startDate: item.monitorStartDate, endDate })
      return
    }
    existing.startDate = compareDateKeys(item.monitorStartDate, existing.startDate) < 0
      ? item.monitorStartDate
      : existing.startDate
    existing.endDate = maxDateKey(existing.endDate, endDate)
  })
  return Array.from(windows.values()).filter((item) => compareDateKeys(item.startDate, item.endDate) <= 0)
}

async function acquirePerformanceConversionSyncLease(leaseOwner: string, startedAt: Date) {
  await prisma.performanceConversionSyncState.upsert({
    where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID },
    create: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID },
    update: {},
  })
  const claimed = await prisma.performanceConversionSyncState.updateMany({
    where: {
      id: PERFORMANCE_CONVERSION_SYNC_STATE_ID,
      OR: [
        { leaseExpiresAt: null },
        { leaseExpiresAt: { lt: startedAt } },
        { leaseOwner },
      ],
    },
    data: {
      status: 'syncing',
      lastStartedAt: startedAt,
      lastError: null,
      leaseOwner,
      leaseExpiresAt: new Date(startedAt.getTime() + SYNC_LEASE_DURATION_MS),
    },
  })
  if (claimed.count !== 1) return null
  return prisma.performanceConversionSyncState.findUniqueOrThrow({
    where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID },
  })
}

async function renewPerformanceConversionSyncLease(leaseOwner: string) {
  const renewed = await prisma.performanceConversionSyncState.updateMany({
    where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID, leaseOwner },
    data: { leaseExpiresAt: new Date(Date.now() + SYNC_LEASE_DURATION_MS) },
  })
  if (renewed.count !== 1) throw new Error('经营数据同步租约已失效，本轮停止写入')
}

function toMetricSnapshotData(row: SourceMetricRow, productId: string, syncedAt: Date, index: number) {
  const metricDate = metricDateKey(row.metricDate)
  if (!metricDate) return null
  const sourceRowId = clean(row.sourceRowId)
  return {
    id: randomUUID(),
    sourceKey: `${productId}:${metricDate}:${sourceRowId || `row-${index}`}`,
    sourceRowId,
    productId,
    metricDate: dateKeyToUtcDate(metricDate),
    productName: clean(row.productName),
    sourceBrand: clean(row.sourceBrand),
    category1: clean(row.category1),
    category2: clean(row.category2),
    category3: clean(row.category3),
    paymentAmount: clean(row.paymentAmount),
    paymentUsers: clean(row.paymentUsers),
    cartUsers: clean(row.cartUsers),
    visitors: clean(row.visitors),
    conversionRate: clean(row.conversionRate),
    favorites: clean(row.favorites),
    impressions: clean(row.impressions),
    clicks: clean(row.clicks),
    clickRate: clean(row.clickRate),
    promotionSpend: clean(row.promotionSpend),
    promotionRevenue: clean(row.promotionRevenue),
    roi: clean(row.roi),
    syncedAt,
    createdAt: syncedAt,
    updatedAt: syncedAt,
  }
}

export async function syncPerformanceConversionMetrics() {
  if (!sourceDbConfigured()) throw new Error('未配置上游报表库（REPORT_DB_*），无法同步经营数据')

  const startedAt = new Date()
  const leaseOwner = `${hostname()}:${process.pid}:${randomUUID()}`
  const state = await acquirePerformanceConversionSyncLease(leaseOwner, startedAt)
  if (!state) return { skipped: true, rowsUpserted: 0, productsSynced: 0 }

  const pool = new mssql.ConnectionPool(sourceConfig())
  let rowsUpserted = 0
  let productsSynced = 0
  try {
    await pool.connect()
    const cursor = parsePerformanceConversionSourceCursor(state.sourceCursorRaw)
    const today = toShanghaiDateKey(new Date())
    if (!today) throw new Error('无法确定上海时区的当前日期')
    const snapshots = await readEligibleSnapshots()
    const windows = getMetricProductWindows(snapshots, today)
    const syncStartedAt = new Date()

    for (const window of windows) {
      await renewPerformanceConversionSyncLease(leaseOwner)
      const existing = await prisma.performanceConversionMetricSnapshot.findFirst({
        where: { productId: window.productId },
        select: { id: true },
      })
      const incrementalStart = cursor.lastSourceDate
        ? shiftDateKey(cursor.lastSourceDate, -SYNC_LOOKBACK_DAYS)
        : window.startDate
      const startDate = existing ? maxDateKey(window.startDate, incrementalStart) : window.startDate
      const endDate = window.endDate
      if (compareDateKeys(startDate, endDate) > 0) continue

      const sourceRows = await fetchSourceRows(pool, window.productId, startDate, endDate)
      const snapshotsToWrite = sourceRows
        .map((row, index) => toMetricSnapshotData(row, window.productId, syncStartedAt, index))
        .filter((row): row is NonNullable<ReturnType<typeof toMetricSnapshotData>> => row !== null)

      await prisma.$transaction(async (tx) => {
        await tx.performanceConversionMetricSnapshot.deleteMany({
          where: {
            productId: window.productId,
            metricDate: { gte: dateKeyToUtcDate(startDate), lte: dateKeyToUtcDate(endDate) },
          },
        })
        if (snapshotsToWrite.length > 0) {
          await tx.performanceConversionMetricSnapshot.createMany({ data: snapshotsToWrite })
        }
      })
      rowsUpserted += snapshotsToWrite.length
      productsSynced += 1
    }

    sourceCache.clear()
    const sourceCursorRaw = serializePerformanceConversionSourceCursor({ version: 1, lastSourceDate: today })
    const completed = await prisma.performanceConversionSyncState.updateMany({
      where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID, leaseOwner },
      data: {
        status: 'ready',
        sourceCursorRaw,
        lastCompletedAt: syncStartedAt,
        lastError: null,
        leaseOwner: null,
        leaseExpiresAt: null,
        rowsUpserted,
        productsSynced,
      },
    })
    if (completed.count !== 1) throw new Error('经营数据同步租约已失效，本轮不能标记为成功')
    return { skipped: false, rowsUpserted, productsSynced }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    await prisma.performanceConversionSyncState.updateMany({
      where: { id: PERFORMANCE_CONVERSION_SYNC_STATE_ID, leaseOwner },
      data: {
        status: 'error',
        lastError: message.slice(0, 2_000),
        leaseOwner: null,
        leaseExpiresAt: null,
      },
    }).catch(() => undefined)
    throw error
  } finally {
    await pool.close().catch(() => undefined)
  }
}

type PerformanceConversionSyncGlobal = typeof globalThis & {
  __performanceConversionDailySyncStarted?: boolean
}

export function ensureDailyPerformanceConversionSyncStarted() {
  const schedulerGlobal = globalThis as PerformanceConversionSyncGlobal
  if (schedulerGlobal.__performanceConversionDailySyncStarted) return
  schedulerGlobal.__performanceConversionDailySyncStarted = true

  if (!sourceDbConfigured()) {
    console.info('[performance-conversion-sync] 未配置上游报表库，跳过每日经营数据同步')
    return
  }

  const runOnce = () => {
    void syncPerformanceConversionMetrics()
      .then((result) => {
        if (result.skipped) {
          console.info('[performance-conversion-sync] 另一实例正在同步，本轮跳过')
          return
        }
        console.info(`[performance-conversion-sync] 同步完成：更新 ${result.rowsUpserted} 条，商品 ${result.productsSynced} 个`)
      })
      .catch((error) => console.warn('[performance-conversion-sync] 同步失败：', error))
  }

  const initialTimer = setTimeout(runOnce, SYNC_INITIAL_DELAY_MS)
  initialTimer.unref?.()
  const interval = setInterval(runOnce, SYNC_INTERVAL_MS)
  interval.unref?.()
  console.info('[performance-conversion-sync] 已调度经营数据每日增量同步，周期 24 小时，按最近两天增量校准')
}

function numberValue(value: unknown) {
  const normalized = clean(value)?.replace(/[,%￥¥\s]/g, '')
  if (!normalized) return null
  const parsed = Number(normalized)
  if (!Number.isFinite(parsed)) return null
  return String(value).includes('%') ? parsed / 100 : parsed
}

function sum(values: Array<number | null>) {
  const present = values.filter((value): value is number => value !== null)
  return present.length ? present.reduce((total, value) => total + value, 0) : null
}

function average(values: Array<number | null>) {
  const present = values.filter((value): value is number => value !== null)
  return present.length ? present.reduce((total, value) => total + value, 0) / present.length : null
}

function ratio(numerator: number | null, denominator: number | null, fallback: number | null) {
  return denominator !== null && denominator > 0 && numerator !== null ? numerator / denominator : fallback
}

function metricDateKey(value: Date | string | null) {
  if (!value) return null
  if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}/.test(value)) return value.slice(0, 10)
  const parsed = value instanceof Date ? value : new Date(value)
  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString().slice(0, 10)
}

function aggregateRows(rows: SourceMetricRow[]) {
  const grouped = new Map<string, SourceMetricRow[]>()
  rows.forEach((row) => {
    const key = metricDateKey(row.metricDate)
    if (key) grouped.set(key, [...(grouped.get(key) || []), row])
  })
  return Array.from(grouped.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([date, dayRows]): PerformanceConversionDailyMetric => {
    const impressions = sum(dayRows.map((row) => numberValue(row.impressions)))
    const clicks = sum(dayRows.map((row) => numberValue(row.clicks)))
    const visitors = sum(dayRows.map((row) => numberValue(row.visitors)))
    const paymentUsers = sum(dayRows.map((row) => numberValue(row.paymentUsers)))
    const promotionSpend = sum(dayRows.map((row) => numberValue(row.promotionSpend)))
    const promotionRevenue = sum(dayRows.map((row) => numberValue(row.promotionRevenue)))
    return {
      date,
      impressions,
      visitors,
      clickRate: ratio(clicks, impressions, average(dayRows.map((row) => numberValue(row.clickRate)))),
      favorites: sum(dayRows.map((row) => numberValue(row.favorites))),
      cartUsers: sum(dayRows.map((row) => numberValue(row.cartUsers))),
      paymentConversionRate: ratio(paymentUsers, visitors, average(dayRows.map((row) => numberValue(row.conversionRate)))),
      paymentAmount: sum(dayRows.map((row) => numberValue(row.paymentAmount))),
      roi: ratio(promotionRevenue, promotionSpend, average(dayRows.map((row) => numberValue(row.roi)))),
    }
  })
}

function expandDailyRange(
  source: PerformanceConversionDailyMetric[],
  startDate: string,
  endDate: string,
) {
  const byDate = new Map(source.map((item) => [item.date, item]))
  const expanded: PerformanceConversionDailyMetric[] = []
  const cursor = new Date(`${startDate}T00:00:00Z`)
  const end = new Date(`${endDate}T00:00:00Z`)
  while (cursor <= end) {
    const date = cursor.toISOString().slice(0, 10)
    expanded.push(byDate.get(date) || {
      date,
      impressions: null,
      visitors: null,
      clickRate: null,
      favorites: null,
      cartUsers: null,
      paymentConversionRate: null,
      paymentAmount: null,
      roi: null,
    })
    cursor.setUTCDate(cursor.getUTCDate() + 1)
  }
  return expanded
}

function normalizeSourceBrand(value: unknown): PerformanceConversionBrand | null {
  const normalized = clean(value)?.toLowerCase()
  if (!normalized) return null
  return BUSINESS_TREND_BRANDS.find((brand) => normalized.includes(brand.toLowerCase())) || null
}

function latestClean(rows: SourceMetricRow[], field: keyof SourceMetricRow) {
  for (let index = rows.length - 1; index >= 0; index -= 1) {
    const value = clean(rows[index][field])
    if (value) return value
  }
  return null
}

export async function getPerformanceConversionTimeseries(
  session: Session | null,
  input: { workflowId?: string | null; productId?: string | null },
): Promise<PerformanceConversionTimeseries> {
  await assertBrandCenterDashboardAccess(session)
  const workflowId = clean(input.workflowId)
  const productId = extractValidProductIds(input.productId)[0]
  if (!workflowId || !productId) throw new PerformanceConversionError('流程或商品 ID 参数无效')

  const row = await prisma.dingWorkflowSnapshot.findUnique({
    where: { processInstanceId: workflowId },
    select: {
      processInstanceId: true,
      businessId: true,
      title: true,
      result: true,
      bizAction: true,
      status: true,
      processCode: true,
      brand: true,
      sourceFinishedAtRaw: true,
      formFields: true,
      syncedAt: true,
    },
  })
  if (!row || !isEligibleSnapshot(row)) throw new PerformanceConversionError('未找到可监控的已完结美术流程', 404)
  const workflow = workflowItems(row).find((item) => item.productId === productId)
  if (!workflow) throw new PerformanceConversionError('商品 ID 不属于该流程', 403)

  const today = toShanghaiDateKey(new Date()) || workflow.monitorStartDate
  const queryEndDate = compareDateKeys(today, workflow.monitorEndDate) < 0 ? today : workflow.monitorEndDate
  const rows = compareDateKeys(queryEndDate, workflow.monitorStartDate) >= 0
    ? await readSourceRows(productId, workflow.monitorStartDate, queryEndDate)
    : []
  const sourceDaily = aggregateRows(rows)
  const daily = compareDateKeys(queryEndDate, workflow.monitorStartDate) >= 0
    ? expandDailyRange(sourceDaily, workflow.monitorStartDate, queryEndDate)
    : []
  const sourceBrand = normalizeSourceBrand(latestClean(rows, 'sourceBrand'))
  const category = [latestClean(rows, 'category1'), latestClean(rows, 'category2'), latestClean(rows, 'category3')]
    .filter(Boolean).join(' / ') || null

  return {
    workflow,
    product: {
      id: productId,
      name: latestClean(rows, 'productName'),
      sourceBrand: latestClean(rows, 'sourceBrand'),
      category,
      brandMatchesWorkflow: sourceBrand ? sourceBrand === workflow.brand : null,
    },
    latest: sourceDaily[sourceDaily.length - 1] || null,
    daily,
    coverage: {
      sourceFirstDate: sourceDaily[0]?.date || null,
      sourceLatestDate: sourceDaily[sourceDaily.length - 1]?.date || null,
      coveredDays: sourceDaily.length,
      expectedDaysToDate: daysBetweenInclusive(workflow.monitorStartDate, queryEndDate),
      monitorStartDate: workflow.monitorStartDate,
      monitorEndDate: workflow.monitorEndDate,
    },
  }
}