import { PDF } from "@libpdf/core";

const pdf = await PDF.load(bytes);
console.log(`${pdf.getPageCount()} pages`);

// Basic load
const pdf = await PDF.load(bytes);

// With password
const encrypted = await PDF.load(bytes, { credentials: "secret" });

// Strict parsing (throws on malformed PDFs)
const strict = await PDF.load(bytes, { lenient: false });

const pdf = PDF.create();
pdf.addPage({ size: "letter" });
const bytes = await pdf.save();

const merged = await PDF.merge([pdf1Bytes, pdf2Bytes, pdf3Bytes]);
const bytes = await merged.save();

const count = pdf.getPageCount();

const page = await pdf.getPage(0);
if (page) {
  console.log(`Size: ${page.width} x ${page.height}`);
}

const pages = await pdf.getPages();
for (const page of pages) {
  console.log(`Page ${page.index}: ${page.width} x ${page.height}`);
}

// Append US Letter page
const page = pdf.addPage();

// Insert A4 page at beginning
const firstPage = pdf.addPage({ size: "a4", insertAt: 0 });

// Custom size landscape
const wide = pdf.addPage({ width: 1000, height: 500 });

pdf.removePage(0); // Remove first page

pdf.movePage(5, 0); // Move page 5 to the beginning

// Copy pages 0 and 2 from source
const copied = await dest.copyPagesFrom(source, [0, 2]);

// Insert at beginning
await dest.copyPagesFrom(source, [0], { insertAt: 0 });

// Duplicate a page in the same document
await pdf.copyPagesFrom(pdf, [0], { insertAt: 1 });

// Extract first 3 pages
const first3 = await pdf.extractPages([0, 1, 2]);

// Extract odd pages
const oddPages = await pdf.extractPages([0, 2, 4, 6]);

const bytes = await first3.save();

const watermark = await PDF.load(watermarkBytes);
const embedded = await pdf.embedPage(watermark, 0);

// Draw on all pages
for (const page of await pdf.getPages()) {
  page.drawPage(embedded, { opacity: 0.5 });
}

const form = await pdf.getForm();
if (form) {
  const fields = form.getFields();
  console.log(`${fields.length} fields found`);
}

const title = pdf.getTitle();

pdf.setTitle("Quarterly Report");

// Show in viewer's title bar
pdf.setTitle("My Document", { showInWindowTitleBar: true });

pdf.setAuthor("Jane Smith");

pdf.setSubject("Financial summary for Q4");

pdf.setKeywords(["finance", "quarterly", "2024"]);
const keywords = pdf.getKeywords(); // ["finance", "quarterly", "2024"]

pdf.setCreator("Report Generator v2.0");

pdf.setProducer("@libpdf/core");

pdf.setCreationDate(new Date());
const created = pdf.getCreationDate();

pdf.setModificationDate(new Date());

pdf.setLanguage("en-US");

// Get all metadata
const metadata = pdf.getMetadata();

// Set multiple fields
pdf.setMetadata({
  title: "Quarterly Report",
  author: "Jane Smith",
  creationDate: new Date(),
});

const security = pdf.getSecurity();
console.log(`Encrypted: ${security.isEncrypted}`);
console.log(`Algorithm: ${security.algorithm}`);
console.log(`Can copy: ${security.permissions.copy}`);

const perms = pdf.getPermissions();
if (!perms.copy) {
  console.log("Copy/paste is restricted");
}

if (pdf.hasOwnerAccess()) {
  pdf.removeProtection();
}

const result = pdf.authenticate("ownerPassword");
if (result.isOwner) {
  pdf.removeProtection();
}

pdf.setProtection({
  userPassword: "secret",
  ownerPassword: "admin",
  permissions: { copy: false, print: true },
  algorithm: "AES-256",
});

const pdf = await PDF.load(bytes, { credentials: "ownerPassword" });
pdf.removeProtection();
const unprotectedBytes = await pdf.save();

const font = pdf.embedFont(fontBytes);

page.drawText("Hello", {
  font,
  size: 24,
});

const image = await pdf.embedImage(jpegBytes);

page.drawImage(image, {
  x: 50,
  y: 500,
  width: 200,
});

import { P12Signer } from "@libpdf/core";

const signer = await P12Signer.create(p12Bytes, "password");

const result = await pdf.sign({
  signer,
  level: "B-LTA",
  timestampServer: "http://timestamp.example.com",
});

// result.bytes contains the signed PDF

// Full rewrite
const bytes = await pdf.save();

// Incremental (preserves signatures)
const bytes = await pdf.save({ incremental: true });

// With font subsetting
const bytes = await pdf.save({ subsetFonts: true });

const signed = await pdf.sign({ signer });
await pdf.reload(signed.bytes);
// Continue using the same PDF instance

interface LoadOptions {
  credentials?: string;  // User or owner password
  lenient?: boolean;     // Enable lenient parsing (default: true)
}

interface SaveOptions {
  incremental?: boolean;   // Append-only save
  useXRefStream?: boolean; // Use XRef stream format
  subsetFonts?: boolean;   // Subset embedded fonts
}

interface DocumentMetadata {
  title?: string;
  author?: string;
  subject?: string;
  keywords?: string[];
  creator?: string;
  producer?: string;
  creationDate?: Date;
  modificationDate?: Date;
  trapped?: "True" | "False" | "Unknown";
  language?: string;
}

interface SecurityInfo {
  isEncrypted: boolean;
  algorithm?: "RC4-40" | "RC4-128" | "AES-128" | "AES-256";
  keyLength?: number;
  revision?: number;
  hasUserPassword?: boolean;
  hasOwnerPassword?: boolean;
  authenticatedAs?: "user" | "owner" | null;
  permissions: Permissions;
  encryptMetadata?: boolean;
}

interface Permissions {
  print: boolean;
  printHighQuality: boolean;
  modify: boolean;
  copy: boolean;
  annotate: boolean;
  fillForms: boolean;
  assembleDocument: boolean;
  extractForAccessibility: boolean;
}