Untitled

 avatar
unknown
plain_text
a month ago
78 kB
3
Indexable
import 'dart:math';

class Time {
  /// Converts a solar date to Julian Day Number (JDN)
  static int jdFromDate(int day, int month, int year) {
    final a = ((14 - month) / 12).floor();
    final y = year + 4800 - a;
    final m = month + 12 * a - 3;
    
    var jd = day + ((153 * m + 2) / 5).floor() + 365 * y + 
             (y / 4).floor() - (y / 100).floor() + 
             (y / 400).floor() - 32045;
             
    if (jd < 2299161) {
      jd = day + ((153 * m + 2) / 5).floor() + 365 * y + 
           (y / 4).floor() - 32083;
    }
    return jd;
  }

  /// Converts Julian Day Number (JDN) to solar date
  static List<int> jdToDate(int jd) {
    int a, b, c;
    if (jd > 2299160) {
      a = jd + 32044;
      b = ((4 * a + 3) / 146097).floor();
      c = a - ((b * 146097) / 4).floor();
    } else {
      b = 0;
      c = jd + 32082;
    }
    
    final d = ((4 * c + 3) / 1461).floor();
    final e = c - ((1461 * d) / 4).floor();
    final m = ((5 * e + 2) / 153).floor();
    
    final day = e - ((153 * m + 2) / 5).floor() + 1;
    final month = m + 3 - 12 * (m / 10).floor();
    final year = b * 100 + d - 4800 + (m / 10).floor();
    
    return [day, month, year];
  }

  /// Calculates the Julian Day Number of the k-th new moon
  static double newMoon(int k) {
    final T = k / 1236.85;
    final T2 = T * T;
    final T3 = T2 * T;
    final dr = pi / 180;
    
    var Jd1 = 2415020.75933 + 29.53058868 * k + 
              0.0001178 * T2 - 0.000000155 * T3;
    Jd1 += 0.00033 * sin((166.56 + 132.87 * T - 0.009173 * T2) * dr);

    final M = 359.2242 + 29.10535608 * k - 0.0000333 * T2 - 0.00000347 * T3;
    final Mpr = 306.0253 + 385.81691806 * k + 0.0107306 * T2 + 0.00001236 * T3;
    final F = 21.2964 + 390.67050646 * k - 0.0016528 * T2 - 0.00000239 * T3;

    var C1 = (0.1734 - 0.000393 * T) * sin(M * dr) + 0.0021 * sin(2 * dr * M);
    C1 -= 0.4068 * sin(Mpr * dr) + 0.0161 * sin(2 * dr * Mpr);
    C1 -= 0.0004 * sin(3 * dr * Mpr);
    C1 += 0.0104 * sin(2 * dr * F) - 0.0051 * sin((M + Mpr) * dr);
    C1 -= 0.0074 * sin((M - Mpr) * dr) + 0.0004 * sin((2 * F + M) * dr);
    C1 -= 0.0004 * sin((2 * F - M) * dr) - 0.0006 * sin((2 * F + Mpr) * dr);
    C1 += 0.0010 * sin((2 * F - Mpr) * dr) + 0.0005 * sin((2 * Mpr + M) * dr);

    final deltat = (T < -11)
        ? 0.001 + 0.000839 * T + 0.0002261 * T2 - 0.00000845 * T3 - 0.000000081 * T * T3
        : -0.000278 + 0.000265 * T + 0.000262 * T2;

    return Jd1 + C1 - deltat;
  }

  /// Gets the Julian Day Number of the k-th new moon
  static int getNewMoonDay(int k, int timeZone) {
    return (newMoon(k) + 0.5 + timeZone / 24).floor();
  }

  /// Gets the sun's longitude at a given Julian Day Number
  static int getSunLongitude(int jdn, int timeZone) {
    final T = (jdn - 2451545.5 - timeZone / 24) / 36525;
    final T2 = T * T;
    final dr = pi / 180;
    
    final M = 357.52910 + 35999.05030 * T - 0.0001559 * T2 - 0.00000048 * T2 * T;
    final L0 = 280.46645 + 36000.76983 * T + 0.0003032 * T2;
    
    var DL = (1.914600 - 0.004817 * T - 0.000014 * T2) * sin(dr * M);
    DL += (0.019993 - 0.000101 * T) * sin(dr * 2 * M) + 0.000290 * sin(dr * 3 * M);
    
    var L = L0 + DL;
    final omega = 125.04 - 1934.136 * T;
    L = L - 0.00569 - 0.00478 * sin(omega * dr);
    L = L * dr;
    L = L - pi * 2 * (L / (pi * 2)).floor();
    
    return (L / pi * 6).floor();
  }

  /// Gets the Julian Day Number of the 11th month of the lunar year
  static int getLunarMonth11(int year, int timeZone) {
    final off = jdFromDate(31, 12, year) - 2415021;
    final k = (off / 29.530588853).floor();
    var nm = getNewMoonDay(k, timeZone);
    final sunLong = getSunLongitude(nm, timeZone);
    
    if (sunLong >= 9) {
      nm = getNewMoonDay(k - 1, timeZone);
    }
    return nm;
  }

  /// Gets the offset of the leap month
  static int getLeapMonthOffset(int a11, int timeZone) {
    final k = ((a11 - 2415021.076998695) / 29.530588853 + 0.5).floor();
    var i = 1;
    var arc = getSunLongitude(getNewMoonDay(k + i, timeZone), timeZone);
    var last = arc;
    
    while (true) {
      last = arc;
      i++;
      arc = getSunLongitude(getNewMoonDay(k + i, timeZone), timeZone);
      if (!(arc != last && i < 14)) {
        break;
      }
    }
    return i - 1;
  }

  /// Converts a solar date to lunar date
  /// Returns a list containing [lunarDay, lunarMonth, lunarYear, isLeapMonth]
  static List<int> S2L(int day, int month, int year, [int timeZone = 7]) {
    final dayNumber = jdFromDate(day, month, year);
    final k = ((dayNumber - 2415021.076998695) / 29.530588853).floor();
    
    var monthStart = getNewMoonDay(k + 1, timeZone);
    if (monthStart > dayNumber) {
      monthStart = getNewMoonDay(k, timeZone);
    }
    
    var a11 = getLunarMonth11(year, timeZone);
    var b11 = a11;
    int lunarYear;
    
    if (a11 >= monthStart) {
      lunarYear = year;
      a11 = getLunarMonth11(year - 1, timeZone);
    } else {
      lunarYear = year + 1;
      b11 = getLunarMonth11(year + 1, timeZone);
    }
    
    final lunarDay = dayNumber - monthStart + 1;
    final diff = ((monthStart - a11) / 29).floor();
    var lunarLeap = 0;
    var lunarMonth = diff + 11;
    
    if (b11 - a11 > 365) {
      final leapMonthDiff = getLeapMonthOffset(a11, timeZone);
      if (diff >= leapMonthDiff) {
        lunarMonth = diff + 10;
        if (diff == leapMonthDiff) {
          lunarLeap = 1;
        }
      }
    }
    
    if (lunarMonth > 12) {
      lunarMonth -= 12;
    }
    if (lunarMonth >= 11 && diff < 4) {
      lunarYear -= 1;
    }
    
    return [lunarDay, lunarMonth, lunarYear, lunarLeap];
  }

  /// Converts a lunar date to solar date
  static List<int> L2S(int lunarDay, int lunarMonth, int lunarYear, bool isLeapMonth, [int timeZone = 7]) {
    // Implement the conversion logic here
    // This is a placeholder implementation
    return [lunarDay, lunarMonth, lunarYear]; // Replace with actual conversion logic
  }
}

class AmDuong {
  /// List of Thien Can (Heavenly Stems)
  static final List<Map<String, dynamic>> thienCan = [
    {
      'id': 0,
      'chuCaiDau': null,
      'tenCan': null,
      'nguHanh': null,
      'nguHanhID': null,
      'vitriDiaBan': null,
      'amDuong': null,
    },
    {
      'id': 1,
      'chuCaiDau': 'G',
      'tenCan': 'Giáp',
      'nguHanh': 'M',
      'nguHanhID': 2,
      'vitriDiaBan': 3,
      'amDuong': 1,
    },
    {
      'id': 2,
      'chuCaiDau': 'A',
      'tenCan': 'Ất',
      'nguHanh': 'M',
      'nguHanhID': 2,
      'vitriDiaBan': 4,
      'amDuong': -1,
    },
    {
      'id': 3,
      'chuCaiDau': 'B',
      'tenCan': 'Bính',
      'nguHanh': 'H',
      'nguHanhID': 4,
      'vitriDiaBan': 6,
      'amDuong': 1,
    },
    {
      'id': 4,
      'chuCaiDau': 'D',
      'tenCan': 'Đinh',
      'nguHanh': 'H',
      'nguHanhID': 4,
      'vitriDiaBan': 7,
      'amDuong': -1,
    },
    {
      'id': 5,
      'chuCaiDau': 'M',
      'tenCan': 'Mậu',
      'nguHanh': 'O',
      'nguHanhID': 5,
      'vitriDiaBan': 6,
      'amDuong': 1,
    },
    {
      'id': 6,
      'chuCaiDau': 'K',
      'tenCan': 'Kỷ',
      'nguHanh': 'O',
      'nguHanhID': 5,
      'vitriDiaBan': 7,
      'amDuong': -1,
    },
    {
      'id': 7,
      'chuCaiDau': 'C',
      'tenCan': 'Canh',
      'nguHanh': 'K',
      'nguHanhID': 1,
      'vitriDiaBan': 9,
      'amDuong': 1,
    },
    {
      'id': 8,
      'chuCaiDau': 'T',
      'tenCan': 'Tân',
      'nguHanh': 'K',
      'nguHanhID': 1,
      'vitriDiaBan': 10,
      'amDuong': -1,
    },
    {
      'id': 9,
      'chuCaiDau': 'N',
      'tenCan': 'Nhâm',
      'nguHanh': 'T',
      'nguHanhID': 3,
      'vitriDiaBan': 12,
      'amDuong': 1,
    },
    {
      'id': 10,
      'chuCaiDau': 'Q',
      'tenCan': 'Quý',
      'nguHanh': 'T',
      'nguHanhID': 3,
      'vitriDiaBan': 1,
      'amDuong': -1,
    },
  ];

  /// List of Dia Chi (Earthly Branches)
  static final List<Map<String, dynamic>> diaChi = [
    {'id': 0, 'tenChi': 'Hem có', 'tenHanh': ':D', 'amDuong': 0},
    {
      'id': 1,
      'tenChi': 'Tý',
      'tenHanh': 'T',
      'menhChu': 'Tham lang',
      'thanChu': 'Linh tinh',
      'amDuong': 1,
    },
    {
      'id': 2,
      'tenChi': 'Sửu',
      'tenHanh': 'O',
      'menhChu': 'Cự môn',
      'thanChu': 'Thiên tướng',
      'amDuong': -1,
    },
    {
      'id': 3,
      'tenChi': 'Dần',
      'tenHanh': 'M',
      'menhChu': 'Lộc tồn',
      'thanChu': 'Thiên lương',
      'amDuong': 1,
    },
    {
      'id': 4,
      'tenChi': 'Mão',
      'tenHanh': 'M',
      'menhChu': 'Văn khúc',
      'thanChu': 'Thiên đồng',
      'amDuong': -1,
    },
    {
      'id': 5,
      'tenChi': 'Thìn',
      'tenHanh': 'O',
      'menhChu': 'Liêm trinh',
      'thanChu': 'Văn xương',
      'amDuong': 1,
    },
    {
      'id': 6,
      'tenChi': 'Tỵ',
      'tenHanh': 'H',
      'menhChu': 'Vũ khúc',
      'thanChu': 'Thiên cơ',
      'amDuong': -1,
    },
    {
      'id': 7,
      'tenChi': 'Ngọ',
      'tenHanh': 'H',
      'menhChu': 'Phá quân',
      'thanChu': 'Hỏa tinh',
      'amDuong': 1,
    },
    {
      'id': 8,
      'tenChi': 'Mùi',
      'tenHanh': 'O',
      'menhChu': 'Vũ khúc',
      'thanChu': 'Thiên tướng',
      'amDuong': -1,
    },
    {
      'id': 9,
      'tenChi': 'Thân',
      'tenHanh': 'K',
      'menhChu': 'Liêm trinh',
      'thanChu': 'Thiên lương',
      'amDuong': 1,
    },
    {
      'id': 10,
      'tenChi': 'Dậu',
      'tenHanh': 'K',
      'menhChu': 'Văn khúc',
      'thanChu': 'Thiên đồng',
      'amDuong': -1,
    },
    {
      'id': 11,
      'tenChi': 'Tuất',
      'tenHanh': 'O',
      'menhChu': 'Lộc tồn',
      'thanChu': 'Văn xương',
      'amDuong': 1,
    },
    {
      'id': 12,
      'tenChi': 'Hợi',
      'tenHanh': 'T',
      'menhChu': 'Cự môn',
      'thanChu': 'Thiên cơ',
      'amDuong': -1,
    },
  ];

  /// Converts solar date to lunar date
   static List<int> ngayThangNam(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
    int thangNhuan = 0;
    if (nn > 0 && nn < 32 && tt > 0 && tt < 13) {
      if (duongLich) {
        final result = Time.S2L(nn, tt, nnnn, timeZone);
        nn = result[0];
        tt = result[1];
        nnnn = result[2];
        thangNhuan = result[3];
      }
      return [nn, tt, nnnn, thangNhuan];
    } else {
      throw ArgumentError('Ngày, tháng, năm không chính xác.');
    }
  }

  /// Calculates Can Chi for day
  static List<int> canChiNgay(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7, bool thangNhuan = false}) {
    if (!duongLich) {
      final result = Time.L2S(nn, tt, nnnn, thangNhuan, timeZone);
      nn = result[0];
      tt = result[1];
      nnnn = result[2];
    }
    int jd = Time.jdFromDate(nn, tt, nnnn);
    int canNgay = ((jd + 9) % 10) + 1;
    int chiNgay = ((jd + 1) % 12) + 1;
    return [canNgay, chiNgay];
  }

  /// Calculates Can Chi for month and year
  static List<int> ngayThangNamCanChi(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
    int thangNhuan = 0;
    if (duongLich) {
      final result = ngayThangNam(nn, tt, nnnn, timeZone: timeZone);
      nn = result[0];
      tt = result[1];
      nnnn = result[2];
      thangNhuan = result[3];
    }
    int canThang = ((nnnn * 12 + tt + 3) % 10) + 1;
    int canNamSinh = ((nnnn + 6) % 10) + 1;
    int chiNam = ((nnnn + 8) % 12) + 1;
    return [canThang, canNamSinh, chiNam];
  }

  /// Gets the Five Elements (Ngũ Hành) information
  static Map<String, dynamic> nguHanh(String tenHanh) {
    final hanhMap = {
      'Kim': {'id': 1, 'tenHanh': 'Kim', 'cuc': 4, 'tenCuc': 'Kim tứ Cục', 'css': 'hanhKim'},
      'K': {'id': 1, 'tenHanh': 'Kim', 'cuc': 4, 'tenCuc': 'Kim tứ Cục', 'css': 'hanhKim'},
      'Moc': {'id': 2, 'tenHanh': 'Mộc', 'cuc': 3, 'tenCuc': 'Mộc tam Cục', 'css': 'hanhMoc'},
      'M': {'id': 2, 'tenHanh': 'Mộc', 'cuc': 3, 'tenCuc': 'Mộc tam Cục', 'css': 'hanhMoc'},
      'Thuy': {'id': 3, 'tenHanh': 'Thủy', 'cuc': 2, 'tenCuc': 'Thủy nhị Cục', 'css': 'hanhThuy'},
      'T': {'id': 3, 'tenHanh': 'Thủy', 'cuc': 2, 'tenCuc': 'Thủy nhị Cục', 'css': 'hanhThuy'},
      'Hoa': {'id': 4, 'tenHanh': 'Hỏa', 'cuc': 6, 'tenCuc': 'Hỏa lục Cục', 'css': 'hanhHoa'},
      'H': {'id': 4, 'tenHanh': 'Hỏa', 'cuc': 6, 'tenCuc': 'Hỏa lục Cục', 'css': 'hanhHoa'},
      'Tho': {'id': 5, 'tenHanh': 'Thổ', 'cuc': 5, 'tenCuc': 'Thổ ngũ Cục', 'css': 'hanhTho'},
      'O': {'id': 5, 'tenHanh': 'Thổ', 'cuc': 5, 'tenCuc': 'Thổ ngũ Cục', 'css': 'hanhTho'},
    };

    if (hanhMap.containsKey(tenHanh)) {
      return hanhMap[tenHanh]!;
    } else {
      throw ArgumentError('Tên Hành phải thuộc Kim (K), Mộc (M), Thủy (T), Hỏa (H) hoặc Thổ (O)');
    }
  }

  /// Calculates the relationship between two elements
  static int? sinhKhac(int hanh1, int hanh2) {
    final matranSinhKhac = [
      [null, null, null, null, null, null],
      [null, 0, -1, 1, -1, 1],
      [null, -1, 0, 1, 1, -1],
      [null, 1, 1, 0, 1, -1],
      [null, -1, 1, -1, 0, 1],
      [null, 1, -1, -1, 1, 0],
    ];
    return matranSinhKhac[hanh1][hanh2];
  }

  /// Calculates the Five Elements Nạp Âm
  static String nguHanhNapAm(int diaChi, int thienCan, {bool xuatBanMenh = false}) {
    final banMenh = {
      'K1': 'HẢI TRUNG KIM',
      'T1': 'GIÁNG HẠ THỦY',
      'H1': 'TÍCH LỊCH HỎA',
      'O1': 'BÍCH THƯỢNG THỔ',
      'M1': 'TANG ÐỐ MỘC',
      'T2': 'ÐẠI KHÊ THỦY',
      'H2': 'LƯ TRUNG HỎA',
      'O2': 'THÀNH ÐẦU THỔ',
      'M2': 'TÒNG BÁ MỘC',
      'K2': 'KIM BẠCH KIM',
      'H3': 'PHÚ ÐĂNG HỎA',
      'O3': 'SA TRUNG THỔ',
      'M3': 'ÐẠI LÂM MỘC',
      'K3': 'BẠCH LẠP KIM',
      'T3': 'TRƯỜNG LƯU THỦY',
      'K4': 'SA TRUNG KIM',
      'T4': 'THIÊN HÀ THỦY',
      'H4': 'THIÊN THƯỢNG HỎA',
      'O4': 'LỘ BÀN THỔ',
      'M4': 'DƯƠNG LIỄU MỘC',
      'T5': 'TRUYỀN TRUNG THỦY',
      'H5': 'SƠN HẠ HỎA',
      'O5': 'ÐẠI TRẠCH THỔ',
      'M5': 'THẠCH LỰU MỘC',
      'K5': 'KIẾM PHONG KIM',
      'H6': 'SƠN ÐẦU HỎA',
      'O6': 'ỐC THƯỢNG THỔ',
      'M6': 'BÌNH ÐỊA MỘC',
      'K6': 'XOA XUYẾN KIM',
      'T6': 'ÐẠI HẢI THỦY',
    };

    final matranNapAm = [
      [0, 'G', 'Ất', 'Bính', 'Đinh', 'Mậu', 'Kỷ', 'Canh', 'Tân', 'N', 'Q'],
      [1, 'K1', false, 'T1', false, 'H1', false, 'O1', false, 'M1', false],
      [2, false, 'K1', false, 'T1', false, 'H1', false, 'O1', false, 'M1'],
      [3, 'T2', false, 'H2', false, 'O2', false, 'M2', false, 'K2', false],
      [4, false, 'T2', false, 'H2', false, 'O2', false, 'M2', false, 'K2'],
      [5, 'H3', false, 'O3', false, 'M3', false, 'K3', false, 'T3', false],
      [6, false, 'H3', false, 'O3', false, 'M3', false, 'K3', false, 'T3'],
      [7, 'K4', false, 'T4', false, 'H4', false, 'O4', false, 'M4', false],
      [8, false, 'K4', false, 'T4', false, 'H4', false, 'O4', false, 'M4'],
      [9, 'T5', false, 'H5', false, 'O5', false, 'M5', false, 'K5', false],
      [10, false, 'T5', false, 'H5', false, 'O5', false, 'M5', false, 'K5'],
      [11, 'H6', false, 'O6', false, 'M6', false, 'K6', false, 'T6', false],
      [12, false, 'H6', false, 'O6', false, 'M6', false, 'K6', false, 'T6'],
    ];

    if (diaChi < 0 || diaChi >= matranNapAm.length) {
     throw Exception('Chỉ số địa chi không hợp lệ');
    }
    if (thienCan < 0 || thienCan >= matranNapAm[diaChi].length) {
      throw Exception('Chỉ số thiên can không hợp lệ');
    }

    final dynamic nh = matranNapAm[diaChi][thienCan];

    if (nh != false && nh is String && ['K', 'M', 'T', 'H', 'O'].contains(nh[0])) {
      return xuatBanMenh ? banMenh[nh] ?? '' : nh[0];
    }

    throw Exception('Không tìm thấy ngũ hành nạp âm hợp lệ');
  }

  /// Moves a position in the chart
  static int dichCung(int cungBanDau, List<int> soCungDich) {
    int cungSauKhiDich = cungBanDau;
    for (final soCung in soCungDich) {
      cungSauKhiDich += soCung;
    }
    if (cungSauKhiDich <= 0) {
      cungSauKhiDich += 12;
    }
    return cungSauKhiDich % 12 == 0 ? 12 : cungSauKhiDich % 12;
  }

  /// Calculates distance between two positions 
  static int khoangCachCung(int cung1, int cung2, int chieu) {
    return chieu == 1 ? (cung1 - cung2 + 12) % 12 : (cung2 - cung1 + 12) % 12;
  }

  /// Finds the Five Elements group (Cục)
  static String timCuc(int viTriCungMenhTrenDiaBan, int canNamSinh) {
    int canThangGieng = (canNamSinh * 2 + 1) % 10;
    int kcCungMenhVaCungThangGieng = viTriCungMenhTrenDiaBan - 3 < 0
        ? viTriCungMenhTrenDiaBan - 3 + 12
        : viTriCungMenhTrenDiaBan - 3;
    int canThangMenh = ((kcCungMenhVaCungThangGieng % 12) + canThangGieng) % 10;
    if (canThangMenh == 0) {
      canThangMenh = 10;
    }
    return nguHanhNapAm(viTriCungMenhTrenDiaBan, canThangMenh);
  }

  /// Finds the Tử Vi position
  static int timTuVi(int cuc, int ngaySinhAmLich) {
    int cungDan = 3; // Vị trí cung Dần ban đầu là 3
    final cucBanDau = cuc;
    if (![2, 3, 4, 5, 6].contains(cuc)) {
      throw Exception('Số cục phải là 2, 3, 4, 5, 6');
    }
    while (cuc < ngaySinhAmLich) {
      cuc += cucBanDau;
      cungDan += 1;
    }
    int saiLech = cuc - ngaySinhAmLich;
    if (saiLech % 2 == 1) {
      saiLech = -saiLech;
    }
    return dichCung(cungDan, [saiLech]);
  }

  /// Finds the Trường Sinh position
  static int timTrangSinh(int cucSo) {
    switch (cucSo) {
      case 6:
        return 3; // Hỏa lục cục - Tràng sinh ở Dần
      case 4:
        return 6; // Kim tứ cục - Tràng sinh ở Tỵ
      case 2:
      case 5:
        return 9; // Thủy nhị cục, Thổ ngũ cục - Tràng sinh ở Thân
      case 3:
        return 12; // Mộc tam cục - Tràng sinh ở Hợi
      default:
        throw Exception('Không tìm được cung an sao Trường sinh');
    }
  }

  /// Finds Hỏa Tinh and Linh Tinh positions
  static List<int> timHoaLinh(int chiNamSinh, int gioSinh, int gioiTinh, int amDuongNamSinh) {
    int khoiCungHoaTinh, khoiCungLinhTinh;

    if ([3, 7, 11].contains(chiNamSinh)) {
      khoiCungHoaTinh = 2;
      khoiCungLinhTinh = 4;
    } else if ([1, 5, 9].contains(chiNamSinh)) {
      khoiCungHoaTinh = 3;
      khoiCungLinhTinh = 11;
    } else if ([6, 10, 2].contains(chiNamSinh)) {
      khoiCungHoaTinh = 4;
      khoiCungLinhTinh = 11;
    } else if ([12, 4, 8].contains(chiNamSinh)) {
      khoiCungHoaTinh = 10;
      khoiCungLinhTinh = 11;
    } else {
      throw Exception('Không thể khởi cung tìm Hỏa-Linh');
    }

    int viTriHoaTinh, viTriLinhTinh;

    if (gioiTinh * amDuongNamSinh == -1) {
      viTriHoaTinh = dichCung(khoiCungHoaTinh + 1, [-gioSinh]);
      viTriLinhTinh = dichCung(khoiCungLinhTinh - 1, [gioSinh]);
    } else if (gioiTinh * amDuongNamSinh == 1) {
      viTriHoaTinh = dichCung(khoiCungHoaTinh - 1, [gioSinh]);
      viTriLinhTinh = dichCung(khoiCungLinhTinh + 1, [-gioSinh]);
    } else {
      throw Exception('Không thể tính vị trí Hỏa-Linh');
    }

    return [viTriHoaTinh, viTriLinhTinh];
  }

  /// Finds Thiên Khoi position
  static int timThienKhoi(int canNam) {
    final thienKhoi = [null, 2, 1, 12, 12, 2, 1, 7, 7, 4, 4];
    if (canNam >= 1 && canNam <= 10) {
        return thienKhoi[canNam] ?? 0;
    } else {
        throw Exception('Không tìm được vị trí Khôi-Việt');
    }
  }

  /// Finds Thiên Quan and Thiên Phúc positions
  static List<int> timThienQuanThienPhuc(int canNam) {
    final thienQuan = [null, 8, 5, 6, 3, 4, 10, 12, 10, 11, 7];
    final thienPhuc = [null, 10, 9, 1, 12, 4, 3, 7, 6, 7, 6];
    if (canNam >= 1 && canNam <= 10) {
        return [
            thienQuan[canNam] ?? 0,
            thienPhuc[canNam] ?? 0
        ];
    } else {
        throw Exception('Không tìm được Quan-Phúc');
    }
  }

  /// Finds Cô Thần position
  static int timCoThan(int chiNam) {
    if ([12, 1, 2].contains(chiNam)) {
      return 3;
    } else if ([3, 4, 5].contains(chiNam)) {
      return 6;
    } else if ([6, 7, 8].contains(chiNam)) {
      return 9;
    } else {
      return 12;
    }
  }

  /// Finds Thiên Mã position
  static int timThienMa(int chiNam) {
    final demNghich = chiNam % 4;
    switch (demNghich) {
      case 1:
        return 3;
      case 2:
        return 12;
      case 3:
        return 9;
      case 0:
        return 6;
      default:
        throw Exception('Không tìm được Thiên mã');
    }
  }

  /// Finds Phá Toái position
  static int timPhaToai(int chiNam) {
    final demNghich = chiNam % 3;
    switch (demNghich) {
      case 0:
        return 6;
      case 1:
        return 10;
      case 2:
        return 2;
      default:
        throw Exception('Không tìm được Phá toái');
    }
  }

  /// Finds Triệt position
  static List<int> timTriet(int canNam) {
    switch (canNam) {
      case 1:
      case 6:
        return [9, 10]; // Giáp Kỷ, Thân Dậu cung
      case 2:
      case 7:
        return [7, 8]; // Ất Canh, Ngọ Mùi cung
      case 3:
      case 8:
        return [5, 6]; // Bính Tân, Thìn Tị cung
      case 4:
      case 9:
        return [3, 4]; // Đinh Nhâm, Dần Mão cung
      case 5:
      case 10:
        return [1, 2]; // Mậu Quý, Tý Sửu cung
      default:
        throw Exception('Không tìm được Triệt');
    }
  }

  /// Finds Lưu Hà and Thiên Trù positions
  static List<int> timLuuTru(int canNam) {
    final maTranLuuHa = [null, 10, 11, 7, 9, 1, 7, 4, 5, 12, 3];
    final maTranThienTru = [null, 6, 7, 1, 6, 7, 9, 3, 7, 10, 11];
    if (canNam >= 1 && canNam <= 10) {
      return [
        maTranLuuHa[canNam] ?? 0,
        maTranThienTru[canNam] ?? 0
      ];
    } else {
      throw Exception('Không tìm được Lưu - Trù');
    }
  }
}


class CungDiaBan {
  int cungSo;
  String hanhCung;
  List<Sao> cungSao = [];
  int cungAmDuong;
  String cungTen;
  bool cungThan = false;
  String? cungChuTen;
  int? cungDaiHan;
  String? cungTieuHan;
  String? nguyetHan;
  bool tuanTrung = false;
  bool luuTuanTrung = false;
  bool trietLo = false;
  bool luuTrietLo = false;

  CungDiaBan(this.cungSo)
      : hanhCung = hanhCungList[cungSo],
        cungAmDuong = cungSo % 2 == 0 ? -1 : 1,
        cungTen = AmDuong.diaChi[cungSo]['tenChi'];

  static const List<String> hanhCungList = [
    '',
    'Thủy', 'Thổ', 'Mộc', 'Mộc', 'Thổ', 'Hỏa',
    'Hỏa', 'Thổ', 'Kim', 'Kim', 'Thổ', 'Thủy'
  ];

  CungDiaBan themSao(List<Sao> saoList) {
    for (var sao in saoList) {
      dacTinhSao(cungSo, sao);
      cungSao.add(sao);
    }
    return this;
  }

  CungDiaBan cungChu(String tenCungChu) {
    cungChuTen = tenCungChu;
    return this;
  }

  CungDiaBan daiHan(int daiHan) {
    cungDaiHan = daiHan;
    return this;
  }

  CungDiaBan tieuHan(int tieuHan) {
    cungTieuHan = AmDuong.diaChi[tieuHan + 1]['tenChi'];
    return this;
  }

  CungDiaBan nguyetHanMethod(int nguyetHanValue) {
    nguyetHan = 'Tháng $nguyetHanValue';
    return this;
  }

  void anCungThan() => cungThan = true;
  void anTuan() => tuanTrung = true;
  void anLuuTuan() => luuTuanTrung = true;
  void anTriet() => trietLo = true;
  void anLuuTriet() => luuTrietLo = true;

  @override
  String toString() {
    return 'CungDiaBan(cungAmDuong: $cungAmDuong, cungChu: $cungChuTen, cungDaiHan: $cungDaiHan, cungSao: $cungSao, cungSo: $cungSo, cungTen: $cungTen, cungThan: $cungThan, cungTieuHan: $cungTieuHan, hanhCung: $hanhCung)';
  }
}

class DiaBan {
  int thangSinhAmLich;
  int gioSinhAmLich;
  late List<CungDiaBan> thapNhiCung;
  int cungThan = 0;
  int cungMenh = 0;
  int cungNoboc = 0;
  int cungTatAch = 0;

  DiaBan(this.thangSinhAmLich, this.gioSinhAmLich) {
    thapNhiCung = List.generate(13, (i) => CungDiaBan(i));
    nhapCungChu();
    nhapCungThan();
  }

  List<Map<String, dynamic>> cungChu(int thangSinh, int gioSinh) {
    cungThan = AmDuong.dichCung(3, [thangSinh - 1, gioSinh - 1]);
    cungMenh = AmDuong.dichCung(3, [thangSinh - 1, -gioSinh + 1]);

    int cungPhuMau = AmDuong.dichCung(cungMenh, [1]);
    int cungPhucDuc = AmDuong.dichCung(cungMenh, [2]);
    int cungDienTrach = AmDuong.dichCung(cungMenh, [3]);
    int cungQuanLoc = AmDuong.dichCung(cungMenh, [4]);
    cungNoboc = AmDuong.dichCung(cungMenh, [5]);
    int cungThienDi = AmDuong.dichCung(cungMenh, [6]);
    cungTatAch = AmDuong.dichCung(cungMenh, [7]);
    int cungTaiBach = AmDuong.dichCung(cungMenh, [8]);
    int cungTuTuc = AmDuong.dichCung(cungMenh, [9]);
    int cungTheThiep = AmDuong.dichCung(cungMenh, [10]);
    int cungHuynhDe = AmDuong.dichCung(cungMenh, [11]);


    return [
      {'cungId': 1, 'tenCung': 'Mệnh', 'cungSoDiaBan': cungMenh},
      {'cungId': 2, 'tenCung': 'Phụ mẫu', 'cungSoDiaBan': cungPhuMau},
      {'cungId': 3, 'tenCung': 'Phúc đức', 'cungSoDiaBan': cungPhucDuc},
      {'cungId': 4, 'tenCung': 'Điền trạch', 'cungSoDiaBan': cungDienTrach},
      {'cungId': 5, 'tenCung': 'Quan lộc', 'cungSoDiaBan': cungQuanLoc},
      {'cungId': 6, 'tenCung': 'Nô bộc', 'cungSoDiaBan': cungNoboc},
      {'cungId': 7, 'tenCung': 'Thiên di', 'cungSoDiaBan': cungThienDi},
      {'cungId': 8, 'tenCung': 'Tật Ách', 'cungSoDiaBan': cungTatAch},
      {'cungId': 9, 'tenCung': 'Tài Bạch', 'cungSoDiaBan': cungTaiBach},
      {'cungId': 10, 'tenCung': 'Tử tức', 'cungSoDiaBan': cungTuTuc},
      {'cungId': 11, 'tenCung': 'Phu thê', 'cungSoDiaBan': cungTheThiep},
      {'cungId': 12, 'tenCung': 'Huynh đệ', 'cungSoDiaBan': cungHuynhDe},
    ];
  }

  DiaBan nhapCungChu() {
    for (var cung in cungChu(thangSinhAmLich, gioSinhAmLich)) {
      thapNhiCung[cung['cungSoDiaBan']].cungChu(cung['tenCung']);
    }
    return this;
  }

  DiaBan nhapCungThan() {
    thapNhiCung[cungThan].anCungThan();
    return this;
  }

  DiaBan nhapDaiHan(int cucSo, int gioiTinh) {
    for (var cung in thapNhiCung) {
      int kc = AmDuong.khoangCachCung(cung.cungSo, cungMenh, gioiTinh);
      cung.daiHan(cucSo + kc * 10);
    }
    return this;
  }

  DiaBan nhapTieuHan(int khoiTieuHan, int gioiTinh, int chiNam) {
    int viTriCungTy1 = AmDuong.dichCung(khoiTieuHan, [-gioiTinh * (chiNam - 1)]);
    for (var cung in thapNhiCung) {
      int kc = AmDuong.khoangCachCung(cung.cungSo, viTriCungTy1, gioiTinh);
      cung.tieuHan(kc);
    }
    return this;
  }

  DiaBan nhapNguyetVan(int chiNam, int thangSinh, int gioSinh) {
    int viTriBatDau = 1;
    for (var cung in thapNhiCung) {
      if (cung.cungTieuHan == AmDuong.diaChi[chiNam]['tenChi']) {
        viTriBatDau = cung.cungSo;
      }
    }
    int viTriThang1 = AmDuong.dichCung(viTriBatDau, [gioSinh - thangSinh]);
    for (var cung in thapNhiCung) {
      int kc = cung.cungSo - viTriThang1;
      if (kc < 0) kc += 12;
      cung.nguyetHanMethod(kc + 1);
    }
    return this;
  }

  DiaBan nhapSao(int cungSo, List<Sao> saoList) {
    for (var sao in saoList) {
      thapNhiCung[cungSo].themSao([sao]);
    }
    return this;
  }

  DiaBan nhapTuan(List<int> cungList) {
    for (var cung in cungList) {
      thapNhiCung[cung].anTuan();
    }
    return this;
  }

  DiaBan nhapLuuTuan(List<int> cungList) {
    for (var cung in cungList) {
      thapNhiCung[cung].anLuuTuan();
    }
    return this;
  }

  DiaBan nhapTriet(List<int> cungList) {
    for (var cung in cungList) {
      thapNhiCung[cung].anTriet();
    }
    return this;
  }

  DiaBan nhapLuuTriet(List<int> cungList) {
    for (var cung in cungList) {
      thapNhiCung[cung].anLuuTriet();
    }
    return this;
  }
}


void dacTinhSao(int viTriDiaBan, Sao sao) {
    const Map<int, List<dynamic>> maTranDacTinh = {
      1: ["Tử vi", "B", "Đ", "M", "B", "V", "M", "M", "Đ", "M", "B", "V", "B"],
      2: ["Liêm trinh", "V", "Đ", "V", "H", "M", "H", "V", "Đ", "V", "H", "M", "H"],
      3: ["Thiên đồng", "V", "H", "M", "Đ", "H", "Đ", "H", "H", "M", "H", "H", "Đ"],
      4: ["Vũ khúc", "V", "M", "V", "Đ", "M", "H", "V", "M", "V", "Đ", "M", "H"],
      5: ["Thái dương", "H", "Đ", "V", "V", "V", "M", "M", "Đ", "H", "H", "H", "H"],
      6: ["Thiên cơ", "Đ", "Đ", "H", "M", "M", "V", "Đ", "Đ", "V", "M", "M", "H"],
      8: ["Thái âm", "V", "Đ", "H", "H", "H", "H", "H", "Đ", "V", "M", "M", "M"],
      9: ["Tham lang", "H", "M", "Đ", "H", "V", "H", "H", "M", "Đ", "H", "V", "H"],
      10: ["Cự môn", "V", "H", "V", "M", "H", "H", "V", "H", "Đ", "M", "H", "Đ"],
      11: ["Thiên tướng", "V", "Đ", "M", "H", "V", "Đ", "V", "Đ", "M", "H", "V", "Đ"],
      12: ["Thiên lương", "V", "Đ", "V", "V", "M", "H", "M", "Đ", "V", "H", "M", "H"],
      13: ["Thất sát", "M", "Đ", "M", "H", "H", "V", "M", "Đ", "M", "H", "H", "V"],
      14: ["Phá quân", "M", "V", "H", "H", "Đ", "H", "M", "V", "H", "H", "Đ", "H"],
      51: ["Đà la", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H"],
      52: ["Kình dương", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H"],
      55: ["Linh tinh", "H", "H", "Đ", "Đ", "Đ", "Đ", "Đ", "H", "H", "H", "H", "H"],
      56: ["Hỏa tinh", "H", "H", "Đ", "Đ", "Đ", "Đ", "Đ", "H", "H", "H", "H", "H"],
      57: ["Văn xương", "H", "Đ", "H", "Đ", "H", "Đ", "H", "Đ", "H", "H", "Đ", "Đ"],
      58: ["Văn khúc", "H", "Đ", "H", "Đ", "H", "Đ", "H", "Đ", "H", "H", "Đ", "Đ"],
      53: ["Địa không", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ"],
      54: ["Địa kiếp", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ", "H", "H", "Đ"],
      95: ["Hóa kỵ", null, "Đ", null, null, "Đ", null, null, "Đ", null, null, "Đ", null],
      36: ["Đại hao", null, null, "Đ", "Đ", null, null, null, null, "Đ", "Đ", null, null],
      30: ["Tiểu Hao", null, null, "Đ", "Đ", null, null, null, null, "Đ", "Đ", null, null],
      69: ["Thiên khốc", "Đ", "Đ", null, "Đ", null, null, "Đ", "Đ", null, "Đ", null, null],
      70: ["Thiên hư", "Đ", "Đ", null, "Đ", null, null, "Đ", "Đ", null, "Đ", null, null],
      98: ["Thiên mã", null, null, "Đ", null, null, "Đ", null, null, null, null, null, null],
      73: ["Thiên Hình", null, null, "Đ", "Đ", null, null, null, null, "Đ", "Đ", null, null],
      74: ["Thiên riêu", null, null, "Đ", "Đ", null, null, null, null, null, "Đ", "Đ", null],
    };

      if (maTranDacTinh.containsKey(sao.saoID)) {
        final dacTinh = maTranDacTinh[sao.saoID]![viTriDiaBan];
        if (["M", "V", "Đ", "B", "H"].contains(dacTinh)) {
          sao.anDacTinh(dacTinh);
        }
      }
}



DiaBan lapDiaBan(
  int nn,
  int tt,
  int nnnn,
  int gioSinh,
  int gioiTinh,
  bool duongLich,
  int timeZone,
  int? namXemTieuVan,
) {
  int canThang, canNam, chiNam, thangNhuan, canLuuThang, canLuuNam, chiLuuNam;

  List<int> ngayThangNam(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
   return AmDuong.ngayThangNam(
    nn,
    tt,
    nnnn,
    duongLich: duongLich,
    timeZone: timeZone,
   );
  }


  List<int> ngayThangNamCanChi(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
  return AmDuong.ngayThangNamCanChi(
    nn,
    tt,
    nnnn,
    duongLich: duongLich,
    timeZone: timeZone,
  );
  }


   Map<String, dynamic> nguHanh(String tenHanh){
    return AmDuong.nguHanh(tenHanh);
  }

   int dichCung(int cungBanDau, List<int> soCungDich) {
   return AmDuong.dichCung(cungBanDau, soCungDich);
  }

  if (duongLich) {
    // Assuming ngayThangNam returns a List<int>
  List<int> result = ngayThangNam(
   nn,
   tt,
   nnnn,
   duongLich: duongLich,
   timeZone: timeZone,
  );
    nn = result[0];
    tt = result[1];
    nnnn = result[2];
    thangNhuan = result[3];
  }

  List<int> canChiResult = ngayThangNamCanChi(
    nn,
    tt,
    nnnn,
    duongLich: false,
    timeZone: timeZone,
  );

  canThang = canChiResult[0];
  canNam = canChiResult[1];
  chiNam = canChiResult[2];
  List<int> canLuuResult = ngayThangNamCanChi(5, 5, namXemTieuVan!, duongLich : false, timeZone: timeZone);
  canLuuThang = canLuuResult[0];
  canLuuNam = canLuuResult[1];
  chiLuuNam = canLuuResult[2];

  DiaBan diaBan = DiaBan(tt, gioSinh);

  int amDuongNamSinh = AmDuong.thienCan[canNam]['amDuong'] as int;

  int amDuongChiNamSinh = AmDuong.diaChi[chiNam]['amDuong'] as int;

  // Bản Mệnh chính là Ngũ hành nạp âm của năm sinh
  // int banMenh = nguHanhNapAm(canNam, chiNam);

  String hanhCuc = AmDuong.timCuc(diaBan.cungMenh, canNam);
  var cuc = nguHanh(hanhCuc);
  int cucSo = cuc["cuc"];

  // Nhập đại hạn khi đã biết được số cục
  diaBan.nhapDaiHan(cucSo, gioiTinh * amDuongChiNamSinh);

  // Nhập tiểu hạn
  int khoiHan = dichCung(11, [-3 * (chiNam - 1)]);
  diaBan.nhapTieuHan(khoiHan, gioiTinh, chiNam);

  // Bắt đầu an Tử vi tinh hệ
  int viTriTuVi = AmDuong.timTuVi(cucSo, nn);
  diaBan.nhapSao(viTriTuVi, [saoTuVi]);

  int viTriLiemTrinh = dichCung(viTriTuVi, [4]);
diaBan.nhapSao(viTriLiemTrinh, [saoLiemTrinh]);

int viTriThienDong = dichCung(viTriTuVi, [7]);
diaBan.nhapSao(viTriThienDong, [saoThienDong]);

int viTriVuKhuc = dichCung(viTriTuVi, [8]);
diaBan.nhapSao(viTriVuKhuc, [saoVuKhuc]);

int vitriThaiDuong = dichCung(viTriTuVi, [9]);
diaBan.nhapSao(vitriThaiDuong, [saoThaiDuong]);

int viTriThienCo = dichCung(viTriTuVi, [11]);
diaBan.nhapSao(viTriThienCo, [saoThienCo]);

// Thiên phủ tinh hệ
int viTriThienPhu = dichCung(3, [3 - viTriTuVi]);
diaBan.nhapSao(viTriThienPhu, [saoThienPhu]);

int viTriThaiAm = dichCung(viTriThienPhu, [1]);
diaBan.nhapSao(viTriThaiAm, [saoThaiAm]);

int viTriThamLang = dichCung(viTriThienPhu, [2]);
diaBan.nhapSao(viTriThamLang, [saoThamLang]);

int viTriCuMon = dichCung(viTriThienPhu, [3]);
diaBan.nhapSao(viTriCuMon, [saoCuMon]);

int viTriThienTuong = dichCung(viTriThienPhu, [4]);
diaBan.nhapSao(viTriThienTuong, [saoThienTuong]);

int viTriThienLuong = dichCung(viTriThienPhu, [5]);
diaBan.nhapSao(viTriThienLuong, [saoThienLuong]);

int viTriThatSat = dichCung(viTriThienPhu, [6]);
diaBan.nhapSao(viTriThatSat, [saoThatSat]);

int viTriPhaQuan = dichCung(viTriThienPhu, [10]);
diaBan.nhapSao(viTriPhaQuan, [saoPhaQuan]);
  
  // Vòng Lộc tồn
  int viTriLocTon = AmDuong.thienCan[canNam]['vitriDiaBan'] as int;
diaBan.nhapSao(viTriLocTon, [saoLocTon, saoBacSy]);

int amDuongNamNu = gioiTinh * amDuongNamSinh;

int viTriLucSi = dichCung(viTriLocTon, [1 * amDuongNamNu]);
diaBan.nhapSao(viTriLucSi, [saoLucSi]);

int viTriThanhLong = dichCung(viTriLocTon, [2 * amDuongNamNu]);
diaBan.nhapSao(viTriThanhLong, [saoThanhLong]);

int viTriTieuHao = dichCung(viTriLocTon, [3 * amDuongNamNu]);
diaBan.nhapSao(viTriTieuHao, [saoTieuHao]);

int viTriTuongQuan = dichCung(viTriLocTon, [4 * amDuongNamNu]);
diaBan.nhapSao(viTriTuongQuan, [saoTuongQuan]);

int viTriTauThu = dichCung(viTriLocTon, [5 * amDuongNamNu]);
diaBan.nhapSao(viTriTauThu, [saoTauThu]);

int viTriPhiLiem = dichCung(viTriLocTon, [6 * amDuongNamNu]);
diaBan.nhapSao(viTriPhiLiem, [saoPhiLiem]);

int viTriHyThan = dichCung(viTriLocTon, [7 * amDuongNamNu]);
diaBan.nhapSao(viTriHyThan, [saoHyThan]);

int viTriDaiHao = dichCung(viTriLocTon, [9 * amDuongNamNu]);
diaBan.nhapSao(viTriDaiHao, [saoDaiHao]);

int viTriPhucBinh = dichCung(viTriLocTon, [10 * amDuongNamNu]);
diaBan.nhapSao(viTriPhucBinh, [saoPhucBinh]);

int viTriQuanPhu2 = dichCung(viTriLocTon, [11 * amDuongNamNu]);
diaBan.nhapSao(viTriQuanPhu2, [saoQuanPhu2]);

  // Vòng Địa chi - Thái tuế
  int viTriThaiTue = chiNam;
  diaBan.nhapSao(viTriThaiTue, [saoThaiTue]);

  int viTriThieuDuong = dichCung(viTriThaiTue, [1]);
  diaBan.nhapSao(viTriThieuDuong, [saoThieuDuong, saoThienKhong]);

  int viTriTangMon = dichCung(viTriThaiTue, [2]);
  diaBan.nhapSao(viTriTangMon, [saoTangMon]);

  int viTriQuanPhu3 = dichCung(viTriThaiTue, [4]);
  diaBan.nhapSao(viTriQuanPhu3, [saoQuanPhu3]);

  int viTriBachHo = dichCung(viTriThaiTue, [8]);
  diaBan.nhapSao(viTriBachHo, [saoBachHo]);

  int viTriPhucDuc = dichCung(viTriThaiTue, [9]);
  diaBan.nhapSao(viTriPhucDuc, [saoPhucDuc]);

  int viTriDaLa = dichCung(viTriLocTon, [-1]);
  diaBan.nhapSao(viTriDaLa, [saoDaLa]);

  int viTriKinhDuong = dichCung(viTriLocTon, [1]);
  diaBan.nhapSao(viTriKinhDuong, [saoKinhDuong]);

  // Không - Kiếp
  int viTriDiaKiep = dichCung(11, [gioSinh]);
  diaBan.nhapSao(viTriDiaKiep, [saoDiaKiep]);

  List<int> viTriHoaTinhLinhTinh = AmDuong.timHoaLinh(chiNam, gioSinh, gioiTinh, amDuongNamSinh);
  diaBan.nhapSao(viTriHoaTinhLinhTinh[0], [saoHoaTinh]);
  diaBan.nhapSao(viTriHoaTinhLinhTinh[1], [saoLinhTinh]);

  int viTriLongTri = dichCung(5, [chiNam - 1]);
  diaBan.nhapSao(viTriLongTri, [saoLongTri]);

  int viTriPhuongCac = dichCung(2, [2 - viTriLongTri]);
  diaBan.nhapSao(viTriPhuongCac, [saoPhuongCac, saoGiaiThan]);

  int viTriTaPhu = dichCung(5, [tt - 1]);
  diaBan.nhapSao(viTriTaPhu, [saoTaPhu]);

  int viTriHuuBat = dichCung(2, [2 - viTriTaPhu]);
  diaBan.nhapSao(viTriHuuBat, [saoHuuBat]);

  int viTriVanKhuc = dichCung(5, [gioSinh - 1]);
  diaBan.nhapSao(viTriVanKhuc, [saoVanKhuc]);

  int viTriVanXuong = dichCung(2, [2 - viTriVanKhuc]);
  diaBan.nhapSao(viTriVanXuong, [saoVanXuong]);

  int viTriThienKhoi = AmDuong.timThienKhoi(canNam);
  diaBan.nhapSao(viTriThienKhoi, [saoThienKhoi]);

  int viTriThienViet = dichCung(5, [5 - viTriThienKhoi]);
  diaBan.nhapSao(viTriThienViet, [saoThienViet]);

  int viTriThienHu = dichCung(7, [chiNam - 1]);
  diaBan.nhapSao(viTriThienHu, [saoThienHu]);

  int viTriThienKhoc = dichCung(7, [-chiNam + 1]);
  diaBan.nhapSao(viTriThienKhoc, [saoThienKhoc]);

  int viTriHongLoan = dichCung(4, [-chiNam + 1]);
  diaBan.nhapSao(viTriHongLoan, [saoHongLoan]);

  int viTriThienHy = dichCung(viTriHongLoan,[ 6]);
  diaBan.nhapSao(viTriThienHy, [saoThienHy]);

  int viTriThienHinh = dichCung(10, [tt - 1]);
  diaBan.nhapSao(viTriThienHinh, [saoThienHinh]);

  int viTriThienRieu = dichCung(viTriThienHinh,[4]);
  diaBan.nhapSao(viTriThienRieu, [saoThienRieu, saoThienY]);

  int viTriCoThan = AmDuong.timCoThan(chiNam);
  diaBan.nhapSao(viTriCoThan, [saoCoThan]);

  int viTriQuaTu = dichCung(viTriCoThan, [-4]);
  diaBan.nhapSao(viTriQuaTu, [saoQuaTu]);

  int viTriVanTinh = dichCung(viTriKinhDuong, [2]);
  // diaBan.nhapSao(viTriVanTinh, [saoVanTinh]);

  int viTriDuongPhu = dichCung(viTriVanTinh, [2]);
  // diaBan.nhapSao(viTriDuongPhu, [saoDuongPhu]);

  int viTriQuocAn = dichCung(viTriDuongPhu, [3]);
  diaBan.nhapSao(viTriQuocAn, [saoQuocAn]);

  // Vòng Thiên mã
  int viTriThienMa = AmDuong.timThienMa(chiNam);
  diaBan.nhapSao(viTriThienMa, [saoThienMa]);

  int viTriHoaCai = dichCung(viTriThienMa, [2]);
  diaBan.nhapSao(viTriHoaCai, [saoHoaCai]);

  int viTriKiepSat = dichCung(viTriThienMa, [3]);
  diaBan.nhapSao(viTriKiepSat, [saoKiepSat]);

  int viTriDaoHoa = dichCung(viTriKiepSat, [4]);
  diaBan.nhapSao(viTriDaoHoa, [saoDaoHoa]);

  int viTriHoaLoc = 0;
int viTriHoaQuyen = 0;
int viTriHoaKhoa = 0;
int viTriHoaKy = 0;

  switch (canNam) {
    case 1:
      viTriHoaLoc = viTriLiemTrinh;
      viTriHoaQuyen = viTriPhaQuan;
      viTriHoaKhoa = viTriVuKhuc;
      viTriHoaKy = vitriThaiDuong;
      break;
    case 2:
      viTriHoaLoc = viTriThienCo;
      viTriHoaQuyen = viTriThienLuong;
      viTriHoaKhoa = viTriTuVi;
      viTriHoaKy = viTriThaiAm;
      break;
    case 3:
      viTriHoaLoc = viTriThienDong;
      viTriHoaQuyen = viTriThienCo;
      viTriHoaKhoa = viTriVanXuong;
      viTriHoaKy = viTriLiemTrinh;
      break;
    case 4:
      viTriHoaLoc = viTriThaiAm;
      viTriHoaQuyen = viTriThienDong;
      viTriHoaKhoa = viTriThienCo;
      viTriHoaKy = viTriCuMon;
      break;
    case 5:
      viTriHoaLoc = viTriThamLang;
      viTriHoaQuyen = viTriThaiAm;
      viTriHoaKhoa = viTriHuuBat;
      viTriHoaKy = viTriThienCo;
      break;
    case 6:
      viTriHoaLoc = viTriVuKhuc;
      viTriHoaQuyen = viTriThamLang;
      viTriHoaKhoa = viTriThienLuong;
      viTriHoaKy = viTriVanKhuc;
      break;
    case 7:
      viTriHoaLoc = vitriThaiDuong;
      viTriHoaQuyen = viTriVuKhuc;
      viTriHoaKhoa = viTriThaiAm;
      viTriHoaKy = viTriThienDong;
      break;
    case 8:
      viTriHoaLoc = viTriCuMon;
      viTriHoaQuyen = vitriThaiDuong;
      viTriHoaKhoa = viTriVanKhuc;
      viTriHoaKy = viTriVanXuong;
      break;
    case 9:
      viTriHoaLoc = viTriThienLuong;
      viTriHoaQuyen = viTriTuVi;
      viTriHoaKhoa = viTriTaPhu;
      viTriHoaKy = viTriVuKhuc;
      break;
    case 10:
      viTriHoaLoc = viTriPhaQuan;
      viTriHoaQuyen = viTriCuMon;
      viTriHoaKhoa = viTriThaiAm;
      viTriHoaKy = viTriThamLang;
      break;
  }

  diaBan.nhapSao(viTriHoaLoc, [saoHoaLoc]);
  diaBan.nhapSao(viTriHoaQuyen, [saoHoaQuyen]);
  diaBan.nhapSao(viTriHoaKhoa, [saoHoaKhoa]);
  diaBan.nhapSao(viTriHoaKy, [saoHoaKy]);

  // An Lưu Hà - Thiên Trù
  List<int> viTriLuuHaThienTru = AmDuong.timLuuTru(canNam);
  diaBan.nhapSao(viTriLuuHaThienTru[0], [saoLuuHa]);
  diaBan.nhapSao(viTriLuuHaThienTru[1], [saoThienTru]);

  // An Tuần, Triệt
  int ketThucTuan = dichCung(chiNam, [10 - canNam]);
  int viTriTuan1 = dichCung(ketThucTuan, [1]);
  int viTriTuan2 = dichCung(viTriTuan1, [1]);
  diaBan.nhapTuan([viTriTuan1, viTriTuan2]);

  List<int> viTriTriet1Triet2 = AmDuong.timTriet(canNam);
  diaBan.nhapTriet([viTriTriet1Triet2[0], viTriTriet1Triet2[1]]);

  if (namXemTieuVan != null) {
    diaBan = diaBan.nhapNguyetVan(chiLuuNam, tt, gioSinh);

    int viTriLuuThienKhoi = AmDuong.timThienKhoi(canLuuNam);
    diaBan.nhapSao(viTriLuuThienKhoi, [saoLuuThienKhoi]);

    int viTriLuuThienViet = dichCung(5, [5 - viTriLuuThienKhoi]);
    diaBan.nhapSao(viTriLuuThienViet, [saoLuuThienViet]);

    int viTriLuuLocTon = AmDuong.thienCan[canLuuNam]["vitriDiaBan"];
    diaBan.nhapSao(viTriLuuLocTon, [saoLuuLocTon]);

    int viTriLuuThaiTue = chiLuuNam;
    diaBan.nhapSao(viTriLuuThaiTue, [saoLuuThaiTue]);

    int viTriLuuTangMon = dichCung(viTriLuuThaiTue, [2]);
    diaBan.nhapSao(viTriLuuTangMon, [saoLuuTangMon]);

    int viTriLuuBachHo = dichCung(viTriLuuThaiTue, [8]);
    diaBan.nhapSao(viTriLuuBachHo, [saoLuuBachHo]);

    int viTriLuuThienMa = AmDuong.timThienMa(chiLuuNam);
    diaBan.nhapSao(viTriLuuThienMa, [saoLuuThienMa]);

    int viTriLuuDaoHoa = dichCung(viTriLuuThienMa, [7]);
    diaBan.nhapSao(viTriLuuDaoHoa, [saoLuuDaoHoa]);

    int viTriLuuHongLoan = dichCung(4, [-chiLuuNam + 1]);
    diaBan.nhapSao(viTriLuuHongLoan, [saoLuuHongLoan]);

    int viTriLuuThienKhoc = dichCung(7, [-chiLuuNam + 1]);
    diaBan.nhapSao(viTriLuuThienKhoc, [saoLuuThienKhoc]);

    int viTriLuuDaLa = dichCung(viTriLuuLocTon, [-1]);
    diaBan.nhapSao(viTriLuuDaLa, [saoLuuDaLa]);

    int viTriLuuKinhDuong = dichCung(viTriLuuLocTon, [1]);
    diaBan.nhapSao(viTriLuuKinhDuong, [saoLuuKinhDuong]);

    int viTriLuuThienHu = dichCung(7, [chiLuuNam - 1]);
    diaBan.nhapSao(viTriLuuThienHu, [saoLuuThienHu]);

    int viTriLuuLongTri = dichCung(5, [chiLuuNam - 1]);

    int viTriLuuPhuongCac = dichCung(2, [2 - viTriLuuLongTri]);
    diaBan.nhapSao(viTriLuuPhuongCac, [saoLuuPhuongCac]);

    int viTriLuuTuongQuan = dichCung(viTriLuuLocTon,[ 4 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuTuongQuan, [saoLuuTuongQuan]);

    int viTriLuuTauThu = dichCung(viTriLuuLocTon, [5 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuTauThu, [saoLuuTauThu]);

    int viTriLuuDuongPhu = dichCung(viTriLuuKinhDuong, [4]);
    diaBan.nhapSao(viTriLuuDuongPhu, [saoLuuDuongPhu]);

    int viTriLuuQuanPhu3 = dichCung(viTriLuuThaiTue, [4]);
    diaBan.nhapSao(viTriLuuQuanPhu3, [saoLuuQuanPhu3]);

    int viTriLuuPhiLiem = dichCung(viTriLuuLocTon,[ 6 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuPhiLiem, [saoLuuPhiLiem]);

    int viTriLuuHyThan = dichCung(viTriLuuLocTon, [7 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuHyThan, [saoLuuHyThan]);

    List<int> viTriLuuLuuHaThienTru = AmDuong.timLuuTru(canLuuNam);
    diaBan.nhapSao(viTriLuuLuuHaThienTru[0], [saoLuuLuuHa]);

    int viTriLuuQuocAn = dichCung(viTriLuuDuongPhu, [3]);
    diaBan.nhapSao(viTriLuuQuocAn, [saoLuuQuocAn]);

    int viTriLuuBenhPhu = dichCung(viTriLuuLocTon, [8 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuBenhPhu, [saoLuuBenhPhu]);

    int viTriLuuDaiHao = dichCung(viTriLuuLocTon, [9 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuDaiHao, [saoLuuDaiHao]);

    int viTriLuuPhucBinh = dichCung(viTriLuuLocTon, [10 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuPhucBinh, [saoLuuPhucBinh]);

    int viTriLuuCoThan = AmDuong.timCoThan(chiLuuNam);
    diaBan.nhapSao(viTriLuuCoThan, [saoLuuCoThan]);

    int viTriLuuQuaTu = dichCung(viTriLuuCoThan, [-4]);
    diaBan.nhapSao(viTriLuuQuaTu, [saoLuuQuaTu]);

    int viTriLuuQuanPhu2 = dichCung(viTriLuuLocTon, [11 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuQuanPhu2, [saoLuuQuanPhu2]);

    int viTriLuuDieuKhach = dichCung(viTriLuuThaiTue, [10]);
    diaBan.nhapSao(viTriLuuDieuKhach, [saoLuuDieuKhach]);

    int viTriLuuLucSi = dichCung(viTriLuuLocTon, [1 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuLucSi, [saoLuuLucSi]);

    int viTriLuuThanhLong = dichCung(viTriLuuLocTon,[ 2 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuThanhLong, [saoLuuThanhLong]);

    int viTriLuuHoaCai = dichCung(viTriLuuThienMa, [2]);
    diaBan.nhapSao(viTriLuuHoaCai, [saoLuuHoaCai]);

    int viTriLuuThienHy = dichCung(viTriLuuHongLoan, [6]);
    diaBan.nhapSao(viTriLuuThienHy, [saoLuuThienHy]);

    int viTriLuuTieuHao = dichCung(viTriLuuLocTon, [3 * amDuongNamNu]);
    diaBan.nhapSao(viTriLuuTieuHao, [saoLuuTieuHao]);

    List<int> viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy = [0, 0, 0, 0];

    switch (canLuuNam) {
      case 1:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriLiemTrinh;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriPhaQuan;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriVuKhuc;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = vitriThaiDuong;
        break;
      case 2:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriThienCo;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriThienLuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriTuVi;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriThaiAm;
        break;
      case 3:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriThienDong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriThienCo;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriVanXuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriLiemTrinh;
        break;
      case 4:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriThaiAm;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriThienDong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriThienCo;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriCuMon;
        break;
      case 5:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriThamLang;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriThaiAm;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriHuuBat;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriThienCo;
        break;
      case 6:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriVuKhuc;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriThamLang;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriThienLuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriVanKhuc;
        break;
      case 7:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = vitriThaiDuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriVuKhuc;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriThienDong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriThaiAm;
        break;
      case 8:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriCuMon;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = vitriThaiDuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriVanKhuc;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriVanXuong;
        break;
      case 9:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriThienLuong;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriTuVi;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriTaPhu;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriVuKhuc;
        break;
      case 10:
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0] = viTriPhaQuan;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1] = viTriCuMon;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2] = viTriThaiAm;
        viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3] = viTriThamLang;
        break;
    }

    diaBan.nhapSao(viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[0], [saoLuuHoaLoc]);
    diaBan.nhapSao(viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[1], [saoLuuHoaQuyen]);
    diaBan.nhapSao(viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[2], [saoLuuHoaKhoa]);
    diaBan.nhapSao(viTriLuuHoaLocLuuHoaQuyenLuuHoaKhoaLuuHoaKy[3], [saoLuuHoaKy]);
  }

  return diaBan;
}


class Sao {
  final int saoID;
  final String saoTen;
  final String saoNguHanh;
  final int saoLoai;
  final String saoPhuongVi;
  final dynamic saoAmDuong;
  final int vongTrangSinh;
  final bool saoLuuNien;
  final String cssSao;

  String? saoDacTinh;
  int? saoViTriCung;

  Sao(
    this.saoID,
    this.saoTen, {
    this.saoNguHanh = '',
    this.saoLoai = 2,
    this.saoPhuongVi = '',
    this.saoAmDuong = '',
    this.vongTrangSinh = 0,
    this.saoLuuNien = false,
  }) : cssSao = AmDuong.nguHanh(saoNguHanh)['css'];

  Sao anDacTinh(String dacTinh) {
    saoDacTinh = dacTinh;
    return this;
  }

  Sao anCung(int saoViTriCung) {
    this.saoViTriCung = saoViTriCung;
    return this;
  }
 @override
 String toString() {
  return 'Sao(cssSao: $cssSao, saoAmDuong: $saoAmDuong, saoDacTinh: $saoDacTinh, saoId: $saoID, saoLoai: $saoLoai, saoLuuNien: $saoLuuNien, saoNguHanh: $saoNguHanh, saoPhuongVi: $saoPhuongVi, saoTen: $saoTen, vongTrangSinh: $vongTrangSinh)';
 }
}




// Tử vi tinh hệ
final saoTuVi = Sao(
  1,
  "Tử vi",
  saoNguHanh: "O",
  saoLoai: 1,
  saoPhuongVi: "Đế tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoLiemTrinh = Sao(
  2,
  "Liêm trinh",
  saoNguHanh: "H",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoThienDong = Sao(
  3,
  "Thiên đồng",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoVuKhuc = Sao(
  4,
  "Vũ khúc",
  saoNguHanh: "K",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

final saoThaiDuong = Sao(
  5,
  "Thái Dương",
  saoNguHanh: "H",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoThienCo = Sao(
  6,
  "Thiên cơ",
  saoNguHanh: "M",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

// Thiên phủ tinh hệ
final saoThienPhu = Sao(
  7,
  "Thiên phủ",
  saoNguHanh: "O",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoThaiAm = Sao(
  8,
  "Thái âm",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

final saoThamLang = Sao(
  9,
  "Tham lang",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

final saoCuMon = Sao(
  10,
  "Cự môn",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

final saoThienTuong = Sao(
  11,
  "Thiên tướng",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoThienLuong = Sao(
  12,
  "Thiên lương",
  saoNguHanh: "M",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

final saoThatSat = Sao(
  13,
  "Thất sát",
  saoNguHanh: "K",
  saoLoai: 1,
  saoPhuongVi: "Nam đẩu tinh",
  saoAmDuong: 1,
  vongTrangSinh: 0,
);

final saoPhaQuan = Sao(
  14,
  "Phá quân",
  saoNguHanh: "T",
  saoLoai: 1,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: -1,
  vongTrangSinh: 0,
);

// Vòng Địa chi - Thái tuế
final saoThaiTue = Sao(
  15,
  "Thái tuế",
  saoNguHanh: "H",
  saoLoai: 15,
  saoPhuongVi: "",
  saoAmDuong: 0,
  vongTrangSinh: 0,
);

final saoThieuDuong = Sao(
  16,
  "Thiếu dương",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoTangMon = Sao(
  17,
  "Tang môn",
  saoNguHanh: "M",
  saoLoai: 12,
);

final saoThieuAm = Sao(
  18,
  "Thiếu âm",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoQuanPhu3 = Sao(
  19,
  "Quan phù",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoTuPhu = Sao(
  20,
  "Tử phù",
  saoNguHanh: "K",
  saoLoai: 12,
);

final saoTuePha = Sao(
  21,
  "Tuế phá",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoLongDuc = Sao(
  22,
  "Long đức",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoBachHo = Sao(
  23,
  "Bạch hổ",
  saoNguHanh: "K",
  saoLoai: 12,
);

final saoPhucDuc = Sao(
  24,
  "Phúc đức",
  saoNguHanh: "O",
  saoLoai: 5,
);

final saoDieuKhach = Sao(
  25,
  "Điếu khách",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoTrucPhu = Sao(
  26,
  "Trực phù",
  saoNguHanh: "K",
  saoLoai: 16,
);

// Vòng Thiên can - Lộc tồn
final saoLocTon = Sao(
  27,
  "Lộc tồn",
  saoNguHanh: "O",
  saoLoai: 3,
  saoPhuongVi: "Bắc đẩu tinh",
);

final saoBacSy = Sao(
  109,
  "Bác sỹ",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoLucSi = Sao(
  28,
  "Lực sĩ",
  saoNguHanh: "H",
  saoLoai: 2,
);

final saoThanhLong = Sao(
  29,
  "Thanh long",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoTieuHao = Sao(
  30,
  "Tiểu hao",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoTuongQuan = Sao(
  31,
  "Tướng quân",
  saoNguHanh: "M",
  saoLoai: 4,
);

final saoTauThu = Sao(
  32,
  "Tấu thư",
  saoNguHanh: "K",
  saoLoai: 3,
);

final saoPhiLiem = Sao(
  33,
  "Phi liêm",
  saoNguHanh: "H",
  saoLoai: 2,
);

final saoHyThan = Sao(
  34,
  "Hỷ thần",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoBenhPhu = Sao(
  35,
  "Bệnh phù",
  saoNguHanh: "O",
  saoLoai: 12,
);

final saoDaiHao = Sao(
  36,
  "Đại hao",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoPhucBinh = Sao(
  37,
  "Phục binh",
  saoNguHanh: "H",
  saoLoai: 13,
);

final saoQuanPhu2 = Sao(
  38,
  "Quan phủ",
  saoNguHanh: "H",
  saoLoai: 12,
);

// Vòng Tràng sinh
final saoTrangSinh = Sao(
  39,
  "Tràng sinh",
  saoNguHanh: "T",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoMocDuc = Sao(
  40,
  "Mộc dục",
  saoNguHanh: "T",
  saoLoai: 14,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoQuanDoi = Sao(
  41,
  "Quan đới",
  saoNguHanh: "K",
  saoLoai: 4,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoLamQuan = Sao(
  42,
  "Lâm quan",
  saoNguHanh: "K",
  saoLoai: 7,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoDeVuong = Sao(
  43,
  "Đế vượng",
  saoNguHanh: "K",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoSuy = Sao(
  44,
  "Suy",
  saoNguHanh: "T",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoBenh = Sao(
  45,
  "Bệnh",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoTu = Sao(
  46,
  "Tử",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoMo = Sao(
  47,
  "Mộ",
  saoNguHanh: "O",
  saoLoai: 0,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoTuyet = Sao(
  48,
  "Tuyệt",
  saoNguHanh: "O",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoThai = Sao(
  49,
  "Thai",
  saoNguHanh: "O",
  saoLoai: 14,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

final saoDuong = Sao(
  50,
  "Dưỡng",
  saoNguHanh: "M",
  saoLoai: 2,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 1,
);

// Lục sát
final saoDaLa = Sao(
  51,
  "Đà la",
  saoNguHanh: "K",
  saoLoai: 11,
);

final saoKinhDuong = Sao(
  52,
  "Kình dương",
  saoNguHanh: "K",
  saoLoai: 11,
);

final saoDiaKhong = Sao(
  53,
  "Địa không",
  saoNguHanh: "H",
  saoLoai: 11,
);

final saoDiaKiep = Sao(
  54,
  "Địa kiếp",
  saoNguHanh: "H",
  saoLoai: 11,
);

final saoLinhTinh = Sao(
  55,
  "Linh tinh",
  saoNguHanh: "H",
  saoLoai: 11,
);

final saoHoaTinh = Sao(
  56,
  "Hỏa tinh",
  saoNguHanh: "H",
  saoLoai: 11,
);

// Sao Âm Dương
final saoVanXuong = Sao(
  57,
  "Văn xương",
  saoNguHanh: "K",
  saoLoai: 6,
);

final saoVanKhuc = Sao(
  58,
  "Văn Khúc",
  saoNguHanh: "T",
  saoLoai: 6,
);

final saoThienKhoi = Sao(
  59,
  "Thiên khôi",
  saoNguHanh: "H",
  saoLoai: 6,
);

final saoThienViet = Sao(
  60,
  "Thiên việt",
  saoNguHanh: "H",
  saoLoai: 6,
);

final saoTaPhu = Sao(
  61,
  "Tả phù",
  saoNguHanh: "O",
  saoLoai: 2,
);

final saoHuuBat = Sao(
  62,
  "Hữu bật",
  saoNguHanh: "O",
  saoLoai: 2,
);

final saoLongTri = Sao(
  63,
  "Long trì",
  saoNguHanh: "T",
  saoLoai: 3,
);

final saoPhuongCac = Sao(
  64,
  "Phượng các",
  saoNguHanh: "O",
  saoLoai: 3,
);

final saoTamThai = Sao(
  65,
  "Tam thai",
  saoNguHanh: "M",
  saoLoai: 7,
);

final saoBatToa = Sao(
  66,
  "Bát tọa",
  saoNguHanh: "T",
  saoLoai: 7,
);

final saoAnQuang = Sao(
  67,
  "Ân quang",
  saoNguHanh: "M",
  saoLoai: 3,
);

final saoThienQuy = Sao(
  68,
  "Thiên quý",
  saoNguHanh: "O",
  saoLoai: 3,
);


// Sao đôi khác
// Sao đôi khác
final saoThienKhoc = Sao(
  69,
  "Thiên khốc",
  saoNguHanh: "T",
  saoLoai: 12,
);

final saoThienHu = Sao(
  70,
  "Thiên hư",
  saoNguHanh: "T",
  saoLoai: 12,
);

final saoThienDuc = Sao(
  71,
  "Thiên đức",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoNguyetDuc = Sao(
  72,
  "Nguyệt đức",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoThienHinh = Sao(
  73,
  "Thiên hình",
  saoNguHanh: "H",
  saoLoai: 15,
);

final saoThienRieu = Sao(
  74,
  "Thiên riêu",
  saoNguHanh: "T",
  saoLoai: 13,
);

final saoThienY = Sao(
  75,
  "Thiên y",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoQuocAn = Sao(
  76,
  "Quốc ấn",
  saoNguHanh: "O",
  saoLoai: 6,
);

final saoDuongPhu = Sao(
  77,
  "Đường phù",
  saoNguHanh: "M",
  saoLoai: 4,
);

final saoDaoHoa = Sao(
  78,
  "Đào hoa",
  saoNguHanh: "M",
  saoLoai: 8,
);

final saoHongLoan = Sao(
  79,
  "Hồng loan",
  saoNguHanh: "T",
  saoLoai: 8,
);

final saoThienHy = Sao(
  80,
  "Thiên hỷ",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoThienGiai = Sao(
  81,
  "Thiên giải",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoDiaGiai = Sao(
  82,
  "Địa giải",
  saoNguHanh: "O",
  saoLoai: 5,
);

final saoGiaiThan = Sao(
  83,
  "Giải thần",
  saoNguHanh: "M",
  saoLoai: 5,
);

final saoThaiPhu = Sao(
  84,
  "Thai phụ",
  saoNguHanh: "K",
  saoLoai: 6,
);

final saoPhongCao = Sao(
  85,
  "Phong cáo",
  saoNguHanh: "O",
  saoLoai: 4,
);

final saoThienTai = Sao(
  86,
  "Thiên tài",
  saoNguHanh: "O",
  saoLoai: 2,
);

final saoThienTho = Sao(
  87,
  "Thiên thọ",
  saoNguHanh: "O",
  saoLoai: 5,
);

final saoThienThuong = Sao(
  88,
  "Thiên thương",
  saoNguHanh: "O",
  saoLoai: 12,
);

final saoThienSu = Sao(
  89,
  "Thiên sứ",
  saoNguHanh: "T",
  saoLoai: 12,
);

final saoThienLa = Sao(
  90,
  "Thiên la",
  saoNguHanh: "O",
  saoLoai: 12,
);

final saoDiaVong = Sao(
  91,
  "Địa võng",
  saoNguHanh: "O",
  saoLoai: 12,
);

final saoHoaKhoa = Sao(
  92,
  "Hóa khoa",
  saoNguHanh: "T",
  saoLoai: 5,
);

final saoHoaQuyen = Sao(
  93,
  "Hóa quyền",
  saoNguHanh: "T",
  saoLoai: 4,
);

final saoHoaLoc = Sao(
  94,
  "Hóa lộc",
  saoNguHanh: "M",
  saoLoai: 3,
);

final saoHoaKy = Sao(
  95,
  "Hóa kỵ",
  saoNguHanh: "T",
  saoLoai: 13,
);

final saoCoThan = Sao(
  96,
  "Cô thần",
  saoNguHanh: "O",
  saoLoai: 13,
);

final saoQuaTu = Sao(
  97,
  "Quả tú",
  saoNguHanh: "O",
  saoLoai: 13,
);

final saoThienMa = Sao(
  98,
  "Thiên mã",
  saoNguHanh: "H",
  saoLoai: 3,
);

final saoPhaToai = Sao(
  99,
  "Phá toái",
  saoNguHanh: "H",
  saoLoai: 12,
);

final saoThienQuan = Sao(
  100,
  "Thiên quan",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoThienPhuc = Sao(
  101,
  "Thiên phúc",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoLuuHa = Sao(
  102,
  "Lưu hà",
  saoNguHanh: "T",
  saoLoai: 12,
);

final saoThienTru = Sao(
  103,
  "Thiên trù",
  saoNguHanh: "O",
  saoLoai: 5,
);

final saoKiepSat = Sao(
  104,
  "Kiếp sát",
  saoNguHanh: "H",
  saoLoai: 11,
);

final saoHoaCai = Sao(
  105,
  "Hoa cái",
  saoNguHanh: "K",
  saoLoai: 14,
);

final saoVanTinh = Sao(
  106,
  "Văn tinh",
  saoNguHanh: "H",
  saoLoai: 6,
);

final saoDauQuan = Sao(
  107,
  "Đẩu quân",
  saoNguHanh: "H",
  saoLoai: 5,
);

final saoThienKhong = Sao(
  108,
  "Thiên không",
  saoNguHanh: "T",
  saoLoai: 11,
);

// Lưu niên tinh hệ
final saoLuuThaiTue = Sao(
  109,
  "L.Thái tuế",
  saoNguHanh: "H",
  saoLoai: 15,
  saoPhuongVi: "",
  saoAmDuong: 0,
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuTangMon = Sao(
  110,
  "L.Tang môn",
  saoNguHanh: "M",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuBachHo = Sao(
  111,
  "L.Bạch hổ",
  saoNguHanh: "K",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuLocTon = Sao(
  112,
  "L.Lộc tồn",
  saoNguHanh: "O",
  saoLoai: 3,
  saoPhuongVi: "Bắc đẩu tinh",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuKinhDuong = Sao(
  113,
  "L.Kình dương",
  saoNguHanh: "K",
  saoLoai: 11,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuDaLa = Sao(
  114,
  "L.Đà la",
  saoNguHanh: "K",
  saoLoai: 11,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienMa = Sao(
  115,
  "L.Thiên mã",
  saoNguHanh: "H",
  saoLoai: 3,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienKhoc = Sao(
  116,
  "L.Thiên khốc",
  saoNguHanh: "T",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienHu = Sao(
  117,
  "L.Thiên hư",
  saoNguHanh: "T",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienKhoi = Sao(
  118,
  "L.Thiên khôi",
  saoNguHanh: "H",
  saoLoai: 6,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienViet = Sao(
  119,
  "L.Thiên việt",
  saoNguHanh: "H",
  saoLoai: 6,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuDaoHoa = Sao(
  120,
  "L.Đào hoa",
  saoNguHanh: "M",
  saoLoai: 8,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHongLoan = Sao(
  121,
  "L.Hồng loan",
  saoNguHanh: "T",
  saoLoai: 8,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHoaKhoa = Sao(
  122,
  "L.Hóa khoa",
  saoNguHanh: "T",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHoaQuyen = Sao(
  123,
  "L.Hóa quyền",
  saoNguHanh: "T",
  saoLoai: 4,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHoaLoc = Sao(
  124,
  "L.Hóa lộc",
  saoNguHanh: "M",
  saoLoai: 3,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHoaKy = Sao(
  125,
  "L.Hóa kỵ",
  saoNguHanh: "T",
  saoLoai: 13,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);


final saoLuuPhuongCac = Sao(
  126,
  "L.Phượng các",
  saoNguHanh: "O",
  saoLoai: 3,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuTuongQuan = Sao(
  127,
  "L.Tướng quân",
  saoNguHanh: "M",
  saoLoai: 4,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuTauThu = Sao(
  128,
  "L.Tấu thư",
  saoNguHanh: "K",
  saoLoai: 3,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuDuongPhu = Sao(
  129,
  "L.Đường phù",
  saoNguHanh: "M",
  saoLoai: 4,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuQuanPhu3 = Sao(
  130,
  "L.Quan phù",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuPhiLiem = Sao(
  131,
  "L.Phi liêm",
  saoNguHanh: "H",
  saoLoai: 2,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHyThan = Sao(
  132,
  "L.Hỷ thần",
  saoNguHanh: "H",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuLuuHa = Sao(
  133,
  "L.Lưu hà",
  saoNguHanh: "T",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuQuocAn = Sao(
  134,
  "L.Quốc ấn",
  saoNguHanh: "O",
  saoLoai: 6,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuBenhPhu = Sao(
  135,
  "L.Bệnh phù",
  saoNguHanh: "O",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuDaiHao = Sao(
  136,
  "L.Đại hao",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuPhucBinh = Sao(
  137,
  "L.Phục binh",
  saoNguHanh: "H",
  saoLoai: 13,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuQuaTu = Sao(
  138,
  "L.Quả tú",
  saoNguHanh: "O",
  saoLoai: 13,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuQuanPhu2 = Sao(
  139,
  "L.Quan phủ",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuDieuKhach = Sao(
  140,
  "L.Điếu khách",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuLucSi = Sao(
  141,
  "L.Lực sĩ",
  saoNguHanh: "H",
  saoLoai: 2,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThanhLong = Sao(
  142,
  "L.Thanh long",
  saoNguHanh: "T",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuHoaCai = Sao(
  143,
  "L.Hoa cái",
  saoNguHanh: "K",
  saoLoai: 14,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuThienHy = Sao(
  144,
  "L.Thiên hỷ",
  saoNguHanh: "T",
  saoLoai: 5,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuTieuHao = Sao(
  145,
  "L.Tiểu hao",
  saoNguHanh: "H",
  saoLoai: 12,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

final saoLuuCoThan = Sao(
  146,
  "L.Cô thần",
  saoNguHanh: "O",
  saoLoai: 13,
  saoPhuongVi: "",
  saoAmDuong: "",
  vongTrangSinh: 0,
  saoLuuNien: true,
);

class LapThienBan {
  int gioiTinh;
  String namNu;
  late Map<String, dynamic> chiGioSinh;
  int canGioSinh = 0;
  String gioSinh;
  int timeZone;
  String today;
  int ngayDuong;
  int thangDuong;
  int namDuong;
  String ten;
  int? namXemTieuVan;
  int canNamTieuVan = 0;
  int chiNamTieuVan = 0;
  int ngayAm = 0;
  int thangAm = 0;
  int namAm = 0;
  int thangNhuan = 0;
  int canThang = 0;
  int canNam = 0;
  int chiNam = 0;
  int chiThang = 0;
  String canThangTen = '';
  String canNamTen = '';
  String chiThangTen = '';
  String chiNamTen = '';
  int canNgay = 0;
  int chiNgay = 0;
  String canNgayTen = '';
  String chiNgayTen = '';
  String amDuongNamSinh = '';
  String amDuongMenh = '';
  int hanhCuc = 0;
  String tenCuc = '';
  String menhChu = '';
  String thanChu = '';
  String menh = '';
  String banMenh = '';
  String sinhKhac = '';
  String canNamTieuVanTen = '';
  String chiNamTieuVanTen = '';


  LapThienBan(
    int nn,
    int tt,
    int nnnn,
    int gioSinhNumber,
    int gioiTinhInput,
    String tenInput,
    DiaBan diaBan, {
    bool duongLich = true,
    int timeZoneInput = 7,
    int? namXemTieuVanInput
  })  : gioiTinh = gioiTinhInput == 1 ? 1 : -1,
        namNu = gioiTinhInput == 1 ? "Nam" : "Nữ",
        ngayDuong = nn,
        thangDuong = tt,
        namDuong = nnnn,
        ten = tenInput,
        gioSinh = gioSinhNumber.toString(),
        timeZone = timeZoneInput,
        today = DateTime.now().toLocal().toString() {

    chiGioSinh = AmDuong.diaChi[gioSinhNumber];

    canGioSinh = ((((Time.jdFromDate(nn, tt, nnnn) - 1) * 2) % 10) + gioSinhNumber) % 10;
    if (canGioSinh == 0) canGioSinh = 10;
    gioSinh = '${AmDuong.thienCan[canGioSinh]["tenCan"]} ${chiGioSinh['tenChi']}';

    if (namXemTieuVanInput != null) {
      namXemTieuVan = namXemTieuVanInput;
      var canChi = ngayThangNamCanChi(5, 5, namXemTieuVanInput, duongLich: false, timeZone: timeZone);
      canNamTieuVan = canChi[1];
      chiNamTieuVan = canChi[2];
      canNamTieuVanTen = AmDuong.thienCan[canNamTieuVan]["tenCan"];
      chiNamTieuVanTen = AmDuong.diaChi[chiNamTieuVan]["tenChi"];
    }

    if (duongLich) {
      var result = ngayThangNam(ngayDuong, thangDuong, namDuong, duongLich: true, timeZone: timeZone);
      ngayAm = result[0];
      thangAm = result[1];
      namAm = result[2];
      thangNhuan = result[3];
    } else {
      ngayAm = ngayDuong;
      thangAm = thangDuong;
      namAm = namDuong;
    }

    var canChiResult = ngayThangNamCanChi(ngayAm, thangAm, namAm, duongLich: false, timeZone: timeZone);
    canThang = canChiResult[0];
    canNam = canChiResult[1];
    chiNam = canChiResult[2];
    chiThang = thangAm;
    canThangTen = AmDuong.thienCan[canThang]['tenCan'];
    canNamTen = AmDuong.thienCan[canNam]['tenCan'];
    chiThangTen = AmDuong.diaChi[thangAm]['tenChi'];
    chiNamTen = AmDuong.diaChi[chiNam]['tenChi'];

    var ngayResult = AmDuong.canChiNgay(ngayDuong, thangDuong, namDuong, duongLich: duongLich, timeZone: timeZone);
    canNgay = ngayResult[0];
    chiNgay = ngayResult[1];
    canNgayTen = AmDuong.thienCan[canNgay]['tenCan'];
    chiNgayTen = AmDuong.diaChi[chiNgay]['tenChi'];

    int cungAmDuong = diaBan.cungMenh % 2 == 1 ? 1 : -1;
    amDuongNamSinh = chiNam % 2 == 1 ? "Dương" : "Âm";

    amDuongMenh = cungAmDuong * gioiTinh == 1 ? "Âm dương thuận lý" : "Âm dương nghịch lý";

    String cuc = timCuc(diaBan.cungMenh, canNam);
    hanhCuc = AmDuong.nguHanh(cuc)["id"];
    tenCuc = AmDuong.nguHanh(cuc)["tenCuc"];

    menhChu = AmDuong.diaChi[canNam]['menhChu'];
    thanChu = AmDuong.diaChi[canNam]['thanChu'];

    menh = nguHanhNapAm(chiNam, canNam);
    int menhId = nguHanh(menh)['id'];
    int? menhCucVal = AmDuong.sinhKhac(menhId, hanhCuc);

    if (menhCucVal == 1) {
      sinhKhac = "Bản Mệnh sinh Cục";
    } else if (menhCucVal == -1) {
      sinhKhac = "Bản Mệnh khắc Cục";
    } else if (menhCucVal == -1) {
      sinhKhac = "Cục khắc Bản Mệnh";
    } else if (menhCucVal == 1) {
      sinhKhac = "Cục sinh Bản mệnh";
    } else {
      sinhKhac = "Cục hòa Bản Mệnh";
    }

    banMenh = nguHanhNapAm(chiNam, canNam, xuatBanMenh: true);
  }

  static List<int> ngayThangNam(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
    return AmDuong.ngayThangNam(nn, tt, nnnn, duongLich: duongLich, timeZone: timeZone);
  }

  List<int> ngayThangNamCanChi(int nn, int tt, int nnnn, {bool duongLich = true, int timeZone = 7}) {
    return AmDuong.ngayThangNamCanChi(nn, tt, nnnn, duongLich: duongLich, timeZone: timeZone);
  }

  static Map<String, dynamic> nguHanh(String tenHanh) {
    return AmDuong.nguHanh(tenHanh);
  }

  static String nguHanhNapAm(int diaChi, int thienCan, {bool xuatBanMenh = false}) {
    return AmDuong.nguHanhNapAm(diaChi, thienCan, xuatBanMenh: xuatBanMenh);
  }

  static List<Map<String, dynamic>> thienCan() {
    return AmDuong.thienCan;
  }

  static String timCuc(int viTriCungMenhTrenDiaBan, int canNamSinh) {
    return AmDuong.timCuc(viTriCungMenhTrenDiaBan, canNamSinh);
  }

  static List<int> jdToDate(int jd) {
    return Time.jdToDate(jd);
  }

  @override
  String toString() {
    return 'LapThienBan(amDuongMenh: $amDuongMenh), amDuongNamSinh: $amDuongNamSinh, banMenh: $banMenh, canGioSinh: $canGioSinh, canNam: $canNam, canNamTen: $canNamTen, canNamTieuVanTen: $canNamTieuVanTen, $canNgay: canNgay, canNgayTen: $canNgayTen, chiGioSinh: $chiGioSinh, chiNam: $chiNam, chiNamTen: $chiNamTen, chiNamTieuVanTen: chiNamTieuVanTen, chiNgay: $chiNgay, chiNgayTen: $chiNgayTen, chiThang: $chiThang, chiThangTen: $chiThangTen, gioSinh: $gioSinh, gioiTinh: $gioiTinh, hanhCuc: $hanhCuc, menh: $menh, menhChu: $menhChu, namAm: $namAm, namDuong: $namDuong, namNu: $namNu, namXemTieuVan: $namXemTieuVan, ngayAm: $ngayAm, ngayDuong: $ngayDuong, sinhKhac: $sinhKhac, ten: $ten, tenCuc: $tenCuc, thanChu: $thanChu, thangAm: $thangAm, thangDuong: $thangDuong, thangNhuan: $thangNhuan, timeZone: $timeZone, today: $today';
  }
}

String capitalizeWords(String input) {
  return input.split(' ').map((word) {
    if (word.isEmpty) return word;
    return word[0].toUpperCase() + word.substring(1).toLowerCase();
  }).join(' ');
}

String generateLasoContent(LapThienBan thienBan, List<CungDiaBan> thapNhiCung) {
  final namDuong = thienBan.namDuong;
  final canNamTen = thienBan.canNamTen;
  final ten = thienBan.ten;
  final chiNamTen = thienBan.chiNamTen;

  // thapNhiCung.removeAt(0);

  final sapXepCungTheoCungSo = List<CungDiaBan>.from(thapNhiCung)..sort((a, b) => a.cungSo.compareTo(b.cungSo));
  final sapXepCungTheoTuoi = List<CungDiaBan>.from(thapNhiCung)..sort((a, b) => (a.cungDaiHan ?? 0).compareTo(b.cungDaiHan ?? 0));

  final contentThapNhiCung = sapXepCungTheoTuoi.asMap().entries.map((entry) {
    final index = entry.key;
    final cung = entry.value;
    final cungSao = cung.cungSao;
    final cungSo = cung.cungSo;
    final chinhTinh = cungSao.where((sao) => sao.saoAmDuong != '').toList();
    final phuTinh = cungSao.where((sao) => sao.saoAmDuong == '').toList();

    final cungDoiXung = cungSo + 6 > 12
        ? sapXepCungTheoCungSo[cungSo + 6 - 12]
        : sapXepCungTheoCungSo[cungSo + 6 - 1];
    final cungTamHop1 = cungSo + 4 > 12
        ? sapXepCungTheoCungSo[cungSo + 4 - 12]
        : sapXepCungTheoCungSo[cungSo + 4 - 1];
    final cungSoTamHop1 = cungTamHop1.cungSo - 1;
    final cungTamHop2 = cungSoTamHop1 + 4 > 12
        ? sapXepCungTheoCungSo[cungSoTamHop1 + 4 - 12]
        : sapXepCungTheoCungSo[cungSoTamHop1 + 4 - 1];

    final stt = index + 1;
    final sttNext = index == sapXepCungTheoTuoi.length - 1 ? null : index + 1;
    final cungTen = cung.cungTen;
    final cungChu = cung.cungChuTen;
    final cungDaiHan = cung.cungDaiHan ?? 0;
    final cungTieuHan = cung.cungTieuHan;

    final cungDaiVan = sttNext == null
        ? "$cungDaiHan tuổi trở lên"
        : "$cungDaiHan tuổi đến năm ${sapXepCungTheoTuoi[sttNext].cungDaiHan! - 1} tuổi";

    return """
$stt. 
Cung vị: ${capitalizeWords(cungTen)} 
Cung chức: ${capitalizeWords(cungChu ?? '')} của anh $ten sinh năm $namDuong
Tam hợp với cung ${capitalizeWords(cungTamHop1.cungChuTen ?? '')} và ${capitalizeWords(cungTamHop2.cungChuTen ?? '')}, đối xung ngoại cảnh là ${capitalizeWords(cungDoiXung.cungChuTen ?? '')}
Chính Tinh  (ảnh hưởng min 50%, max 80%): ${chinhTinh.map((sao) => capitalizeWords(sao.saoTen)).join(' + ')}
Phụ Tinh (ảnh hưởng min 20%, max 50%): ${phuTinh.map((sao) => capitalizeWords(sao.saoTen)).join(' + ')}
Đại vận thứ ${index == 0 ? 'nhất' : stt} của anh ${capitalizeWords(ten)} sinh năm $namDuong ($cungDaiVan)
Tiểu vận: năm ${capitalizeWords(cungTieuHan ?? '')}
""";
  }).join('\n');

  return "Lá số của $ten sinh năm $namDuong ($canNamTen $chiNamTen)\n$contentThapNhiCung";
}


void main(){
 String hoTen = 'tien';
 int ngaySinh = 24;
 int thangSinh = 3;
 int namSinh = 2000;
 int gioSinh = 1;
 int gioiTinh = 1;
 bool duongLich = true;
 int timeZone = 7;

 DiaBan diaBan = lapDiaBan(ngaySinh, thangSinh, namSinh, gioSinh, gioiTinh, duongLich, timeZone, 2025);
 
 LapThienBan thienBan = LapThienBan(
  ngaySinh,      // nn
  thangSinh,     // tt
  namSinh,       // nnnn
  gioSinh,       // gioSinhNumber (int)
  gioiTinh,      // gioiTinhInput
  hoTen,         // tenInput
  diaBan,        // diaBan
  duongLich: true,
  timeZoneInput: 1
);
 List<CungDiaBan> thapNhiCung = diaBan.thapNhiCung.sublist(1);
 
 String content = generateLasoContent(thienBan, thapNhiCung);
 print(content);

}
Editor is loading...
Leave a Comment