eye-care 1.0.0

package/scripts/make-icon.js

@@ -0,0 +1,120 @@
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+function makePng(W, H, pixelFn) {
+  const pixels = Buffer.alloc(W * H * 4);
+  pixelFn(W, H, pixels);
+  const raw = Buffer.alloc(H * (1 + W * 4));
+  for (let y = 0; y < H; y++) {
+    raw[y * (1 + W * 4)] = 0;
+    pixels.copy(raw, y * (1 + W * 4) + 1, y * W * 4, (y + 1) * W * 4);
+  }
+  const compressed = zlib.deflateSync(raw);
+  const sig = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(W, 0);
+  ihdr.writeUInt32BE(H, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  const png = Buffer.concat([sig, chunk("IHDR", ihdr), chunk("IDAT", compressed), chunk("IEND", Buffer.alloc(0))]);
+  return png;
+}
+
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length, 0);
+  const typeBuf = Buffer.from(type, "ascii");
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
+  return Buffer.concat([len, typeBuf, data, crc]);
+}
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) {
+    c ^= buf[i];
+    for (let k = 0; k < 8; k++) {
+      c = (c >>> 1) ^ (0xedb88320 & -(c & 1));
+    }
+  }
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function inCircle(cx, cy, r, x, y) {
+  const dx = x - cx;
+  const dy = y - cy;
+  return dx * dx + dy * dy <= r * r;
+}
+
+function drawEye(W, H, pixels) {
+  const cx = W / 2;
+  const cy = H / 2;
+  const eyeW = W * 0.42;
+  const eyeH = H * 0.28;
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      let r = 0, g = 0, b = 0, a = 0;
+      const dx = (x - cx) / eyeW;
+      const dy = (y - cy) / eyeH;
+      const eyeShape = dx * dx + dy * dy <= 1;
+      if (eyeShape) {
+        r = 79; g = 140; b = 255; a = 255;
+      }
+      const pupilR = Math.min(W, H) * 0.14;
+      if (inCircle(cx, cy, pupilR, x, y)) {
+        r = 20; g = 30; b = 60; a = 255;
+      }
+      const glintR = Math.min(W, H) * 0.06;
+      if (inCircle(cx - pupilR * 0.3, cy - pupilR * 0.3, glintR, x, y)) {
+        r = 240; g = 245; b = 255; a = 255;
+      }
+      const i = (y * W + x) * 4;
+      pixels[i] = r;
+      pixels[i + 1] = g;
+      pixels[i + 2] = b;
+      pixels[i + 3] = a;
+    }
+  }
+}
+
+function makeIco(sizes) {
+  const pngs = sizes.map((s) => ({ size: s, png: makePng(s, s, drawEye) }));
+  const headerSize = 6 + pngs.length * 16;
+  const header = Buffer.alloc(6);
+  header.writeUInt16LE(0, 0);
+  header.writeUInt16LE(1, 2);
+  header.writeUInt16LE(pngs.length, 4);
+  const entries = [];
+  let offset = headerSize;
+  for (const { size, png } of pngs) {
+    const entry = Buffer.alloc(16);
+    entry[0] = size >= 256 ? 0 : size;
+    entry[1] = size >= 256 ? 0 : size;
+    entry[2] = 0;
+    entry[3] = 0;
+    entry.writeUInt16LE(1, 4);
+    entry.writeUInt16LE(32, 6);
+    entry.writeUInt32LE(png.length, 8);
+    entry.writeUInt32LE(offset, 12);
+    entries.push(entry);
+    offset += png.length;
+  }
+  return Buffer.concat([header, ...entries, ...pngs.map((p) => p.png)]);
+}
+
+const dir = path.join(__dirname, "..", "build");
+if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+const trayPng = makePng(16, 16, drawEye);
+fs.writeFileSync(path.join(dir, "tray.png"), trayPng);
+fs.writeFileSync(path.join(dir, "tray@2x.png"), makePng(32, 32, drawEye));
+console.log("Wrote build/tray.png, build/tray@2x.png");
+
+const icon256 = makePng(256, 256, drawEye);
+fs.writeFileSync(path.join(dir, "icon.png"), icon256);
+console.log("Wrote build/icon.png (256x256)");
+
+const ico = makeIco([16, 32, 48, 64, 128, 256]);
+fs.writeFileSync(path.join(dir, "icon.ico"), ico);
+console.log("Wrote build/icon.ico (" + ico.length + " bytes, multi-size)");

package/src/data/exercises.ts

@@ -0,0 +1,120 @@
+import { Exercise } from "../shared/types";
+
+export const EXERCISES: Exercise[] = [
+  {
+    id: "20-20-20",
+    name: "20-20-20 Rule",
+    shortDescription: "Look at something 20 feet away for 20 seconds.",
+    steps: [
+      {
+        text: "Look at an object at least 20 feet (6 m) away — out a window or across the room.",
+        durationSeconds: 20,
+      },
+    ],
+    source: "American Academy of Ophthalmology",
+    sourceUrl: "https://www.aao.org/eye-health/tips-prevention/computer-vision-syndrome",
+    forBreakTypes: ["mini", "long"],
+  },
+  {
+    id: "conscious-blink",
+    name: "Conscious Blinking",
+    shortDescription: "Blink slowly to remoisten your eyes.",
+    steps: [
+      { text: "Close your eyes gently and softly for 2 seconds.", durationSeconds: 2 },
+      { text: "Open slowly. Repeat the slow blink at a relaxed pace.", durationSeconds: 18 },
+    ],
+    source: "American Academy of Ophthalmology — Computer Vision Syndrome",
+    sourceUrl: "https://www.aao.org/eye-health/tips-prevention/computer-vision-syndrome",
+    forBreakTypes: ["mini", "long"],
+  },
+  {
+    id: "near-far-focus",
+    name: "Near-Far Focus Shift",
+    shortDescription: "Alternate focus between a near and distant target.",
+    steps: [
+      { text: "Hold your finger 10-15 inches (25-38 cm) from your eyes and focus on it.", durationSeconds: 5 },
+      { text: "Shift focus to an object 20 feet (6 m) or farther away.", durationSeconds: 5 },
+      { text: "Back to your finger.", durationSeconds: 5 },
+      { text: "Back to the distant object. Repeat smoothly.", durationSeconds: 5 },
+    ],
+    source: "American Optometric Association — Computer Vision Initiative",
+    sourceUrl: "https://www.aoa.org/healthy-eyes/caring-for-your-eyes/protecting-your-eyes/computer-vision-syndrome",
+    forBreakTypes: ["long"],
+  },
+  {
+    id: "figure-eight",
+    name: "Figure-8 Tracing",
+    shortDescription: "Trace an imaginary figure-8 with your eyes to relax eye muscles.",
+    steps: [
+      { text: "Imagine a large figure-8 on the wall about 10 feet (3 m) away.", durationSeconds: 5 },
+      { text: "Slowly trace it one way with your eyes only (head still).", durationSeconds: 10 },
+      { text: "Reverse direction and trace it back.", durationSeconds: 10 },
+    ],
+    source: "American Academy of Ophthalmology — Eye Exercises",
+    sourceUrl: "https://www.aao.org/eye-health/tips-prevention/eye-exercises",
+    forBreakTypes: ["long"],
+  },
+  {
+    id: "palming",
+    name: "Palming",
+    shortDescription: "Cover closed eyes with warm palms to relax.",
+    steps: [
+      { text: "Rub your palms together until they feel warm.", durationSeconds: 5 },
+      { text: "Close your eyes and cup your palms over them without pressing on the eyeballs.", durationSeconds: 30 },
+      { text: "Breathe slowly and relax. Keep the position.", durationSeconds: 25 },
+    ],
+    source: "American Academy of Ophthalmology — Eye Exercises",
+    sourceUrl: "https://www.aao.org/eye-health/tips-prevention/eye-exercises",
+    forBreakTypes: ["long"],
+  },
+  {
+    id: "horizontal-rolls",
+    name: "Horizontal Eye Rolls",
+    shortDescription: "Slow horizontal eye movement to relieve fatigue.",
+    steps: [
+      { text: "Look as far right as comfortable (head still).", durationSeconds: 4 },
+      { text: "Slowly move your gaze to the far left.", durationSeconds: 4 },
+      { text: "Back to center.", durationSeconds: 2 },
+      { text: "Repeat the slow sweep a few more times.", durationSeconds: 10 },
+    ],
+    source: "American Academy of Ophthalmology — Eye Exercises",
+    sourceUrl: "https://www.aao.org/eye-health/tips-prevention/eye-exercises",
+    forBreakTypes: ["mini", "long"],
+  },
+];
+
+export function exercisesForBreak(type: "mini" | "long", durationSeconds: number): Exercise[] {
+  const pool = EXERCISES.filter((e) => e.forBreakTypes.includes(type));
+  if (pool.length === 0) return [];
+
+  const selected: Exercise[] = [];
+  let used = 0;
+  let i = 0;
+
+  while (used < durationSeconds) {
+    const ex = pool[i % pool.length];
+    const exTotal = ex.steps.reduce((s, st) => s + st.durationSeconds, 0);
+    const remaining = durationSeconds - used;
+
+    if (exTotal <= remaining) {
+      selected.push({ ...ex, id: ex.id + "-" + i });
+      used += exTotal;
+    } else {
+      const scaled: Exercise = {
+        ...ex,
+        id: ex.id + "-" + i,
+        steps: ex.steps.map((st) => ({
+          text: st.text,
+          durationSeconds: Math.max(3, Math.round((st.durationSeconds / exTotal) * remaining)),
+        })),
+      };
+      const scaledTotal = scaled.steps.reduce((s, st) => s + st.durationSeconds, 0);
+      selected.push(scaled);
+      used += scaledTotal;
+      break;
+    }
+    i += 1;
+  }
+
+  return selected;
+}

package/src/data/i18n.ts

@@ -0,0 +1,297 @@
+import { Language } from "../shared/types";
+
+export type ExerciseTranslations = {
+  name: string;
+  shortDescription: string;
+  steps: string[];
+};
+
+export type TranslationKey =
+  | "appTitle"
+  | "settingsTitle"
+  | "settingsHint"
+  | "miniBreakSection"
+  | "longBreakSection"
+  | "generalSection"
+  | "enableMiniBreaks"
+  | "enableLongBreaks"
+  | "intervalMinutes"
+  | "durationSeconds"
+  | "soundNotifications"
+  | "strictMode"
+  | "strictModeHint"
+  | "languageLabel"
+  | "saved"
+  | "medicalDisclaimer"
+  | "breakTitleMini"
+  | "breakSubtitleMini"
+  | "breakTitleLong"
+  | "breakSubtitleLong"
+  | "breakComplete"
+  | "breakCompleteSubtitle"
+  | "skipBreak"
+  | "sourcePrefix"
+  | "restEyes"
+  | "restEyesInstruction"
+  | "trayNextBreak"
+  | "trayPaused"
+  | "trayTakeMiniNow"
+  | "trayTakeLongNow"
+  | "trayPause1Hour"
+  | "trayResume"
+  | "traySettings"
+  | "trayAbout"
+  | "trayQuit"
+  | "noBreakScheduled"
+  | "exercise20_20_20"
+  | "exerciseConsciousBlink"
+  | "exerciseNearFarFocus"
+  | "exerciseFigure8"
+  | "exercisePalming"
+  | "exerciseHorizontalRolls"
+  | "guideLook20ft"
+  | "guideYou"
+  | "guideFarL"
+  | "guideFarR"
+  | "guideSlowBlink"
+  | "guideNear"
+  | "guideFar"
+  | "guideTrace8"
+  | "guideWarmPalms"
+  | "guideBreathe"
+  | "guideSweepLR"
+  | "guideL"
+  | "guideR"
+  | "guideRestEyes"
+  | "step20_20_20"
+  | "stepBlinkClose"
+  | "stepBlinkOpen"
+  | "stepNearFocus"
+  | "stepFarFocus"
+  | "stepNearBack"
+  | "stepFarBack"
+  | "stepFigure8Imagine"
+  | "stepFigure8Trace"
+  | "stepFigure8Reverse"
+  | "stepPalmRub"
+  | "stepPalmCover"
+  | "stepPalmBreathe"
+  | "stepHoriRight"
+  | "stepHoriLeft"
+  | "stepHoriCenter"
+  | "stepHoriRepeat";
+
+type Dict = Record<TranslationKey, string>;
+
+const en: Dict = {
+  appTitle: "eye-care",
+  settingsTitle: "eye-care Settings",
+  settingsHint: "Adjust break intervals and durations. Changes are saved automatically.",
+  miniBreakSection: "Mini break",
+  longBreakSection: "Long break",
+  generalSection: "General",
+  enableMiniBreaks: "Enable mini breaks",
+  enableLongBreaks: "Enable long breaks",
+  intervalMinutes: "Interval (minutes)",
+  durationSeconds: "Duration (seconds)",
+  soundNotifications: "Sound notifications",
+  strictMode: "Strict mode (no skip)",
+  strictModeHint: "",
+  languageLabel: "Language",
+  saved: "Saved",
+  medicalDisclaimer:
+    "eye-care is for eye-fatigue relief only. It is not a medical device and does not diagnose, treat, or cure any condition. If you experience persistent eye discomfort, consult a licensed ophthalmologist.",
+  breakTitleMini: "Mini eye break",
+  breakSubtitleMini: "A quick reset for your eyes.",
+  breakTitleLong: "Long eye break",
+  breakSubtitleLong: "Follow the guided exercises.",
+  breakComplete: "Break complete",
+  breakCompleteSubtitle: "Great job. Back to work!",
+  skipBreak: "Skip break",
+  sourcePrefix: "Source: ",
+  restEyes: "Rest your eyes",
+  restEyesInstruction: "Look away from the screen and relax.",
+  trayNextBreak: "Next: ",
+  trayPaused: "Paused — resumes in ~",
+  trayTakeMiniNow: "Take a mini break now",
+  trayTakeLongNow: "Take a long break now",
+  trayPause1Hour: "Pause breaks for 1 hour",
+  trayResume: "Resume breaks",
+  traySettings: "Settings...",
+  trayAbout: "About eye-care",
+  trayQuit: "Quit",
+  noBreakScheduled: "No break scheduled",
+  exercise20_20_20: "20-20-20 Rule",
+  exerciseConsciousBlink: "Conscious Blinking",
+  exerciseNearFarFocus: "Near-Far Focus Shift",
+  exerciseFigure8: "Figure-8 Tracing",
+  exercisePalming: "Palming",
+  exerciseHorizontalRolls: "Horizontal Eye Rolls",
+  guideLook20ft: "Look 20 ft (6 m) away",
+  guideYou: "you",
+  guideFarL: "far L",
+  guideFarR: "far R",
+  guideSlowBlink: "Slow blink",
+  guideNear: "Near",
+  guideFar: "Far",
+  guideTrace8: "Trace the 8 with your eyes",
+  guideWarmPalms: "Warm palms over closed eyes",
+  guideBreathe: "breathe",
+  guideSweepLR: "Sweep your gaze left to right",
+  guideL: "L",
+  guideR: "R",
+  guideRestEyes: "Rest your eyes",
+  step20_20_20: "Look at an object at least 20 feet (6 m) away — out a window or across the room.",
+  stepBlinkClose: "Close your eyes gently and softly for 2 seconds.",
+  stepBlinkOpen: "Open slowly. Repeat the slow blink at a relaxed pace.",
+  stepNearFocus: "Hold your finger 10-15 inches (25-38 cm) from your eyes and focus on it.",
+  stepFarFocus: "Shift focus to an object 20 feet (6 m) or farther away.",
+  stepNearBack: "Back to your finger.",
+  stepFarBack: "Back to the distant object. Repeat smoothly.",
+  stepFigure8Imagine: "Imagine a large figure-8 on the wall about 10 feet (3 m) away.",
+  stepFigure8Trace: "Slowly trace it one way with your eyes only (head still).",
+  stepFigure8Reverse: "Reverse direction and trace it back.",
+  stepPalmRub: "Rub your palms together until they feel warm.",
+  stepPalmCover: "Close your eyes and cup your palms over them without pressing on the eyeballs.",
+  stepPalmBreathe: "Breathe slowly and relax. Keep the position.",
+  stepHoriRight: "Look as far right as comfortable (head still).",
+  stepHoriLeft: "Slowly move your gaze to the far left.",
+  stepHoriCenter: "Back to center.",
+  stepHoriRepeat: "Repeat the slow sweep a few more times.",
+};
+
+const ko: Dict = {
+  appTitle: "eye-care",
+  settingsTitle: "eye-care 설정",
+  settingsHint: "휴식 간격과 시간을 조정하세요. 변경사항은 자동 저장됩니다.",
+  miniBreakSection: "미니 휴식",
+  longBreakSection: "긴 휴식",
+  generalSection: "일반",
+  enableMiniBreaks: "미니 휴식 사용",
+  enableLongBreaks: "긴 휴식 사용",
+  intervalMinutes: "간격 (분)",
+  durationSeconds: "시간 (초)",
+  soundNotifications: "소리 알림",
+  strictMode: "엄격 모드 (건너뛰기 금지)",
+  strictModeHint: "",
+  languageLabel: "언어",
+  saved: "저장됨",
+  medicalDisclaimer:
+    "eye-care는 눈 피로 완화 목적입니다. 의료기기가 아니며 질환을 진단·치료·완치하지 않습니다. 지속적인 눈 불편함이 있다면 안과 전문의와 상담하세요.",
+  breakTitleMini: "미니 눈 휴식",
+  breakSubtitleMini: "눈에 빠른 휴식을 주세요.",
+  breakTitleLong: "긴 눈 휴식",
+  breakSubtitleLong: "가이드를 따라 운동해주세요.",
+  breakComplete: "휴식 완료",
+  breakCompleteSubtitle: "잘했어요. 다시 일어볼까요!",
+  skipBreak: "휴식 건너뛰기",
+  sourcePrefix: "출처: ",
+  restEyes: "눈 휴식",
+  restEyesInstruction: "화면에서 눈을 떼고 편안히 쉬세요.",
+  trayNextBreak: "다음: ",
+  trayPaused: "일시정지 — 약 ",
+  trayTakeMiniNow: "지금 미니 휴식하기",
+  trayTakeLongNow: "지금 긴 휴식하기",
+  trayPause1Hour: "1시간 동안 휴식 일시정지",
+  trayResume: "휴식 재개",
+  traySettings: "설정...",
+  trayAbout: "eye-care 정보",
+  trayQuit: "종료",
+  noBreakScheduled: "예정된 휴식 없음",
+  exercise20_20_20: "20-20-20 규칙",
+  exerciseConsciousBlink: "의식적 깜빡임",
+  exerciseNearFarFocus: "원근 촛점 교대",
+  exerciseFigure8: "8자 추적",
+  exercisePalming: "파밍 (손바닥 덮기)",
+  exerciseHorizontalRolls: "좌우 눈 운동",
+  guideLook20ft: "20피트(6m) 너머 보기",
+  guideYou: "나",
+  guideFarL: "왼쪽 먼 곳",
+  guideFarR: "오른쪽 먼 곳",
+  guideSlowBlink: "천천히 깜빡이기",
+  guideNear: "가까이",
+  guideFar: "멀리",
+  guideTrace8: "눈으로 8자를 따라가세요",
+  guideWarmPalms: "따뜻한 손바닥으로 눈 덮기",
+  guideBreathe: "호흡",
+  guideSweepLR: "시선을 좌에서 우로 천천히",
+  guideL: "좌",
+  guideR: "우",
+  guideRestEyes: "눈 휴식",
+  step20_20_20: "20피트(6m) 이상 먼 곳을 바라보세요 — 창밖이나 방 반대편.",
+  stepBlinkClose: "부드럽게 2초간 눈을 감으세요.",
+  stepBlinkOpen: "천천히 뜨세요. 편안한 속도로 반복합니다.",
+  stepNearFocus: "손가락을 눈에서 25-38cm 거리에 두고 응시하세요.",
+  stepFarFocus: "20피트(6m) 이상 먼 곳의 사물로 초점을 옮기세요.",
+  stepNearBack: "다시 손가락으로.",
+  stepFarBack: "다시 먼 곳으로. 부드럽게 반복하세요.",
+  stepFigure8Imagine: "약 3m 앞 벽에 큰 8자가 있다고 상상하세요.",
+  stepFigure8Trace: "머리는 움직이지 말고 눈만으로 한 방향으로 천천히 따라가세요.",
+  stepFigure8Reverse: "반대 방향으로 되돌아 가세요.",
+  stepPalmRub: "손바닥을 비벼 따뜻하게 만드세요.",
+  stepPalmCover: "눈을 감고 손바닥을 눈 위에 덮으세요 (안구를 누르지 마세요).",
+  stepPalmBreathe: "천천히 호흡하며 편안히 유지하세요.",
+  stepHoriRight: "머리는 그대로 둔 채 시선을 편안한 오른쪽 끝으로.",
+  stepHoriLeft: "시선을 천천히 왼쪽 끝으로 옮기세요.",
+  stepHoriCenter: "다시 중앙으로.",
+  stepHoriRepeat: "느린 좌우 스윕을 몇 번 더 반복하세요.",
+};
+
+const DICTS: Record<Language, Dict> = { en, ko };
+
+export function t(lang: Language, key: TranslationKey): string {
+  return DICTS[lang][key] ?? DICTS.en[key] ?? key;
+}
+
+export function getExerciseTranslations(lang: Language): Record<string, ExerciseTranslations> {
+  return {
+    "20-20-20": {
+      name: t(lang, "exercise20_20_20"),
+      shortDescription: lang === "ko" ? "20피트(6m) 너머를 20초간 바라보세요." : "Look at something 20 feet away for 20 seconds.",
+      steps: [t(lang, "step20_20_20")],
+    },
+    "conscious-blink": {
+      name: t(lang, "exerciseConsciousBlink"),
+      shortDescription: lang === "ko" ? "천천히 깜빡여 눈을 적셔주세요." : "Blink slowly to remoisten your eyes.",
+      steps: [t(lang, "stepBlinkClose"), t(lang, "stepBlinkOpen")],
+    },
+    "near-far-focus": {
+      name: t(lang, "exerciseNearFarFocus"),
+      shortDescription: lang === "ko" ? "가까운 곳과 먼 곳을 번갈아 응시하세요." : "Alternate focus between a near and distant target.",
+      steps: [
+        t(lang, "stepNearFocus"),
+        t(lang, "stepFarFocus"),
+        t(lang, "stepNearBack"),
+        t(lang, "stepFarBack"),
+      ],
+    },
+    "figure-eight": {
+      name: t(lang, "exerciseFigure8"),
+      shortDescription: lang === "ko" ? "상상의 8자를 눈으로 추적하며 안근을 이완하세요." : "Trace an imaginary figure-8 with your eyes to relax eye muscles.",
+      steps: [
+        t(lang, "stepFigure8Imagine"),
+        t(lang, "stepFigure8Trace"),
+        t(lang, "stepFigure8Reverse"),
+      ],
+    },
+    "palming": {
+      name: t(lang, "exercisePalming"),
+      shortDescription: lang === "ko" ? "따뜻한 손바닥으로 감은 눈을 덮어 휴식하세요." : "Cover closed eyes with warm palms to relax.",
+      steps: [
+        t(lang, "stepPalmRub"),
+        t(lang, "stepPalmCover"),
+        t(lang, "stepPalmBreathe"),
+      ],
+    },
+    "horizontal-rolls": {
+      name: t(lang, "exerciseHorizontalRolls"),
+      shortDescription: lang === "ko" ? "느린 좌우 눈 운동으로 피로를 풀어주세요." : "Slow horizontal eye movement to relieve fatigue.",
+      steps: [
+        t(lang, "stepHoriRight"),
+        t(lang, "stepHoriLeft"),
+        t(lang, "stepHoriCenter"),
+        t(lang, "stepHoriRepeat"),
+      ],
+    },
+  };
+}

package/src/main/backgrounds.ts

@@ -0,0 +1,144 @@
+import { app, dialog, ipcMain, BrowserWindow } from "electron";
+import * as path from "path";
+import * as fs from "fs";
+import { BackgroundConfig, BackgroundMode } from "../shared/types";
+
+const BUILTIN_BACKGROUNDS = ["sunny-sky", "forest", "sea", "mountains", "sunset"];
+
+function userBackgroundsDir(): string {
+  return path.join(app.getPath("userData"), "backgrounds");
+}
+
+function builtinBackgroundsDir(): string {
+  return path.join(__dirname, "..", "renderer", "backgrounds");
+}
+
+export function ensureUserBackgroundsDir(): void {
+  const dir = userBackgroundsDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+export function listUserBackgrounds(): string[] {
+  const dir = userBackgroundsDir();
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => /\.(png|jpe?g|webp|gif|svg)$/i.test(f))
+    .map((f) => path.parse(f).name);
+}
+
+export function listBuiltinBackgrounds(): string[] {
+  return BUILTIN_BACKGROUNDS;
+}
+
+export function resolveBackgroundPath(name: string, mode: BackgroundMode): string | null {
+  if (mode === "builtin") {
+    const file = path.join(builtinBackgroundsDir(), name + ".svg");
+    return fs.existsSync(file) ? file : null;
+  }
+  if (mode === "user") {
+    const dir = userBackgroundsDir();
+    if (!fs.existsSync(dir)) return null;
+    const candidates = fs
+      .readdirSync(dir)
+      .filter((f) => path.parse(f).name === name && /\.(png|jpe?g|webp|gif|svg)$/i.test(f));
+    if (candidates.length > 0) return path.join(dir, candidates[0]);
+  }
+  return null;
+}
+
+export function pickRandomBackground(pool: "builtin" | "user" | "all"): string | null {
+  let poolNames: { name: string; mode: "builtin" | "user" }[] = [];
+  if (pool === "builtin" || pool === "all") {
+    poolNames = poolNames.concat(listBuiltinBackgrounds().map((n) => ({ name: n, mode: "builtin" as const })));
+  }
+  if (pool === "user" || pool === "all") {
+    poolNames = poolNames.concat(listUserBackgrounds().map((n) => ({ name: n, mode: "user" as const })));
+  }
+  if (poolNames.length === 0) return null;
+  const pick = poolNames[Math.floor(Math.random() * poolNames.length)];
+  const file = resolveBackgroundPath(pick.name, pick.mode);
+  return file;
+}
+
+const ALLOWED_EXT = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"];
+
+export function registerBackgroundIpc(getConfig: () => BackgroundConfig, setConfig: (c: BackgroundConfig) => void): void {
+  ensureUserBackgroundsDir();
+
+  ipcMain.handle("bg:listBuiltin", () => listBuiltinBackgrounds());
+  ipcMain.handle("bg:listUser", () => listUserBackgrounds());
+
+  ipcMain.handle("bg:addUser", async (e) => {
+    const parentWindow = BrowserWindow.fromWebContents(e.sender);
+    const opts: Electron.OpenDialogOptions = {
+      title: "Select background image",
+      properties: ["openFile", "multiSelections"],
+      filters: [
+        { name: "Images", extensions: ["png", "jpg", "jpeg", "webp", "gif", "svg"] },
+      ],
+    };
+    const result = parentWindow
+      ? await dialog.showOpenDialog(parentWindow, opts)
+      : await dialog.showOpenDialog(opts);
+    if (result.canceled || result.filePaths.length === 0) return { added: [] };
+    const dir = userBackgroundsDir();
+    const added: string[] = [];
+    for (const src of result.filePaths) {
+      const ext = path.extname(src).toLowerCase();
+      if (!ALLOWED_EXT.includes(ext)) continue;
+      const base = path.parse(src).name.replace(/[^\w-]/g, "_");
+      const dest = path.join(dir, base + ext);
+      try {
+        fs.copyFileSync(src, dest);
+        added.push(base);
+      } catch (err) {
+        console.error("Failed to copy background:", err);
+      }
+    }
+    if (added.length > 0) {
+      const cfg = getConfig();
+      const merged = Array.from(new Set([...cfg.userImages, ...added]));
+      setConfig({ ...cfg, userImages: merged });
+    }
+    return { added };
+  });
+
+  ipcMain.handle("bg:deleteUser", (_e, name: string) => {
+    const dir = userBackgroundsDir();
+    const candidates = fs
+      .readdirSync(dir)
+      .filter((f) => path.parse(f).name === name && /\.(png|jpe?g|webp|gif|svg)$/i.test(f));
+    for (const c of candidates) {
+      try {
+        fs.unlinkSync(path.join(dir, c));
+      } catch (err) {
+        console.error("Failed to delete background:", err);
+      }
+    }
+    const cfg = getConfig();
+    setConfig({ ...cfg, userImages: cfg.userImages.filter((n) => n !== name) });
+    return true;
+  });
+
+  ipcMain.handle("bg:set", (_e, cfg: BackgroundConfig) => {
+    setConfig(cfg);
+    return cfg;
+  });
+
+  ipcMain.handle("bg:get", () => getConfig());
+
+  ipcMain.handle("bg:loadFile", (_e, name: string, mode: BackgroundMode) => {
+    const p = resolveBackgroundPath(name, mode);
+    if (!p) return null;
+    try {
+      const data = fs.readFileSync(p);
+      const ext = path.extname(p).slice(1).toLowerCase();
+      const mime = ext === "svg" ? "image/svg+xml" : "image/" + ext;
+      return { mime, data: data.toString("base64") };
+    } catch (err) {
+      console.error("Failed to load background file:", err);
+      return null;
+    }
+  });
+}