yijing-bazi-mcp/src/utils/bazi-calculator.js

易经八字分析 MCP 服务器 - 提供传统命理分析和易经卦象解读的AI工具

/**
 * 八字计算工具
 * 用于八字的排盘和计算
 */

const Logger = require('./logger.js');
const DateUtils = require('./date-utils.js');

class BaziCalculator {
  constructor() {
    this.logger = new Logger();
    this.dateUtils = new DateUtils();
    // 初始化BaziDatabase以支持getTenGod方法
    const BaziDatabase = require('../data/bazi-database.js');
    this.baziDB = new BaziDatabase();

    // 天干
    this.heavenlyStems = [
      '甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'
    ];

    // 地支
    this.earthlyBranches = [
      '子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'
    ];

    // 五行属性
    this.stemElements = {
      '甲': '木', '乙': '木', '丙': '火', '丁': '火', '戊': '土',
      '己': '土', '庚': '金', '辛': '金', '壬': '水', '癸': '水'
    };

    this.branchElements = {
      '子': '水', '丑': '土', '寅': '木', '卯': '木', '辰': '土', '巳': '火',
      '午': '火', '未': '土', '申': '金', '酉': '金', '戌': '土', '亥': '水'
    };

    // 阴阳属性
    this.stemPolarity = {
      '甲': '阳', '乙': '阴', '丙': '阳', '丁': '阴', '戊': '阳',
      '己': '阴', '庚': '阳', '辛': '阴', '壬': '阳', '癸': '阴'
    };

    this.branchPolarity = {
      '子': '阳', '丑': '阴', '寅': '阳', '卯': '阴', '辰': '阳', '巳': '阴',
      '午': '阳', '未': '阴', '申': '阳', '酉': '阴', '戌': '阳', '亥': '阴'
    };

    // 十神关系
    this.tenGods = {
      '比肩': '同我',
      '劫财': '同我',
      '食神': '我生',
      '伤官': '我生',
      '偏财': '我克',
      '正财': '我克',
      '七杀': '克我',
      '正官': '克我',
      '偏印': '生我',
      '正印': '生我'
    };
  }

  /**
   * 计算八字
   * @param {string} birthDate - 出生日期 (YYYY-MM-DD)
   * @param {string} birthTime - 出生时间 (HH:mm)
   * @param {string} timezone - 时区
   * @param {string} gender - 性别 (male/female)
   * @param {boolean} isLunar - 是否农历
   * @returns {Object} 八字数据
   */
  calculateBazi(birthDate, birthTime, timezone = 'Asia/Shanghai', gender = 'male', isLunar = false) {
    this.logger.info('开始计算八字', { birthDate, birthTime, timezone, gender, isLunar });

    try {
      // 转换为公历日期时间
      const solarDateTime = isLunar ?
        this.dateUtils.lunarToSolar(birthDate, birthTime) :
        new Date(`${birthDate}T${birthTime}:00`);

      // 计算年柱
      const yearPillar = this.calculateYearPillar(solarDateTime);

      // 计算月柱
      const monthPillar = this.calculateMonthPillar(solarDateTime, yearPillar.stem);

      // 计算日柱
      const dayPillar = this.calculateDayPillar(solarDateTime);

      // 计算时柱
      const hourPillar = this.calculateHourPillar(solarDateTime, dayPillar.stem);

      // 计算大运
      const majorLuck = this.calculateMajorLuck(yearPillar, monthPillar, gender, solarDateTime);

      // 计算流年
      const annualLuck = this.calculateAnnualLuck(solarDateTime);

      // 分析五行强弱
      const elementAnalysis = this.analyzeElements([yearPillar, monthPillar, dayPillar, hourPillar]);

      // 分析十神关系
      const tenGodsAnalysis = this.analyzeTenGods(dayPillar.stem, [yearPillar, monthPillar, dayPillar, hourPillar]);

      // 分析格局
      const patternAnalysis = this.analyzePattern([yearPillar, monthPillar, dayPillar, hourPillar], elementAnalysis);

      const bazi = {
        birth_info: {
          solar_date: solarDateTime.toISOString().split('T')[0],
          solar_time: solarDateTime.toTimeString().split(' ')[0].substring(0, 5),
          lunar_date: isLunar ? birthDate : this.dateUtils.solarToLunar(solarDateTime),
          timezone: timezone,
          gender: gender,
          is_lunar: isLunar
        },
        four_pillars: {
          year: yearPillar,
          month: monthPillar,
          day: dayPillar,
          hour: hourPillar
        },
        major_luck: majorLuck,
        annual_luck: annualLuck,
        element_analysis: elementAnalysis,
        ten_gods_analysis: tenGodsAnalysis,
        pattern_analysis: patternAnalysis,
        timestamp: new Date().toISOString()
      };

      this.logger.info('八字计算完成', { bazi });
      return bazi;

    } catch (error) {
      this.logger.error('八字计算失败', { error: error.message, birthDate, birthTime });
      throw error;
    }
  }

  /**
   * 计算年柱
   * @param {Date} date - 日期
   * @returns {Object} 年柱
   */
  calculateYearPillar(date) {
    // 立春为年的分界点
    const year = date.getFullYear();
    const springStart = this.getSpringStart(year);

    let actualYear = year;
    if (date < springStart) {
      actualYear = year - 1;
    }

    // 计算干支
    // 甲子年为1984年，每60年一个循环
    const baseYear = 1984;
    const yearOffset = (actualYear - baseYear) % 60;
    const stemIndex = yearOffset % 10;
    const branchIndex = yearOffset % 12;

    const stem = this.heavenlyStems[stemIndex < 0 ? stemIndex + 10 : stemIndex];
    const branch = this.earthlyBranches[branchIndex < 0 ? branchIndex + 12 : branchIndex];

    return {
      stem: stem,
      branch: branch,
      element: this.stemElements[stem],
      polarity: this.stemPolarity[stem],
      branch_element: this.branchElements[branch],
      branch_polarity: this.branchPolarity[branch],
      year: actualYear
    };
  }

  /**
   * 计算月柱
   * @param {Date} date - 日期
   * @param {string} yearStem - 年干
   * @returns {Object} 月柱
   */
  calculateMonthPillar(date, yearStem) {
    const month = date.getMonth() + 1;
    const day = date.getDate();

    // 确定节气月份
    const solarMonth = this.getSolarMonth(month, day);

    // 月支固定：寅月(立春)、卯月(惊蛰)、辰月(清明)...
    const monthBranches = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑'];
    const branchIndex = (solarMonth - 1) % 12;
    const branch = monthBranches[branchIndex];

    // 月干根据年干推算
    const yearStemIndex = this.heavenlyStems.indexOf(yearStem);
    const monthStemIndex = (yearStemIndex * 2 + solarMonth - 1) % 10;
    const stem = this.heavenlyStems[monthStemIndex];

    return {
      stem: stem,
      branch: branch,
      element: this.stemElements[stem],
      polarity: this.stemPolarity[stem],
      branch_element: this.branchElements[branch],
      branch_polarity: this.branchPolarity[branch],
      solar_month: solarMonth
    };
  }

  /**
   * 计算日柱
   * @param {Date} date - 日期
   * @returns {Object} 日柱
   */
  calculateDayPillar(date) {
    // 使用儒略日计算
    const julianDay = this.getJulianDay(date);

    // 甲子日的儒略日为1924681（1900年1月1日）
    const baseJulianDay = 1924681;
    const dayOffset = (julianDay - baseJulianDay) % 60;

    const stemIndex = dayOffset % 10;
    const branchIndex = dayOffset % 12;

    const stem = this.heavenlyStems[stemIndex < 0 ? stemIndex + 10 : stemIndex];
    const branch = this.earthlyBranches[branchIndex < 0 ? branchIndex + 12 : branchIndex];

    return {
      stem: stem,
      branch: branch,
      element: this.stemElements[stem],
      polarity: this.stemPolarity[stem],
      branch_element: this.branchElements[branch],
      branch_polarity: this.branchPolarity[branch],
      julian_day: julianDay
    };
  }

  /**
   * 计算时柱
   * @param {Date} date - 日期
   * @param {string} dayStem - 日干
   * @returns {Object} 时柱
   */
  calculateHourPillar(date, dayStem) {
    const hour = date.getHours();

    // 确定时辰
    const hourBranches = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
    let hourIndex;

    if (hour >= 23 || hour < 1) hourIndex = 0;  // 子时 23:00-01:00
    else if (hour >= 1 && hour < 3) hourIndex = 1;   // 丑时 01:00-03:00
    else if (hour >= 3 && hour < 5) hourIndex = 2;   // 寅时 03:00-05:00
    else if (hour >= 5 && hour < 7) hourIndex = 3;   // 卯时 05:00-07:00
    else if (hour >= 7 && hour < 9) hourIndex = 4;   // 辰时 07:00-09:00
    else if (hour >= 9 && hour < 11) hourIndex = 5;  // 巳时 09:00-11:00
    else if (hour >= 11 && hour < 13) hourIndex = 6; // 午时 11:00-13:00
    else if (hour >= 13 && hour < 15) hourIndex = 7; // 未时 13:00-15:00
    else if (hour >= 15 && hour < 17) hourIndex = 8; // 申时 15:00-17:00
    else if (hour >= 17 && hour < 19) hourIndex = 9; // 酉时 17:00-19:00
    else if (hour >= 19 && hour < 21) hourIndex = 10; // 戌时 19:00-21:00
    else hourIndex = 11; // 亥时 21:00-23:00

    const branch = hourBranches[hourIndex];

    // 时干根据日干推算
    const dayStemIndex = this.heavenlyStems.indexOf(dayStem);
    const hourStemIndex = (dayStemIndex * 2 + hourIndex) % 10;
    const stem = this.heavenlyStems[hourStemIndex];

    return {
      stem: stem,
      branch: branch,
      element: this.stemElements[stem],
      polarity: this.stemPolarity[stem],
      branch_element: this.branchElements[branch],
      branch_polarity: this.branchPolarity[branch],
      hour_index: hourIndex,
      hour_range: this.getHourRange(hourIndex)
    };
  }

  /**
   * 计算大运
   * @param {Object} yearPillar - 年柱
   * @param {Object} monthPillar - 月柱
   * @param {string} gender - 性别
   * @param {Date} birthDate - 出生日期
   * @returns {Object} 大运信息
   */
  calculateMajorLuck(yearPillar, monthPillar, gender, birthDate) {
    // 判断顺逆
    const yearStemIndex = this.heavenlyStems.indexOf(yearPillar.stem);
    const isYangYear = yearStemIndex % 2 === 0;
    const isMale = gender === 'male';

    // 阳年男命、阴年女命顺行，阴年男命、阳年女命逆行
    const isForward = (isYangYear && isMale) || (!isYangYear && !isMale);

    // 计算起运年龄（简化计算）
    const startAge = this.calculateLuckStartAge(birthDate, monthPillar, isForward);

    // 生成大运
    const majorLuckPeriods = [];
    const monthStemIndex = this.heavenlyStems.indexOf(monthPillar.stem);
    const monthBranchIndex = this.earthlyBranches.indexOf(monthPillar.branch);

    for (let i = 0; i < 8; i++) {
      const ageStart = startAge + i * 10;
      const ageEnd = ageStart + 9;

      let stemIndex, branchIndex;
      if (isForward) {
        stemIndex = (monthStemIndex + i + 1) % 10;
        branchIndex = (monthBranchIndex + i + 1) % 12;
      } else {
        stemIndex = (monthStemIndex - i - 1 + 10) % 10;
        branchIndex = (monthBranchIndex - i - 1 + 12) % 12;
      }

      const stem = this.heavenlyStems[stemIndex];
      const branch = this.earthlyBranches[branchIndex];

      majorLuckPeriods.push({
        period: i + 1,
        age_start: ageStart,
        age_end: ageEnd,
        stem: stem,
        branch: branch,
        element: this.stemElements[stem],
        branch_element: this.branchElements[branch]
      });
    }

    return {
      is_forward: isForward,
      start_age: startAge,
      periods: majorLuckPeriods
    };
  }

  /**
   * 获取天干对应的五行
   * @param {string} gan - 天干
   * @returns {string} 五行
   */
  getGanElement(gan) {
    return this.stemElements[gan] || '未知';
  }

  /**
   * 获取天干的阴阳属性
   * @param {string} gan - 天干
   * @returns {string} 阴阳属性
   */
  getGanYinYang(gan) {
    return this.stemPolarity[gan] || '未知';
  }

  /**
   * 生成大运序列
   * @param {Object} monthPillar - 月柱
   * @param {boolean} isForward - 是否顺行
   * @param {number} startAge - 起运年龄
   * @returns {Array} 大运序列
   */
  generateMajorLuckSequence(monthPillar, isForward, startAge) {
    const sequence = [];
    let currentGan = monthPillar.heavenly_stem;
    let currentZhi = monthPillar.earthly_branch;

    for (let i = 0; i < 8; i++) {
      const age = startAge + i * 10;

      if (isForward) {
        currentGan = this.getNextGan(currentGan);
        currentZhi = this.getNextZhi(currentZhi);
      } else {
        currentGan = this.getPrevGan(currentGan);
        currentZhi = this.getPrevZhi(currentZhi);
      }

      sequence.push({
        period: i + 1,
        age_range: `${age}-${age + 9}`,
        gan: currentGan,
        zhi: currentZhi,
        gan_zhi: currentGan + currentZhi,
        element: this.getGanElement(currentGan),
        yin_yang: this.getGanYinYang(currentGan)
      });
    }

    return sequence;
  }

  /**
   * 获取下一个天干
   * @param {string} gan - 当前天干
   * @returns {string} 下一个天干
   */
  getNextGan(gan) {
    const gans = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
    const index = gans.indexOf(gan);
    return gans[(index + 1) % 10];
  }

  /**
   * 获取上一个天干
   * @param {string} gan - 当前天干
   * @returns {string} 上一个天干
   */
  getPrevGan(gan) {
    const gans = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
    const index = gans.indexOf(gan);
    return gans[(index - 1 + 10) % 10];
  }

  /**
   * 获取下一个地支
   * @param {string} zhi - 当前地支
   * @returns {string} 下一个地支
   */
  getNextZhi(zhi) {
    const zhis = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
    const index = zhis.indexOf(zhi);
    return zhis[(index + 1) % 12];
  }

  /**
   * 获取上一个地支
   * @param {string} zhi - 当前地支
   * @returns {string} 上一个地支
   */
  getPrevZhi(zhi) {
    const zhis = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
    const index = zhis.indexOf(zhi);
    return zhis[(index - 1 + 12) % 12];
  }

  /**
   * 获取年份对应的干支
   * @param {number} year - 年份
   * @returns {string} 干支
   */
  getYearGanZhi(year) {
    // 以1984年甲子年为基准
    const baseYear = 1984;
    const yearDiff = year - baseYear;

    const gans = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
    const zhis = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];

    const ganIndex = (yearDiff % 10 + 10) % 10;
    const zhiIndex = (yearDiff % 12 + 12) % 12;

    return gans[ganIndex] + zhis[zhiIndex];
  }

  /**
   * 获取贵人星
   * @param {string} dayGan - 日干
   * @param {Array} zhis - 地支数组
   * @returns {Array} 贵人星
   */
  getNobleStars(dayGan, zhis) {
    const nobleStarMap = {
      '甲': ['丑', '未'], '乙': ['子', '申'], '丙': ['亥', '酉'], '丁': ['亥', '酉'],
      '戊': ['丑', '未'], '己': ['子', '申'], '庚': ['丑', '未'], '辛': ['午', '寅'],
      '壬': ['卯', '巳'], '癸': ['卯', '巳']
    };

    const nobleZhis = nobleStarMap[dayGan] || [];
    return zhis.filter(zhi => nobleZhis.includes(zhi));
  }

  /**
   * 获取桃花星
   * @param {string} dayZhi - 日支
   * @param {Array} zhis - 地支数组
   * @returns {Array} 桃花星
   */
  getPeachBlossom(dayZhi, zhis) {
    const peachBlossomMap = {
      '子': '酉', '丑': '午', '寅': '卯', '卯': '子',
      '辰': '酉', '巳': '午', '午': '卯', '未': '子',
      '申': '酉', '酉': '午', '戌': '卯', '亥': '子'
    };

    const peachBlossom = peachBlossomMap[dayZhi];
    return zhis.filter(zhi => zhi === peachBlossom);
  }

  /**
   * 获取文昌星
   * @param {string} dayGan - 日干
   * @param {Object} fourPillars - 四柱
   * @returns {Array} 文昌星
   */
  getAcademicStars(dayGan, fourPillars) {
    const academicStarMap = {
      '甲': '巳', '乙': '午', '丙': '申', '丁': '酉',
      '戊': '申', '己': '酉', '庚': '亥', '辛': '子',
      '壬': '寅', '癸': '卯'
    };

    const academicStar = academicStarMap[dayGan];
    const zhis = [fourPillars.year.earthly_branch, fourPillars.month.earthly_branch, fourPillars.day.earthly_branch, fourPillars.hour.earthly_branch];
    return zhis.filter(zhi => zhi === academicStar);
  }

  /**
   * 获取财星
   * @param {string} dayGan - 日干
   * @param {Object} fourPillars - 四柱
   * @returns {Array} 财星
   */
  getWealthStars(dayGan, fourPillars) {
    // 简化实现，返回空数组
    return [];
  }

  /**
   * 获取权力星
   * @param {string} dayGan - 日干
   * @param {Object} fourPillars - 四柱
   * @returns {Array} 权力星
   */
  getPowerStars(dayGan, fourPillars) {
    // 简化实现，返回空数组
    return [];
  }

  /**
   * 获取驿马星
   * @param {string} dayZhi - 日支
   * @param {Object} fourPillars - 四柱
   * @returns {Array} 驿马星
   */
  getTravelHorse(dayZhi, fourPillars) {
    const travelHorseMap = {
      '子': '寅', '丑': '亥', '寅': '申', '卯': '巳',
      '辰': '寅', '巳': '亥', '午': '申', '未': '巳',
      '申': '寅', '酉': '亥', '戌': '申', '亥': '巳'
    };

    const travelHorse = travelHorseMap[dayZhi];
    const zhis = [fourPillars.year.earthly_branch, fourPillars.month.earthly_branch, fourPillars.day.earthly_branch, fourPillars.hour.earthly_branch];
    return zhis.filter(zhi => zhi === travelHorse);
  }

  /**
   * 获取灾煞星
   * @param {string} dayGan - 日干
   * @param {Object} fourPillars - 四柱
   * @returns {Array} 灾煞星
   */
  getDisasterStars(dayGan, fourPillars) {
    // 简化实现，返回空数组
    return [];
  }

  /**
   * 获取地支对应的五行
   * @param {string} zhi - 地支
   * @returns {string} 五行
   */
  getZhiElement(zhi) {
    const zhiElements = {
      '子': 'water', '丑': 'earth', '寅': 'wood', '卯': 'wood',
      '辰': 'earth', '巳': 'fire', '午': 'fire', '未': 'earth',
      '申': 'metal', '酉': 'metal', '戌': 'earth', '亥': 'water'
    };
    return zhiElements[zhi] || '未知';
  }

  /**
   * 获取地支藏干
   * @param {string} zhi - 地支
   * @returns {Array} 藏干数组
   */
  getZhiHiddenGans(zhi) {
    const hiddenGans = {
      '子': [{ gan: '癸', strength: 1.0 }],
      '丑': [{ gan: '己', strength: 0.6 }, { gan: '癸', strength: 0.3 }, { gan: '辛', strength: 0.1 }],
      '寅': [{ gan: '甲', strength: 0.6 }, { gan: '丙', strength: 0.3 }, { gan: '戊', strength: 0.1 }],
      '卯': [{ gan: '乙', strength: 1.0 }],
      '辰': [{ gan: '戊', strength: 0.6 }, { gan: '乙', strength: 0.3 }, { gan: '癸', strength: 0.1 }],
      '巳': [{ gan: '丙', strength: 0.6 }, { gan: '戊', strength: 0.3 }, { gan: '庚', strength: 0.1 }],
      '午': [{ gan: '丁', strength: 0.7 }, { gan: '己', strength: 0.3 }],
      '未': [{ gan: '己', strength: 0.6 }, { gan: '丁', strength: 0.3 }, { gan: '乙', strength: 0.1 }],
      '申': [{ gan: '庚', strength: 0.6 }, { gan: '壬', strength: 0.3 }, { gan: '戊', strength: 0.1 }],
      '酉': [{ gan: '辛', strength: 1.0 }],
      '戌': [{ gan: '戊', strength: 0.6 }, { gan: '辛', strength: 0.3 }, { gan: '丁', strength: 0.1 }],
      '亥': [{ gan: '壬', strength: 0.7 }, { gan: '甲', strength: 0.3 }]
    };
    return hiddenGans[zhi] || [];
  }

  /**
   * 分析五行平衡
   * @param {Object} elements - 五行统计
   * @param {string} dayMasterElement - 日主五行
   * @returns {Object} 分析结果
   */
  analyzeFiveElementBalance(elements, dayMasterElement) {
    const total = Object.values(elements).reduce((sum, count) => sum + count, 0);
    const dayMasterStrength = elements[dayMasterElement] / total;

    let favorable_elements = [];
    let unfavorable_elements = [];

    if (dayMasterStrength < 0.2) {
      // 日主偏弱，需要生扶
      favorable_elements = this.getGeneratingElements(dayMasterElement);
      unfavorable_elements = this.getWeakeningElements(dayMasterElement);
    } else if (dayMasterStrength > 0.4) {
      // 日主偏强，需要克泄
      favorable_elements = this.getWeakeningElements(dayMasterElement);
      unfavorable_elements = this.getGeneratingElements(dayMasterElement);
    } else {
      // 日主中和
      favorable_elements = [dayMasterElement];
      unfavorable_elements = [];
    }

    return {
      balance_type: dayMasterStrength < 0.2 ? '偏弱' : dayMasterStrength > 0.4 ? '偏强' : '中和',
      day_master_strength: (dayMasterStrength * 100).toFixed(1) + '%',
      favorable_elements,
      unfavorable_elements
    };
  }

  /**
   * 获取生扶元素
   * @param {string} element - 五行
   * @returns {Array} 生扶元素
   */
  getGeneratingElements(element) {
    const generating = {
      'wood': ['water', 'wood'],
      'fire': ['wood', 'fire'],
      'earth': ['fire', 'earth'],
      'metal': ['earth', 'metal'],
      'water': ['metal', 'water']
    };
    return generating[element] || [];
  }

  /**
   * 获取克泄元素
   * @param {string} element - 五行
   * @returns {Array} 克泄元素
   */
  getWeakeningElements(element) {
    const weakening = {
      'wood': ['metal', 'fire'],
      'fire': ['water', 'earth'],
      'earth': ['wood', 'metal'],
      'metal': ['fire', 'water'],
      'water': ['earth', 'wood']
    };
    return weakening[element] || [];
  }

  /**
   * 根据地支获取季节
   * @param {string} zhi - 地支
   * @returns {string} 季节
   */
  getSeasonFromZhi(zhi) {
    const seasons = {
      '寅': '春', '卯': '春', '辰': '春',
      '巳': '夏', '午': '夏', '未': '夏',
      '申': '秋', '酉': '秋', '戌': '秋',
      '亥': '冬', '子': '冬', '丑': '冬'
    };
    return seasons[zhi] || '未知';
  }

  /**
   * 根据日干和时辰计算时干
   * @param {string} dayStem - 日干
   * @param {number} hour - 小时（0-23）
   * @returns {string} 时干
   */
  getHourGan(dayStem, hour) {
    // 确定时辰索引
    let hourIndex;
    if (hour >= 23 || hour < 1) hourIndex = 0;  // 子时
    else if (hour >= 1 && hour < 3) hourIndex = 1;   // 丑时
    else if (hour >= 3 && hour < 5) hourIndex = 2;   // 寅时
    else if (hour >= 5 && hour < 7) hourIndex = 3;   // 卯时
    else if (hour >= 7 && hour < 9) hourIndex = 4;   // 辰时
    else if (hour >= 9 && hour < 11) hourIndex = 5;  // 巳时
    else if (hour >= 11 && hour < 13) hourIndex = 6; // 午时
    else if (hour >= 13 && hour < 15) hourIndex = 7; // 未时
    else if (hour >= 15 && hour < 17) hourIndex = 8; // 申时
    else if (hour >= 17 && hour < 19) hourIndex = 9; // 酉时
    else if (hour >= 19 && hour < 21) hourIndex = 10; // 戌时
    else hourIndex = 11; // 亥时

    // 根据日干推算时干
    const dayStemIndex = this.heavenlyStems.indexOf(dayStem);
    const hourStemIndex = (dayStemIndex * 2 + hourIndex) % 10;
    return this.heavenlyStems[hourStemIndex];
  }

  /**
   * 计算流年
   * @param {Date} birthDate - 出生日期
   * @returns {Array} 流年信息
   */
  calculateAnnualLuck(birthDate) {
    const currentYear = new Date().getFullYear();
    const birthYear = birthDate.getFullYear();
    const annualLuck = [];

    // 计算近10年的流年
    for (let i = -5; i <= 5; i++) {
      const year = currentYear + i;
      const age = year - birthYear;

      // 计算该年的干支
      const baseYear = 1984; // 甲子年
      const yearOffset = (year - baseYear) % 60;
      const stemIndex = yearOffset % 10;
      const branchIndex = yearOffset % 12;

      const stem = this.heavenlyStems[stemIndex < 0 ? stemIndex + 10 : stemIndex];
      const branch = this.earthlyBranches[branchIndex < 0 ? branchIndex + 12 : branchIndex];

      annualLuck.push({
        year: year,
        age: age,
        stem: stem,
        branch: branch,
        element: this.stemElements[stem],
        branch_element: this.branchElements[branch],
        is_current: year === currentYear
      });
    }

    return annualLuck;
  }

  /**
   * 分析五行强弱
   * @param {Array} pillars - 四柱
   * @returns {Object} 五行分析
   */
  analyzeElements(pillars) {
    const elements = { '木': 0, '火': 0, '土': 0, '金': 0, '水': 0 };

    // 统计天干地支五行
    pillars.forEach(pillar => {
      elements[pillar.element] += 2; // 天干权重2
      elements[pillar.branch_element] += 1; // 地支权重1
    });

    // 找出最强和最弱的五行
    const sortedElements = Object.entries(elements).sort((a, b) => b[1] - a[1]);
    const strongest = sortedElements[0];
    const weakest = sortedElements[sortedElements.length - 1];

    // 计算日主强弱
    const dayMasterElement = pillars[2].element; // 日柱天干
    const dayMasterStrength = elements[dayMasterElement];
    const totalStrength = Object.values(elements).reduce((sum, val) => sum + val, 0);
    const strengthRatio = dayMasterStrength / totalStrength;

    let dayMasterStatus;
    if (strengthRatio > 0.4) dayMasterStatus = '偏强';
    else if (strengthRatio > 0.25) dayMasterStatus = '中和';
    else if (strengthRatio > 0.15) dayMasterStatus = '偏弱';
    else dayMasterStatus = '极弱';

    return {
      element_count: elements,
      strongest_element: { element: strongest[0], count: strongest[1] },
      weakest_element: { element: weakest[0], count: weakest[1] },
      day_master_element: dayMasterElement,
      day_master_strength: dayMasterStrength,
      day_master_status: dayMasterStatus,
      strength_ratio: strengthRatio,
      total_strength: totalStrength
    };
  }

  /**
   * 分析十神关系
   * @param {string} dayMasterStem - 日主天干
   * @param {Array} pillars - 四柱
   * @returns {Object} 十神分析
   */
  analyzeTenGods(dayMasterStem, pillars) {
    const dayMasterElement = this.stemElements[dayMasterStem];
    const dayMasterPolarity = this.stemPolarity[dayMasterStem];

    const tenGodsCount = {};
    const tenGodsPositions = [];

    pillars.forEach((pillar, index) => {
      const positions = ['年', '月', '日', '时'];

      // 分析天干十神
      const stemTenGod = this.getStemTenGod(dayMasterStem, pillar.stem);
      if (stemTenGod) {
        tenGodsCount[stemTenGod] = (tenGodsCount[stemTenGod] || 0) + 1;
        tenGodsPositions.push({
          position: positions[index],
          type: '天干',
          stem: pillar.stem,
          ten_god: stemTenGod
        });
      }

      // 分析地支藏干十神（简化处理）
      const branchHiddenStems = this.getBranchHiddenStems(pillar.branch);
      branchHiddenStems.forEach(hiddenStem => {
        const hiddenTenGod = this.getStemTenGod(dayMasterStem, hiddenStem.stem);
        if (hiddenTenGod) {
          tenGodsCount[hiddenTenGod] = (tenGodsCount[hiddenTenGod] || 0) + hiddenStem.strength;
          tenGodsPositions.push({
            position: positions[index],
            type: '地支藏干',
            branch: pillar.branch,
            hidden_stem: hiddenStem.stem,
            ten_god: hiddenTenGod,
            strength: hiddenStem.strength
          });
        }
      });
    });

    return {
      day_master: {
        stem: dayMasterStem,
        element: dayMasterElement,
        polarity: dayMasterPolarity
      },
      ten_gods_count: tenGodsCount,
      ten_gods_positions: tenGodsPositions
    };
  }

  /**
   * 分析格局
   * @param {Array} pillars - 四柱
   * @param {Object} elementAnalysis - 五行分析
   * @returns {Object} 格局分析
   */
  analyzePattern(pillars, elementAnalysis) {
    const dayMaster = pillars[2]; // 日柱
    const monthBranch = pillars[1].branch; // 月支

    // 判断是否为特殊格局
    const specialPattern = this.identifySpecialPattern(pillars, elementAnalysis);
    if (specialPattern) {
      return {
        type: '特殊格局',
        pattern: specialPattern,
        description: this.getPatternDescription(specialPattern)
      };
    }

    // 判断普通格局（以月支为准）
    const monthElement = this.branchElements[monthBranch];
    const dayMasterElement = dayMaster.element;

    let pattern;
    if (monthElement === dayMasterElement) {
      pattern = '建禄格';
    } else if (this.isElementGenerating(monthElement, dayMasterElement)) {
      pattern = '印绶格';
    } else if (this.isElementGenerating(dayMasterElement, monthElement)) {
      pattern = '食伤格';
    } else if (this.isElementDestructive(dayMasterElement, monthElement)) {
      pattern = '财格';
    } else if (this.isElementDestructive(monthElement, dayMasterElement)) {
      pattern = '官杀格';
    } else {
      pattern = '普通格局';
    }

    return {
      type: '普通格局',
      pattern: pattern,
      month_element: monthElement,
      day_master_element: dayMasterElement,
      description: this.getPatternDescription(pattern)
    };
  }

  // 辅助方法

  /**
   * 获取立春时间
   * @param {number} year - 年份
   * @returns {Date} 立春时间
   */
  getSpringStart(year) {
    // 简化计算，实际应该使用精确的节气计算
    return new Date(year, 1, 4); // 大约2月4日
  }

  /**
   * 获取节气月份
   * @param {number} month - 月份
   * @param {number} day - 日期
   * @returns {number} 节气月份
   */
  getSolarMonth(month, day) {
    // 简化处理，实际应该根据精确节气计算
    const solarMonthStart = [
      [2, 4],   // 立春
      [3, 6],   // 惊蛰
      [4, 5],   // 清明
      [5, 6],   // 立夏
      [6, 6],   // 芒种
      [7, 7],   // 小暑
      [8, 8],   // 立秋
      [9, 8],   // 白露
      [10, 8],  // 寒露
      [11, 8],  // 立冬
      [12, 7],  // 大雪
      [1, 6]    // 小寒
    ];

    for (let i = 0; i < solarMonthStart.length; i++) {
      const [startMonth, startDay] = solarMonthStart[i];
      if (month === startMonth && day >= startDay) {
        return (i + 1) % 12 || 12;
      }
    }

    return month;
  }

  /**
   * 获取儒略日
   * @param {Date} date - 日期
   * @returns {number} 儒略日
   */
  getJulianDay(date) {
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    const day = date.getDate();

    let a = Math.floor((14 - month) / 12);
    let y = year + 4800 - a;
    let m = month + 12 * a - 3;

    return day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
  }

  /**
   * 获取时辰范围
   * @param {number} hourIndex - 时辰索引
   * @returns {string} 时辰范围
   */
  getHourRange(hourIndex) {
    const ranges = [
      '23:00-01:00', '01:00-03:00', '03:00-05:00', '05:00-07:00',
      '07:00-09:00', '09:00-11:00', '11:00-13:00', '13:00-15:00',
      '15:00-17:00', '17:00-19:00', '19:00-21:00', '21:00-23:00'
    ];
    return ranges[hourIndex];
  }

  /**
   * 计算起运年龄
   * @param {Date} birthDate - 出生日期
   * @param {Object} monthPillar - 月柱
   * @param {boolean} isForward - 是否顺行
   * @returns {number} 起运年龄
   */
  calculateLuckStartAge(birthDate, monthPillar, isForward) {
    // 简化计算，实际应该根据节气精确计算
    return Math.floor(Math.random() * 8) + 1; // 1-8岁之间
  }

  /**
   * 获取天干十神
   * @param {string} dayMaster - 日主
   * @param {string} targetStem - 目标天干
   * @returns {string} 十神
   */
  getStemTenGod(dayMaster, targetStem) {
    if (dayMaster === targetStem) return null; // 日主本身

    const dayElement = this.stemElements[dayMaster];
    const dayPolarity = this.stemPolarity[dayMaster];
    const targetElement = this.stemElements[targetStem];
    const targetPolarity = this.stemPolarity[targetStem];

    // 根据五行关系和阴阳确定十神
    if (dayElement === targetElement) {
      return dayPolarity === targetPolarity ? '比肩' : '劫财';
    } else if (this.isElementGenerating(dayElement, targetElement)) {
      return dayPolarity === targetPolarity ? '食神' : '伤官';
    } else if (this.isElementDestructive(dayElement, targetElement)) {
      return dayPolarity === targetPolarity ? '偏财' : '正财';
    } else if (this.isElementDestructive(targetElement, dayElement)) {
      return dayPolarity === targetPolarity ? '七杀' : '正官';
    } else if (this.isElementGenerating(targetElement, dayElement)) {
      return dayPolarity === targetPolarity ? '偏印' : '正印';
    }

    return '未知';
  }

  /**
   * 获取十神信息
   * @param {string} god - 十神名称
   * @returns {Object|null} 十神信息
   */
  getTenGod(god) {
    return this.baziDB.getTenGod(god);
  }

  /**
   * 统计十神分布
   * @param {Object} tenGods - 十神数据
   * @returns {Object} 十神分布统计
   */
  getTenGodDistribution(tenGods) {
    const distribution = {
      '比肩': 0, '劫财': 0, '食神': 0, '伤官': 0, '偏财': 0,
      '正财': 0, '七杀': 0, '正官': 0, '偏印': 0, '正印': 0
    };

    Object.values(tenGods).forEach(pillar => {
      if (pillar.gan_ten_god) {
        distribution[pillar.gan_ten_god] = (distribution[pillar.gan_ten_god] || 0) + 1;
      }
      if (pillar.zhi_ten_god) {
        distribution[pillar.zhi_ten_god] = (distribution[pillar.zhi_ten_god] || 0) + 0.5;
      }
    });

    return distribution;
  }

  /**
   * 分析十神特点
   * @param {Object} distribution - 十神分布
   * @param {string} dayGan - 日干
   * @returns {Object} 十神特点分析
   */
  analyzeTenGodCharacteristics(distribution, dayGan) {
    const characteristics = {
      dominant_gods: [],
      personality_traits: [],
      career_tendencies: [],
      wealth_potential: '中等',
      relationship_style: '平和'
    };

    // 找出主要十神
    Object.entries(distribution).forEach(([god, count]) => {
      if (count >= 1) {
        characteristics.dominant_gods.push(god);
      }
    });

    // 根据主要十神分析特点
    if (distribution['正官'] > 0 || distribution['七杀'] > 0) {
      characteristics.personality_traits.push('有责任心', '领导能力强');
      characteristics.career_tendencies.push('管理', '公务员');
    }

    if (distribution['正财'] > 0 || distribution['偏财'] > 0) {
      characteristics.wealth_potential = '较强';
      characteristics.career_tendencies.push('商业', '金融');
    }

    if (distribution['食神'] > 0 || distribution['伤官'] > 0) {
      characteristics.personality_traits.push('有创意', '表达能力强');
      characteristics.career_tendencies.push('艺术', '创意');
    }

    return characteristics;
  }

  /**
   * 获取年份干支
   * @param {number} year - 年份
   * @returns {string} 年干支
   */
  getYearGanZhi(year) {
    // 甲子年为1984年，每60年一个循环
    const baseYear = 1984;
    const yearOffset = (year - baseYear) % 60;
    const stemIndex = yearOffset % 10;
    const branchIndex = yearOffset % 12;

    const stem = this.heavenlyStems[stemIndex < 0 ? stemIndex + 10 : stemIndex];
    const branch = this.earthlyBranches[branchIndex < 0 ? branchIndex + 12 : branchIndex];

    return stem + branch;
  }

  /**
   * 获取月份干支
   * @param {number} year - 年份
   * @param {number} month - 月份(1-12)
   * @returns {string} 月干支
   */
  getMonthGanZhi(year, month) {
    // 月支固定：寅月(立春)、卯月(惊蛰)、辰月(清明)...
    const monthBranches = ['寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥', '子', '丑'];
    const branchIndex = (month - 1) % 12;
    const branch = monthBranches[branchIndex];

    // 月干根据年干推算
    const yearGanZhi = this.getYearGanZhi(year);
    const yearStem = yearGanZhi.charAt(0);
    const yearStemIndex = this.heavenlyStems.indexOf(yearStem);
    const monthStemIndex = (yearStemIndex * 2 + month - 1) % 10;
    const stem = this.heavenlyStems[monthStemIndex];

    return stem + branch;
  }

  /**
   * 获取地支主气天干
   * @param {string} branch - 地支
   * @returns {string} 主气天干
   */
  getZhiMainGan(branch) {
    const hiddenStems = this.getBranchHiddenStems(branch);
    return hiddenStems.length > 0 ? hiddenStems[0].stem : null;
  }

  /**
   * 获取地支藏干
   * @param {string} branch - 地支
   * @returns {Array} 藏干数组
   */
  getBranchHiddenStems(branch) {
    const hiddenStems = {
      '子': [{ stem: '癸', strength: 1.0 }],
      '丑': [{ stem: '己', strength: 0.6 }, { stem: '癸', strength: 0.3 }, { stem: '辛', strength: 0.1 }],
      '寅': [{ stem: '甲', strength: 0.6 }, { stem: '丙', strength: 0.3 }, { stem: '戊', strength: 0.1 }],
      '卯': [{ stem: '乙', strength: 1.0 }],
      '辰': [{ stem: '戊', strength: 0.6 }, { stem: '乙', strength: 0.3 }, { stem: '癸', strength: 0.1 }],
      '巳': [{ stem: '丙', strength: 0.6 }, { stem: '戊', strength: 0.3 }, { stem: '庚', strength: 0.1 }],
      '午': [{ stem: '丁', strength: 0.7 }, { stem: '己', strength: 0.3 }],
      '未': [{ stem: '己', strength: 0.6 }, { stem: '丁', strength: 0.3 }, { stem: '乙', strength: 0.1 }],
      '申': [{ stem: '庚', strength: 0.6 }, { stem: '壬', strength: 0.3 }, { stem: '戊', strength: 0.1 }],
      '酉': [{ stem: '辛', strength: 1.0 }],
      '戌': [{ stem: '戊', strength: 0.6 }, { stem: '辛', strength: 0.3 }, { stem: '丁', strength: 0.1 }],
      '亥': [{ stem: '壬', strength: 0.7 }, { stem: '甲', strength: 0.3 }]
    };

    return hiddenStems[branch] || [];
  }

  /**
   * 判断五行相生关系
   * @param {string} element1 - 五行1
   * @param {string} element2 - 五行2
   * @returns {boolean} 是否相生
   */
  isElementGenerating(element1, element2) {
    const generatingCycles = {
      '木': '火',
      '火': '土',
      '土': '金',
      '金': '水',
      '水': '木'
    };

    return generatingCycles[element1] === element2;
  }

  /**
   * 判断五行相克关系
   * @param {string} element1 - 五行1
   * @param {string} element2 - 五行2
   * @returns {boolean} 是否相克
   */
  isElementDestructive(element1, element2) {
    const destructiveCycles = {
      '木': '土',
      '火': '金',
      '土': '水',
      '金': '木',
      '水': '火'
    };

    return destructiveCycles[element1] === element2;
  }

  /**
   * 识别特殊格局
   * @param {Array} pillars - 四柱
   * @param {Object} elementAnalysis - 五行分析
   * @returns {string|null} 特殊格局名称
   */
  identifySpecialPattern(pillars, elementAnalysis) {
    // 从革格（金旺）
    if (elementAnalysis.strongest_element.element === '金' &&
      elementAnalysis.strongest_element.count >= 8) {
      return '从革格';
    }

    // 炎上格（火旺）
    if (elementAnalysis.strongest_element.element === '火' &&
      elementAnalysis.strongest_element.count >= 8) {
      return '炎上格';
    }

    // 润下格（水旺）
    if (elementAnalysis.strongest_element.element === '水' &&
      elementAnalysis.strongest_element.count >= 8) {
      return '润下格';
    }

    // 曲直格（木旺）
    if (elementAnalysis.strongest_element.element === '木' &&
      elementAnalysis.strongest_element.count >= 8) {
      return '曲直格';
    }

    // 稼穑格（土旺）
    if (elementAnalysis.strongest_element.element === '土' &&
      elementAnalysis.strongest_element.count >= 8) {
      return '稼穑格';
    }

    return null;
  }

  /**
   * 获取格局描述
   * @param {string} pattern - 格局名称
   * @returns {string} 格局描述
   */
  getPatternDescription(pattern) {
    const descriptions = {
      '建禄格': '日主与月支同气，身强有力，适合创业发展',
      '印绶格': '月支生助日主，聪明好学，适合文职工作',
      '食伤格': '日主生月支，才华横溢，适合创意工作',
      '财格': '日主克月支，善于理财，适合商业发展',
      '官杀格': '月支克日主，有责任心，适合管理工作',
      '从革格': '金气极旺，性格刚强，适合技术工作',
      '炎上格': '火气极旺，热情积极，适合表演艺术',
      '润下格': '水气极旺，智慧灵活，适合流动性工作',
      '曲直格': '木气极旺，仁慈正直，适合教育工作',
      '稼穑格': '土气极旺，诚实稳重，适合农业地产'
    };

    return descriptions[pattern] || '格局特殊，需要综合分析';
  }

  /**
   * 验证八字数据
   * @param {Object} bazi - 八字数据
   * @returns {boolean} 是否有效
   */
  validateBazi(bazi) {
    if (!bazi || typeof bazi !== 'object') {
      return false;
    }

    // 检查必要字段
    const requiredFields = ['birth_info', 'four_pillars', 'element_analysis'];
    for (const field of requiredFields) {
      if (!bazi[field]) {
        return false;
      }
    }

    // 检查四柱
    const pillars = ['year', 'month', 'day', 'hour'];
    for (const pillar of pillars) {
      if (!bazi.four_pillars[pillar] ||
        !bazi.four_pillars[pillar].stem ||
        !bazi.four_pillars[pillar].branch) {
        return false;
      }
    }

    return true;
  }
}

module.exports = BaziCalculator;