import { app, BrowserWindow, ipcMain } from "electron";
import path from "node:path";

function createWindow() {
  const win = new BrowserWindow({
    webPreferences: {
      preload: path.join(__dirname, "preload.js"),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
    },
  });
  if (app.isPackaged) void win.loadFile(path.join(__dirname, "../renderer/index.html"));
  else void win.loadURL("http://localhost:5173");
}

app.whenReady().then(createWindow);
// Register narrow IPC handlers in this trusted process.

import { contextBridge, ipcRenderer } from "electron";

contextBridge.exposeInMainWorld("desktopApi", {
  products: {
    list: (input: { page: number; pageSize: number; search?: string }) =>
      ipcRenderer.invoke("products:list", input),
    create: (input: { name: string; price: number }) =>
      ipcRenderer.invoke("products:create", input),
  },
});
// Never expose raw ipcRenderer or arbitrary filesystem/SQL access.

import { ipcMain } from "electron";

function parseListInput(value: unknown) {
  if (!value || typeof value !== "object") throw new Error("Invalid input");
  const input = value as Record<string, unknown>;
  const page = Number(input.page);
  const pageSize = Number(input.pageSize);
  const search = typeof input.search === "string" ? input.search.trim().slice(0, 100) : "";
  if (!Number.isInteger(page) || page < 1) throw new Error("Invalid page");
  if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw new Error("Invalid page size");
  return { page, pageSize, search };
}

ipcMain.handle("products:list", async (_event, value: unknown) => {
  const { page, pageSize, search } = parseListInput(value);
  const offset = (page - 1) * pageSize;
  return db.all(
    `SELECT id, name, price FROM products
     WHERE name LIKE ? ORDER BY name, id LIMIT ? OFFSET ?`,
    [`%${search}%`, pageSize, offset],
  );
});

import sqlite3 from "sqlite3";

export const db = new sqlite3.Database(databasePath);

export function run(sql: string, params: unknown[] = []) {
  return new Promise<{ lastID: number; changes: number }>((resolve, reject) => {
    db.run(sql, params, function (error) {
      if (error) reject(error);
      else resolve({ lastID: this.lastID, changes: this.changes });
    });
  });
}

export function all<T>(sql: string, params: unknown[] = []) {
  return new Promise<T[]>((resolve, reject) => {
    db.all(sql, params, (error, rows) => error ? reject(error) : resolve(rows as T[]));
  });
}

export async function initializeDatabase() {
  await run("PRAGMA foreign_keys = ON");
  await run("PRAGMA journal_mode = WAL");
  await run("PRAGMA synchronous = NORMAL");
  await run(`CREATE TABLE IF NOT EXISTS products (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    price INTEGER NOT NULL CHECK(price >= 0),
    created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
  )`);
}

export async function createSale(input: SaleInput) {
  await run("BEGIN IMMEDIATE");
  try {
    const sale = await run(
      "INSERT INTO sales (customer_id, total) VALUES (?, ?)",
      [input.customerId, input.total],
    );
    for (const line of input.lines) {
      const update = await run(
        "UPDATE products SET stock = stock - ? WHERE id = ? AND stock >= ?",
        [line.quantity, line.productId, line.quantity],
      );
      if (update.changes !== 1) throw new Error("Insufficient stock");
      await run(
        "INSERT INTO sale_lines (sale_id, product_id, quantity, price) VALUES (?, ?, ?, ?)",
        [sale.lastID, line.productId, line.quantity, line.price],
      );
    }
    await run("COMMIT");
    return sale.lastID;
  } catch (error) {
    await run("ROLLBACK");
    throw error;
  }
}

const pageSize = Math.min(Math.max(input.pageSize, 1), 100);
const offset = (input.page - 1) * pageSize;

const rows = await all<Product>(
  `SELECT id, name, price FROM products
   WHERE name LIKE ?
   ORDER BY name ASC, id ASC
   LIMIT ? OFFSET ?`,
  [`%${input.search}%`, pageSize, offset],
);
const countRows = await all<{ count: number }>(
  "SELECT COUNT(*) AS count FROM products WHERE name LIKE ?",
  [`%${input.search}%`],
);
return { rows, total: countRows[0]?.count ?? 0, page: input.page, pageSize };

type Migration = { version: number; sql: string };
const migrations: Migration[] = [
  { version: 1, sql: `CREATE TABLE IF NOT EXISTS schema_migrations (
      version INTEGER PRIMARY KEY, applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
    ); CREATE TABLE IF NOT EXISTS customers (
      id INTEGER PRIMARY KEY, name TEXT NOT NULL
    );` },
  { version: 2, sql: `ALTER TABLE customers ADD COLUMN phone TEXT;` },
];

// Production code should apply each migration transactionally where supported,
// record its version only after success, and handle already-applied versions.

// Pseudocode: adapt to the SQLite driver/API used by the project.
export async function createBackup(destination: string) {
  // Pause or serialize app writes if your backup method requires it.
  // Prefer SQLite online backup API when available, especially with WAL enabled.
  await db.backup(destination);
  await verifyDatabaseFile(destination); // e.g. open copy and run integrity_check
}

export async function verifyDatabaseFile(filePath: string) {
  const copy = openReadOnlyDatabase(filePath);
  const result = await copy.get("PRAGMA integrity_check");
  if (result.integrity_check !== "ok") throw new Error("Backup integrity check failed");
  await copy.close();
}