/**
 * Phong-thuỷ helpers for "chọn năm" và "chọn số" tools.
 */

import { elementFromYear, type Element } from "./colors";

/**
 * Kim Lâu — gia chủ phạm Kim Lâu nếu tuổi mụ chia 9 dư 1, 3, 6, 8.
 * Tuổi mụ = (năm xây - năm sinh) + 1.
 */
export function isKimLau(
  birthYear: number,
  buildYear: number
): {
  ok: boolean;
  ageMu: number;
  type?: "Kim Lâu Thê" | "Kim Lâu Tử" | "Kim Lâu Lục Súc" | "Kim Lâu Thân";
} {
  const ageMu = buildYear - birthYear + 1;
  const r = ageMu % 9;
  const map: Record<number, "Kim Lâu Thê" | "Kim Lâu Tử" | "Kim Lâu Lục Súc" | "Kim Lâu Thân"> = {
    1: "Kim Lâu Thân",
    3: "Kim Lâu Thê",
    6: "Kim Lâu Tử",
    8: "Kim Lâu Lục Súc",
  };
  if (r in map) return { ok: false, ageMu, type: map[r] };
  return { ok: true, ageMu };
}

/**
 * Hoang Ốc — chia tuổi mụ cho 12, dư 1, 5, 6, 9 thì phạm Hoang Ốc.
 */
export function isHoangOc(
  birthYear: number,
  buildYear: number
): {
  ok: boolean;
  type?: "Nhất Cát" | "Nhị Nghi" | "Tam Địa Sát" | "Tứ Tấn Tài" | "Ngũ Thọ Tử" | "Lục Hoang Ốc";
} {
  const ageMu = buildYear - birthYear + 1;
  const r = ageMu % 6;
  // r=1 Nhất Cát (tốt), 2 Nhị Nghi (tốt), 3 Tam Địa Sát (xấu), 4 Tứ Tấn Tài (tốt), 5 Ngũ Thọ Tử (xấu), 0 Lục Hoang Ốc (xấu)
  const map: Record<
    number,
    {
      name: "Nhất Cát" | "Nhị Nghi" | "Tam Địa Sát" | "Tứ Tấn Tài" | "Ngũ Thọ Tử" | "Lục Hoang Ốc";
      bad: boolean;
    }
  > = {
    1: { name: "Nhất Cát", bad: false },
    2: { name: "Nhị Nghi", bad: false },
    3: { name: "Tam Địa Sát", bad: true },
    4: { name: "Tứ Tấn Tài", bad: false },
    5: { name: "Ngũ Thọ Tử", bad: true },
    0: { name: "Lục Hoang Ốc", bad: true },
  };
  const entry = map[r];
  return { ok: !entry.bad, type: entry.name };
}

/**
 * Tam Tai — 3 năm liên tiếp, lặp lại mỗi 12 năm. Mỗi tam-hợp có một bộ
 * tam-tai cố định:
 *   Thân-Tý-Thìn → Dần-Mão-Thìn
 *   Tỵ-Dậu-Sửu → Hợi-Tý-Sửu
 *   Dần-Ngọ-Tuất → Thân-Dậu-Tuất
 *   Hợi-Mão-Mùi → Tỵ-Ngọ-Mùi
 */
export function isTamTai(
  birthYear: number,
  targetYear: number
): {
  ok: boolean;
  triad?: string;
} {
  const branchOf = (y: number): number => (((y - 1924) % 12) + 12) % 12;
  const b1 = branchOf(birthYear);
  const b2 = branchOf(targetYear);

  // Map birth branch → 3 forbidden target branches
  const tamTaiBy: Record<number, [number, number, number]> = {
    // Thân (8), Tý (0), Thìn (4) → Dần (2), Mão (3), Thìn (4)
    8: [2, 3, 4],
    0: [2, 3, 4],
    4: [2, 3, 4],
    // Tỵ (5), Dậu (9), Sửu (1) → Hợi (11), Tý (0), Sửu (1)
    5: [11, 0, 1],
    9: [11, 0, 1],
    1: [11, 0, 1],
    // Dần (2), Ngọ (6), Tuất (10) → Thân (8), Dậu (9), Tuất (10)
    2: [8, 9, 10],
    6: [8, 9, 10],
    10: [8, 9, 10],
    // Hợi (11), Mão (3), Mùi (7) → Tỵ (5), Ngọ (6), Mùi (7)
    11: [5, 6, 7],
    3: [5, 6, 7],
    7: [5, 6, 7],
  };
  const triadNames = ["Thân-Tý-Thìn", "Tỵ-Dậu-Sửu", "Dần-Ngọ-Tuất", "Hợi-Mão-Mùi"];
  const triadIdx = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3].indexOf(b1 % 4); // simple; not used downstream
  void triadIdx;

  const forbidden = tamTaiBy[b1];
  if (forbidden.includes(b2)) {
    // Find which triad the BIRTH branch belongs to for display
    let triad = "";
    if ([8, 0, 4].includes(b1)) triad = triadNames[0];
    else if ([5, 9, 1].includes(b1)) triad = triadNames[1];
    else if ([2, 6, 10].includes(b1)) triad = triadNames[2];
    else triad = triadNames[3];
    return { ok: false, triad };
  }
  return { ok: true };
}

// =============================================================
// Personalization helpers — Bát Trạch hướng nhà + 10-year preview
// =============================================================

export type CungMenh = "Khảm" | "Cấn" | "Chấn" | "Tốn" | "Ly" | "Khôn" | "Đoài" | "Càn";
export type ManhGroup = "Đông Tứ Mệnh" | "Tây Tứ Mệnh";

const CUNG_GROUP: Record<CungMenh, ManhGroup> = {
  Khảm: "Đông Tứ Mệnh",
  Ly: "Đông Tứ Mệnh",
  Chấn: "Đông Tứ Mệnh",
  Tốn: "Đông Tứ Mệnh",
  Cấn: "Tây Tứ Mệnh",
  Khôn: "Tây Tứ Mệnh",
  Càn: "Tây Tứ Mệnh",
  Đoài: "Tây Tứ Mệnh",
};

const GOOD_DIRECTIONS: Record<ManhGroup, string[]> = {
  "Đông Tứ Mệnh": ["Bắc", "Nam", "Đông", "Đông Nam"],
  "Tây Tứ Mệnh": ["Đông Bắc", "Tây Nam", "Tây", "Tây Bắc"],
};

const BAD_DIRECTIONS: Record<ManhGroup, string[]> = {
  "Đông Tứ Mệnh": ["Đông Bắc", "Tây Nam", "Tây", "Tây Bắc"],
  "Tây Tứ Mệnh": ["Bắc", "Nam", "Đông", "Đông Nam"],
};

function sumDigits(n: number): number {
  let s = 0;
  while (n > 0) {
    s += n % 10;
    n = Math.floor(n / 10);
  }
  return s > 9 ? sumDigits(s) : s;
}

/** Compute cung mệnh theo Lạc Thư + giới tính. */
export function computeCungMenh(year: number, gender: "Nam" | "Nữ"): CungMenh {
  const reduced = sumDigits(year);
  const idx = gender === "Nam" ? (((11 - reduced) % 9) + 9) % 9 : ((4 + reduced) % 9) % 9;
  const map: Record<number, CungMenh> = {
    1: "Khảm",
    2: "Khôn",
    3: "Chấn",
    4: "Tốn",
    6: "Càn",
    7: "Đoài",
    8: "Cấn",
    9: "Ly",
  };
  if (idx === 5 || idx === 0) {
    return gender === "Nam" ? "Khôn" : "Cấn";
  }
  return map[idx] ?? "Khảm";
}

/** Tổng hợp Bát Trạch — cung mệnh + Đông/Tây + 4 hướng tốt + 4 hướng xấu. */
export function batTrach(
  year: number,
  gender: "Nam" | "Nữ"
): {
  cung: CungMenh;
  group: ManhGroup;
  goodDirections: string[];
  badDirections: string[];
} {
  const cung = computeCungMenh(year, gender);
  const group = CUNG_GROUP[cung];
  return {
    cung,
    group,
    goodDirections: GOOD_DIRECTIONS[group],
    badDirections: BAD_DIRECTIONS[group],
  };
}

/**
 * Find next N "good build years" — không phạm Kim Lâu, Hoang Ốc, Tam Tai.
 * Quét từ `fromYear` tới khi tìm đủ `count` năm tốt hoặc hết `maxRange`.
 */
export type GoodBuildYear = {
  year: number;
  ageMu: number;
  hoangOcType: string;
};

export function findGoodBuildYears(
  birthYear: number,
  fromYear: number,
  count = 5,
  maxRange = 30
): GoodBuildYear[] {
  const out: GoodBuildYear[] = [];
  for (let y = fromYear; y < fromYear + maxRange && out.length < count; y++) {
    const kl = isKimLau(birthYear, y);
    const ho = isHoangOc(birthYear, y);
    const tt = isTamTai(birthYear, y);
    if (kl.ok && ho.ok && tt.ok) {
      out.push({
        year: y,
        ageMu: kl.ageMu,
        hoangOcType: ho.type ?? "",
      });
    }
  }
  return out;
}

/**
 * Build year preview — kiểm tra 10 năm tới + đánh dấu năm nào xây được.
 * Trả về cả năm tốt và năm xấu để người dùng biết "tránh năm nào".
 */
export type BuildYearPreview = {
  year: number;
  ageMu: number;
  ok: boolean;
  reasons: string[];
};

export function previewBuildYears(
  birthYear: number,
  fromYear: number,
  range = 10
): BuildYearPreview[] {
  const out: BuildYearPreview[] = [];
  for (let y = fromYear; y < fromYear + range; y++) {
    const kl = isKimLau(birthYear, y);
    const ho = isHoangOc(birthYear, y);
    const tt = isTamTai(birthYear, y);
    const reasons: string[] = [];
    if (!kl.ok) reasons.push(`${kl.type}`);
    if (!ho.ok) reasons.push(`Hoang Ốc ${ho.type}`);
    if (!tt.ok) reasons.push(`Tam Tai ${tt.triad}`);
    out.push({
      year: y,
      ageMu: kl.ageMu,
      ok: kl.ok && ho.ok && tt.ok,
      reasons,
    });
  }
  return out;
}

/**
 * Material + color suggestions for the build year, theo mệnh ngũ hành của
 * gia chủ. Không phải mệnh năm xây — đây là gợi ý vật liệu mà GIA CHỦ nên dùng.
 */
const ELEMENT_MATERIALS: Record<Element, { good: string[]; avoid: string[]; rooms: string[] }> = {
  Kim: {
    good: ["Kim loại không gỉ (inox)", "Đá granite trắng/xám", "Kính trong", "Gỗ sáng màu (sồi)"],
    avoid: ["Gỗ sậm cháy", "Gạch terracotta đỏ"],
    rooms: ["Phòng khách hướng Tây", "Bếp đặt hướng Tây Bắc", "Phòng làm việc hướng Tây"],
  },
  Mộc: {
    good: ["Gỗ tự nhiên (lim, sồi, óc chó)", "Tre nứa", "Đá tự nhiên xanh đen"],
    avoid: ["Inox bóng", "Vật liệu kim loại sáng nhiều"],
    rooms: ["Phòng làm việc hướng Đông", "Sân vườn hướng Đông Nam", "Phòng đọc hướng Đông"],
  },
  Thuỷ: {
    good: ["Đá đen / xanh navy", "Kính trong/xanh", "Inox xám", "Gỗ sậm"],
    avoid: ["Gạch nung đỏ", "Đá vàng đất"],
    rooms: ["Phòng tắm/bếp hướng Bắc", "Bể cá hướng Bắc", "Phòng ngủ chính hướng Bắc"],
  },
  Hoả: {
    good: ["Gạch nung đỏ", "Đá lửa", "Gỗ sậm tự nhiên", "Đèn ánh ấm"],
    avoid: ["Đá xanh đen quá nhiều", "Hồ nước lớn trong nhà"],
    rooms: ["Phòng khách hướng Nam", "Bếp hướng Nam", "Phòng ăn hướng Nam"],
  },
  Thổ: {
    good: ["Gốm sứ", "Đá tự nhiên vàng đất", "Gỗ nâu", "Gạch terracotta"],
    avoid: ["Vật liệu xanh lá nhiều", "Cây cảnh thân lớn trong nhà"],
    rooms: ["Phòng thờ hướng Tây Nam", "Phòng ngủ chính hướng Đông Bắc", "Bếp hướng Đông Bắc"],
  },
};

export function buildMaterialAdvice(birthYear: number): {
  element: Element;
  good: string[];
  avoid: string[];
  rooms: string[];
} {
  const el = elementFromYear(birthYear);
  const m = ELEMENT_MATERIALS[el];
  return {
    element: el,
    good: m.good,
    avoid: m.avoid,
    rooms: m.rooms,
  };
}