import { Solar } from 'lunar-typescript'

const PALACE_ORDER = ['大安', '留连', '速喜', '赤口', '小吉', '空亡'] as const
const BRANCH_ORDER = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'] as const
const LUNAR_MONTH_BRANCHES = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑'] as const
const SLOT_ORDER = ['year', 'month', 'day', 'time'] as const
const COMPASS_SLOT_VALUES = ['first', 'second', 'third'] as const

const BRANCH_VALUES: Record<BranchName, number> = {
  子: 1,
  丑: 2,
  寅: 3,
  卯: 4,
  辰: 5,
  巳: 6,
  午: 7,
  未: 8,
  申: 9,
  酉: 10,
  戌: 11,
  亥: 12,
}

const PALACE_META = {
  大安: {
    element: '木',
    quality: '吉',
    theme: '稳住格局，利于正面推进。',
    detail: '适合谈条件、做决策、走正式流程。',
    weight: 2,
  },
  留连: {
    element: '土',
    quality: '中',
    theme: '反复拖延，过程比结果更磨人。',
    detail: '适合补材料、等批复、拉齐分歧，不宜急催。',
    weight: 0,
  },
  速喜: {
    element: '火',
    quality: '吉',
    theme: '消息来得快，适合主动推进。',
    detail: '利沟通、利反馈、利敲定窗口期。',
    weight: 3,
  },
  赤口: {
    element: '金',
    quality: '凶',
    theme: '口舌争执，信息容易带刺。',
    detail: '要管住措辞，避免硬碰硬。',
    weight: -2,
  },
  小吉: {
    element: '水',
    quality: '吉',
    theme: '缓步有利，贵在借力。',
    detail: '利协商、利求人、利柔性处理。',
    weight: 2,
  },
  空亡: {
    element: '土',
    quality: '凶',
    theme: '预期容易落空，先核实条件。',
    detail: '适合先确认资源和边界，再决定要不要投入。',
    weight: -3,
  },
} as const

const ELEMENT_GENERATES: Record<ElementName, ElementName> = {
  木: '火',
  火: '土',
  土: '金',
  金: '水',
  水: '木',
}

const ELEMENT_CONTROLS: Record<ElementName, ElementName> = {
  木: '土',
  火: '金',
  土: '水',
  金: '木',
  水: '火',
}

const SLOT_LABELS: Record<BranchSlot, string> = {
  year: '年宫',
  month: '月宫',
  day: '日宫',
  time: '时宫',
}

const SLOT_SOURCES: Record<BranchSlot, string> = {
  year: '农历年支',
  month: '农历月建',
  day: '万年历日支',
  time: '时辰地支',
}

const SLOT_EXPLANATIONS: Record<BranchSlot, string> = {
  year: '对应大环境、外部周期、行业与权力方态度。',
  month: '对应当月氛围、资源松紧、团队与预算状态。',
  day: '对应当天执行面、你的状态、沟通与临场表现。',
  time: '对应结果落点，成败判断以此为主。',
}

const DOMAIN_KEYWORDS = {
  career: ['工作', '加薪', '升职', 'offer', '面试', '跳槽', '裁员', '项目', '合作', '老板'],
  wealth: ['财运', '投资', '赚钱', '回款', '签单', '收入', '生意', '客户'],
  relation: ['感情', '恋爱', '复合', '结婚', '相亲', '关系', '伴侣'],
  study: ['考试', '学习', '申请', '留学', '证书', '答辩'],
} as const

export type PalaceName = (typeof PALACE_ORDER)[number]
export type BranchName = (typeof BRANCH_ORDER)[number]
export type BranchSlot = (typeof SLOT_ORDER)[number]
export type ElementName = '木' | '火' | '土' | '金' | '水'
export type DivinationMode = 'time' | 'compass'

export interface CompassNumbers {
  first: number
  second: number
  third: number
}

export interface ManualBranchOverrides {
  year?: BranchName
  month?: BranchName
  day?: BranchName
  time?: BranchName
}

export interface BranchInfo {
  slot: BranchSlot
  label: string
  branch: string
  value: number
  source: string
  sourceNote: string
  ganZhi: string
}

export interface PalaceResult {
  slot: BranchSlot
  label: string
  branch: string
  branchValue: number
  palace: PalaceName
  element: ElementName
  quality: '吉' | '中' | '凶'
  theme: string
  detail: string
  slotExplanation: string
}

export interface PalaceRelation {
  from: BranchSlot
  to: BranchSlot
  kind: '前生后' | '前克后' | '后生前' | '后克前' | '比和'
  score: number
  summary: string
}

export interface LocalInterpretation {
  verdict: string
  score: number
  summary: string
  domainLabel: string
  chainSummary: string
  actionAdvice: string[]
  riskAdvice: string[]
}

export interface DivinationResult {
  mode: DivinationMode
  modeLabel: string
  question: string
  datetime: string
  solarLabel: string
  lunarLabel: string
  methodNote: string
  branches: Record<BranchSlot, BranchInfo>
  palaces: PalaceResult[]
  relations: PalaceRelation[]
  finalPalace: PalaceResult
  localInterpretation: LocalInterpretation
}

interface DerivedContext {
  mode: DivinationMode
  modeLabel: string
  solarLabel: string
  lunarLabel: string
  methodNote: string
  branches: Record<BranchSlot, BranchInfo>
}

export const branchOptions = [...BRANCH_ORDER]
export const compassNumberOptions = [1, 2, 3, 4, 5, 6, 7, 8, 9] as const
export const defaultCompassNumbers: CompassNumbers = {
  first: 3,
  second: 6,
  third: 9,
}

export function buildDivination(input: {
  datetime: string
  question: string
  mode?: DivinationMode
  overrides?: ManualBranchOverrides
  compassNumbers?: CompassNumbers
}): DivinationResult {
  const trimmedQuestion = input.question.trim() || '这件事现在推进，结果会怎样？'
  const context = deriveContext({
    mode: input.mode ?? 'time',
    datetime: input.datetime,
    overrides: input.overrides,
    compassNumbers: input.compassNumbers,
  })
  const palaces = buildPalaces(context.branches)
  const relations = buildRelations(palaces)
  const finalPalace = palaces[palaces.length - 1]
  const localInterpretation = buildLocalInterpretation(trimmedQuestion, palaces, relations)

  return {
    mode: context.mode,
    modeLabel: context.modeLabel,
    question: trimmedQuestion,
    datetime: input.datetime,
    solarLabel: context.solarLabel,
    lunarLabel: context.lunarLabel,
    methodNote: context.methodNote,
    branches: context.branches,
    palaces,
    relations,
    finalPalace,
    localInterpretation,
  }
}

export function deriveBranchDefaults(datetime: string): Record<BranchSlot, BranchName> {
  const branches = deriveTimeContext(datetime).branches
  return {
    year: branches.year.branch as BranchName,
    month: branches.month.branch as BranchName,
    day: branches.day.branch as BranchName,
    time: branches.time.branch as BranchName,
  }
}

export function getDefaultDatetimeValue(date = new Date()): string {
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hour = String(date.getHours()).padStart(2, '0')
  const minute = String(date.getMinutes()).padStart(2, '0')
  return `${year}-${month}-${day}T${hour}:${minute}`
}

function deriveContext(input: {
  mode: DivinationMode
  datetime: string
  overrides?: ManualBranchOverrides
  compassNumbers?: CompassNumbers
}): DerivedContext {
  if (input.mode === 'compass') {
    return deriveCompassContext(input.datetime, input.compassNumbers)
  }

  return deriveTimeContext(input.datetime, input.overrides)
}

function deriveTimeContext(datetime: string, overrides?: ManualBranchOverrides): DerivedContext {
  const date = parseLocalDatetime(datetime)
  const solar = Solar.fromDate(date)
  const lunar = solar.getLunar()
  const lunarMonth = Math.abs(lunar.getMonth())
  const yearGanZhi = lunar.getYearInGanZhi()
  const monthGanZhi = lunar.getMonthInGanZhi()
  const dayGanZhi = lunar.getDayInGanZhi()
  const timeGanZhi = lunar.getTimeInGanZhi()
  const autoBranches: Record<BranchSlot, BranchName> = {
    year: lunar.getYearZhi() as BranchName,
    month: LUNAR_MONTH_BRANCHES[(Math.max(1, Math.min(12, lunarMonth)) - 1) as number],
    day: lunar.getDayZhi() as BranchName,
    time: getTimeBranch(date.getHours()),
  }
  const resolvedBranches: Record<BranchSlot, BranchName> = {
    year: overrides?.year ?? autoBranches.year,
    month: overrides?.month ?? autoBranches.month,
    day: overrides?.day ?? autoBranches.day,
    time: overrides?.time ?? autoBranches.time,
  }

  return {
    mode: 'time',
    modeLabel: '时刻起课',
    solarLabel: formatSolarLabel(date),
    lunarLabel: `农历${lunar.getYearInChinese()}年${lunar.getMonthInChinese()}月${lunar.getDayInChinese()}`,
    methodNote:
      '默认按农历年支、农历月建、万年历日支、时辰地支起四宫；若涉及晚子时、闰月或流派差异，可手动覆写。',
    branches: {
      year: {
        slot: 'year',
        label: SLOT_LABELS.year,
        branch: resolvedBranches.year,
        value: BRANCH_VALUES[resolvedBranches.year],
        source: SLOT_SOURCES.year,
        sourceNote: `自动换算为 ${yearGanZhi}，本法取年支 ${resolvedBranches.year}。`,
        ganZhi: yearGanZhi,
      },
      month: {
        slot: 'month',
        label: SLOT_LABELS.month,
        branch: resolvedBranches.month,
        value: BRANCH_VALUES[resolvedBranches.month],
        source: SLOT_SOURCES.month,
        sourceNote: `当前为农历${lunar.getMonthInChinese()}月，月建取支 ${resolvedBranches.month}；干支参考 ${monthGanZhi}。`,
        ganZhi: monthGanZhi,
      },
      day: {
        slot: 'day',
        label: SLOT_LABELS.day,
        branch: resolvedBranches.day,
        value: BRANCH_VALUES[resolvedBranches.day],
        source: SLOT_SOURCES.day,
        sourceNote: `万年历日柱参考 ${dayGanZhi}，本法取日支 ${resolvedBranches.day}。`,
        ganZhi: dayGanZhi,
      },
      time: {
        slot: 'time',
        label: SLOT_LABELS.time,
        branch: resolvedBranches.time,
        value: BRANCH_VALUES[resolvedBranches.time],
        source: SLOT_SOURCES.time,
        sourceNote: `当前时柱参考 ${timeGanZhi}，本法取时支 ${resolvedBranches.time}。`,
        ganZhi: timeGanZhi,
      },
    },
  }
}

function deriveCompassContext(datetime: string, numbers?: CompassNumbers): DerivedContext {
  const date = parseLocalDatetime(datetime)
  const solar = Solar.fromDate(date)
  const lunar = solar.getLunar()
  const resolvedNumbers = normalizeCompassNumbers(numbers)
  const total = resolvedNumbers.first + resolvedNumbers.second + resolvedNumbers.third

  return {
    mode: 'compass',
    modeLabel: '罗盘三数起课',
    solarLabel: formatSolarLabel(date),
    lunarLabel: `农历${lunar.getYearInChinese()}年${lunar.getMonthInChinese()}月${lunar.getDayInChinese()}`,
    methodNote:
      '按罗盘三数法起课：第一数定外势，第二数看过程，第三数落执行，三数合参定终局。三数都取 1 到 9，结果宫按合参之数顺推。',
    branches: {
      year: {
        slot: 'year',
        label: SLOT_LABELS.year,
        branch: `数${resolvedNumbers.first}`,
        value: resolvedNumbers.first,
        source: '罗盘第一数',
        sourceNote: `第一数取 ${resolvedNumbers.first}，从大安起数，先定年宫。`,
        ganZhi: '-',
      },
      month: {
        slot: 'month',
        label: SLOT_LABELS.month,
        branch: `数${resolvedNumbers.second}`,
        value: resolvedNumbers.second,
        source: '罗盘第二数',
        sourceNote: `第二数取 ${resolvedNumbers.second}，从年宫顺推，落月宫。`,
        ganZhi: '-',
      },
      day: {
        slot: 'day',
        label: SLOT_LABELS.day,
        branch: `数${resolvedNumbers.third}`,
        value: resolvedNumbers.third,
        source: '罗盘第三数',
        sourceNote: `第三数取 ${resolvedNumbers.third}，从月宫顺推，落日宫。`,
        ganZhi: '-',
      },
      time: {
        slot: 'time',
        label: SLOT_LABELS.time,
        branch: `合${total}`,
        value: total,
        source: '三数合参',
        sourceNote: `三数相加为 ${total}，从日宫顺推，定时宫终局。`,
        ganZhi: '-',
      },
    },
  }
}

function buildPalaces(branches: Record<BranchSlot, BranchInfo>): PalaceResult[] {
  let currentIndex = 0

  return SLOT_ORDER.map((slot) => {
    const branch = branches[slot]
    currentIndex = walkPalace(currentIndex, branch.value)
    const palace = PALACE_ORDER[currentIndex]
    const meta = PALACE_META[palace]

    return {
      slot,
      label: SLOT_LABELS[slot],
      branch: branch.branch,
      branchValue: branch.value,
      palace,
      element: meta.element,
      quality: meta.quality,
      theme: meta.theme,
      detail: meta.detail,
      slotExplanation: SLOT_EXPLANATIONS[slot],
    }
  })
}

function buildRelations(palaces: PalaceResult[]): PalaceRelation[] {
  const relations: PalaceRelation[] = []

  for (let index = 0; index < palaces.length - 1; index += 1) {
    const current = palaces[index]
    const next = palaces[index + 1]
    const relation = classifyRelation(current.element, next.element)

    relations.push({
      from: current.slot,
      to: next.slot,
      kind: relation.kind,
      score: relation.score,
      summary: `${current.label}${current.palace}(${current.element})${relation.text}${next.label}${next.palace}(${next.element})`,
    })
  }

  return relations
}

function buildLocalInterpretation(
  question: string,
  palaces: PalaceResult[],
  relations: PalaceRelation[],
): LocalInterpretation {
  const domainLabel = detectDomain(question)
  const palaceScore = palaces.reduce((sum, item, index) => {
    const weight = PALACE_META[item.palace].weight
    return sum + (index === palaces.length - 1 ? weight * 2 : weight)
  }, 0)
  const relationScore = relations.reduce((sum, relation) => sum + relation.score, 0)
  const score = palaceScore + relationScore
  const finalPalace = palaces[palaces.length - 1]
  const verdict = resolveVerdict(score, finalPalace.palace)
  const chainSummary = relations.map((item) => item.summary).join('；')

  const summary = [
    `终宫落在${finalPalace.palace}，主调是“${PALACE_META[finalPalace.palace].theme}”`,
    `${finalPalace.label}主结果，说明这件事的落点偏向${describeOutcome(finalPalace.palace)}。`,
    chainSummary ? `四宫链路里，${chainSummary}。` : '',
  ]
    .filter(Boolean)
    .join('')

  return {
    verdict,
    score,
    summary,
    domainLabel,
    chainSummary,
    actionAdvice: buildActionAdvice(domainLabel, finalPalace, relations),
    riskAdvice: buildRiskAdvice(finalPalace, relations),
  }
}

function buildActionAdvice(
  domainLabel: string,
  finalPalace: PalaceResult,
  relations: PalaceRelation[],
): string[] {
  const advice = [
    '先把所问之事收束成一个判断点，例如现在推进、暂缓观望，还是先补条件。',
    '先看年宫与月宫给不给势，再决定当下动作，不要只盯终宫一句吉凶。',
  ]

  if (finalPalace.palace === '速喜') {
    advice.unshift('眼下宜先动一步，把时间、对象和诉求一次定清，不要把顺势拖成失势。')
  } else if (finalPalace.palace === '大安') {
    advice.unshift('此局宜走正路，把条件、边界和预期回报摆清，再稳稳推进。')
  } else if (finalPalace.palace === '小吉') {
    advice.unshift('此时宜先借力，让熟人、旧成果或中间人替你开路，不必硬闯。')
  } else if (finalPalace.palace === '留连') {
    advice.unshift('此局贵在补缺，把顾虑逐条拆开，比一味催结果更有效。')
  } else if (finalPalace.palace === '赤口') {
    advice.unshift('此时先收锋芒再出手，话要留余地，事要留凭据。')
  } else {
    advice.unshift('此时先验信息真假与承诺落点，未坐实之前，不宜下重注。')
  }

  if (domainLabel === '事业/合作') {
    advice.push('涉及事业或合作时，诉求要落成岗位、预算、周期或资源清单，别只谈感受。')
  } else if (domainLabel === '财务/生意') {
    advice.push('涉及财务或生意时，所有判断都要落到现金流、付款条件和违约边界。')
  } else if (domainLabel === '感情/关系') {
    advice.push('涉及关系时，先辨对方真实态度，再决定进退，不要拿想象替代反馈。')
  } else if (domainLabel === '考试/申请') {
    advice.push('涉及考试或申请时，先守时间规划与材料完整，再谈额外发挥。')
  }

  if (relations.some((item) => item.kind === '前生后')) {
    advice.push('四宫若见顺生，说明次第不可乱，按“先看环境，再落动作，后取结果”会更顺。')
  }

  return advice.slice(0, 4)
}

function buildRiskAdvice(finalPalace: PalaceResult, relations: PalaceRelation[]): string[] {
  const advice: string[] = []

  if (relations.some((item) => item.kind === '前克后' || item.kind === '后克前')) {
    advice.push('四宫存在克制，推进中容易出现抵触、卡口或资源冲突。')
  }

  if (finalPalace.palace === '赤口') {
    advice.push('结果宫带赤口，最大的风险不是没有机会，而是把机会说坏。')
  }

  if (finalPalace.palace === '空亡') {
    advice.push('结果宫带空亡，最大的风险是信息不实、承诺虚高或条件临时失效。')
  }

  if (finalPalace.palace === '留连') {
    advice.push('结果宫带留连，最大的风险是一直等、一直猜，迟迟不做下一步动作。')
  }

  if (advice.length === 0) {
    advice.push('整体链路不算凶，但仍要把时间点、承诺边界和证据留存好。')
  }

  return advice.slice(0, 3)
}

function walkPalace(startIndex: number, steps: number): number {
  return (startIndex + steps - 1) % PALACE_ORDER.length
}

function classifyRelation(from: ElementName, to: ElementName): {
  kind: PalaceRelation['kind']
  score: number
  text: string
} {
  if (from === to) {
    return { kind: '比和', score: 0, text: '与' }
  }

  if (ELEMENT_GENERATES[from] === to) {
    return { kind: '前生后', score: 1, text: '生' }
  }

  if (ELEMENT_CONTROLS[from] === to) {
    return { kind: '前克后', score: -1, text: '克' }
  }

  if (ELEMENT_GENERATES[to] === from) {
    return { kind: '后生前', score: 0, text: '受' }
  }

  return { kind: '后克前', score: -1, text: '受' }
}

function resolveVerdict(score: number, finalPalace: PalaceName): string {
  if (score >= 7) {
    return '上吉，可主动推进。'
  }

  if (score >= 3) {
    return '偏吉，成事面大于阻力。'
  }

  if (score >= 0) {
    return '中平，能不能成取决于执行方式。'
  }

  if (finalPalace === '空亡' || finalPalace === '赤口') {
    return '偏凶，先控风险再行动。'
  }

  return '有阻，宜放慢节奏并补条件。'
}

function describeOutcome(palace: PalaceName): string {
  switch (palace) {
    case '大安':
      return '稳中见成，适合按规矩落地'
    case '留连':
      return '拖中见变，需要耐心和补件'
    case '速喜':
      return '快中见成，重在主动出击'
    case '赤口':
      return '先有口舌，再看能否化解'
    case '小吉':
      return '缓中有利，重在人和与借力'
    case '空亡':
      return '容易落空，必须先验真伪'
  }
}

function detectDomain(question: string): string {
  for (const [key, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
    if (keywords.some((word) => question.includes(word))) {
      switch (key) {
        case 'career':
          return '事业/合作'
        case 'wealth':
          return '财务/生意'
        case 'relation':
          return '感情/关系'
        case 'study':
          return '考试/申请'
        default:
          return '综合事项'
      }
    }
  }

  return '综合事项'
}

function normalizeCompassNumbers(numbers?: CompassNumbers): CompassNumbers {
  const fallback = defaultCompassNumbers
  const values = {
    first: numbers?.first ?? fallback.first,
    second: numbers?.second ?? fallback.second,
    third: numbers?.third ?? fallback.third,
  }

  for (const key of COMPASS_SLOT_VALUES) {
    values[key] = clampCompassNumber(values[key])
  }

  return values
}

function clampCompassNumber(value: number): number {
  if (!Number.isFinite(value)) {
    return 1
  }

  return Math.max(1, Math.min(9, Math.round(value)))
}

function parseLocalDatetime(value: string): Date {
  const [datePart, timePart = '00:00'] = value.split('T')
  const [year, month, day] = datePart.split('-').map((item) => Number(item))
  const [hour, minute] = timePart.split(':').map((item) => Number(item))

  if (![year, month, day, hour, minute].every(Number.isFinite)) {
    return new Date()
  }

  return new Date(year, month - 1, day, hour, minute, 0, 0)
}

function formatSolarLabel(date: Date): string {
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hour = String(date.getHours()).padStart(2, '0')
  const minute = String(date.getMinutes()).padStart(2, '0')
  return `${year}年${month}月${day}日 ${hour}:${minute}`
}

function getTimeBranch(hour: number): BranchName {
  if (hour >= 23 || hour < 1) {
    return '子'
  }
  if (hour < 3) {
    return '丑'
  }
  if (hour < 5) {
    return '寅'
  }
  if (hour < 7) {
    return '卯'
  }
  if (hour < 9) {
    return '辰'
  }
  if (hour < 11) {
    return '巳'
  }
  if (hour < 13) {
    return '午'
  }
  if (hour < 15) {
    return '未'
  }
  if (hour < 17) {
    return '申'
  }
  if (hour < 19) {
    return '酉'
  }
  if (hour < 21) {
    return '戌'
  }
  return '亥'
}