import { createConverter } from '@matbee/libreoffice-converter';

const converter = await createConverter({
  wasmPath: './wasm',
  verbose: false,
  onProgress: (info) => console.log(info.message),
  onReady: () => console.log('Ready!'),
  onError: (err) => console.error(err),
});

const result = await converter.convert(
  inputBuffer,
  {
    outputFormat: 'pdf',
    inputFormat: 'docx',  // Optional, auto-detected from filename
    password: 'secret',   // For encrypted documents
    pdf: {
      pdfaLevel: 'PDF/A-2b',
      quality: 90,
    },
  },
  'document.docx'  // Optional filename for format detection
);

interface ConversionResult {
  data: Uint8Array;      // Converted document bytes
  mimeType: string;      // MIME type of output
  filename: string;      // Suggested output filename
  duration: number;      // Conversion time in ms
}

await converter.destroy();

import { convertDocument } from '@matbee/libreoffice-converter';

const result = await convertDocument(
  inputBuffer,
  { outputFormat: 'pdf' },
  { wasmPath: './wasm' }
);

import { createWorkerConverter } from '@matbee/libreoffice-converter';

const converter = await createWorkerConverter({
  wasmPath: './wasm',
  verbose: false,
});

// Same API as LibreOfficeConverter
const result = await converter.convert(docxBuffer, { outputFormat: 'pdf' });
await converter.destroy();

import { createSubprocessConverter } from '@matbee/libreoffice-converter';

const converter = await createSubprocessConverter({
  wasmPath: './wasm',
});

const result = await converter.convert(xlsxBuffer, { outputFormat: 'pdf' }, 'report.xlsx');
await converter.destroy();

import { LibreOfficeConverter } from '@matbee/libreoffice-converter';

const formats = LibreOfficeConverter.getSupportedInputFormats();
// ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp', ...]

const formats = LibreOfficeConverter.getSupportedOutputFormats();
// ['pdf', 'docx', 'doc', 'odt', 'rtf', 'txt', 'html', 'xlsx', ...]

import { isConversionSupported } from '@matbee/libreoffice-converter';

isConversionSupported('docx', 'pdf');   // true
isConversionSupported('pdf', 'docx');   // false - PDFs can't be converted to DOCX
isConversionSupported('xlsx', 'csv');   // true
isConversionSupported('pptx', 'xlsx');  // false - can't convert presentations to spreadsheets

import { getValidOutputFormatsFor } from '@matbee/libreoffice-converter';

getValidOutputFormatsFor('docx');
// ['pdf', 'docx', 'doc', 'odt', 'rtf', 'txt', 'html', 'png']

getValidOutputFormatsFor('xlsx');
// ['pdf', 'xlsx', 'xls', 'ods', 'csv', 'html', 'png']

getValidOutputFormatsFor('pdf');
// ['pdf', 'png', 'svg', 'html'] (PDFs are imported as Draw documents)

import {
  isConversionSupported,
  getValidOutputFormatsFor,
  getConversionErrorMessage,
} from '@matbee/libreoffice-converter';

function validateConversion(inputFile: string, outputFormat: string) {
  const ext = inputFile.split('.').pop()?.toLowerCase();

  if (!isConversionSupported(ext, outputFormat)) {
    throw new Error(getConversionErrorMessage(ext, outputFormat));
    // "Cannot convert PDF to DOCX. PDF files are imported as Draw documents
    //  and cannot be exported to Office formats. Valid output formats for PDF:
    //  pdf, png, svg, html"
  }
}

import { WorkerBrowserConverter, createWasmPaths } from '@matbee/libreoffice-converter/browser';

const converter = new WorkerBrowserConverter({
  ...createWasmPaths('/wasm/'),
  browserWorkerJs: '/dist/browser-worker.js',
  onProgress: (progress) => {
    // progress is a WasmLoadProgress object
    console.log(`Phase: ${progress.phase}`);
    console.log(`Progress: ${progress.percent}%`);
    console.log(`Message: ${progress.message}`);

    // During download phases, bytes info is available
    if (progress.bytesLoaded !== undefined) {
      const mb = (progress.bytesLoaded / 1024 / 1024).toFixed(1);
      const totalMb = (progress.bytesTotal! / 1024 / 1024).toFixed(1);
      console.log(`Downloaded: ${mb} MB / ${totalMb} MB`);
    }
  },
});

interface WasmLoadProgress {
  /** Overall progress 0-100 */
  percent: number;
  /** Human-readable status message */
  message: string;
  /** Current loading phase */
  phase: WasmLoadPhase;
  /** Bytes downloaded (present during download phases) */
  bytesLoaded?: number;
  /** Total bytes to download (present during download phases) */
  bytesTotal?: number;
}

type WasmLoadPhase =
  | 'download-wasm'    // Downloading soffice.wasm (~142MB)
  | 'download-data'    // Downloading soffice.data (~96MB)
  | 'compile'          // WebAssembly compilation
  | 'filesystem'       // Emscripten filesystem setup
  | 'lok-init'         // LibreOfficeKit initialization
  | 'ready';           // Complete

// Node.js
import { createWorkerConverter } from '@matbee/libreoffice-converter';

const converter = await createWorkerConverter({ wasmPath: './wasm' });

const docInfo = await converter.getDocumentInfo(fileBuffer, 'docx');
console.log(docInfo);
// {
//   documentType: 0,           // 0=TEXT, 1=SPREADSHEET, 2=PRESENTATION, 3=DRAWING
//   documentTypeName: 'Text Document',
//   validOutputFormats: ['pdf', 'docx', 'odt', 'html', 'txt', 'png'],
//   pageCount: 5
// }

interface DocumentInfo {
  documentType: number;           // LOK document type enum
  documentTypeName: string;       // Human-readable type name
  validOutputFormats: string[];   // Formats this document can be converted to
  pageCount: number;              // Number of pages/slides/sheets
}

const pageCount = await converter.getPageCount(docxBuffer, 'docx');
console.log(`Document has ${pageCount} pages`);

// Render first page at 800px width (height auto-calculated to maintain aspect ratio)
const preview = await converter.renderPage(pptxBuffer, 'pptx', 0, 800);

// preview.data is a Uint8Array containing raw RGBA pixel data
console.log(`Rendered: ${preview.width}x${preview.height} pixels`);

// Save as PNG (Node.js)
import { createCanvas } from 'canvas';
const canvas = createCanvas(preview.width, preview.height);
const ctx = canvas.getContext('2d');
const imageData = ctx.createImageData(preview.width, preview.height);
imageData.data.set(preview.data);
ctx.putImageData(imageData, 0, 0);
fs.writeFileSync('page-0.png', canvas.toBuffer('image/png'));

interface PagePreview {
  page: number;      // Page index
  data: Uint8Array;  // Raw RGBA pixel data
  width: number;     // Actual rendered width
  height: number;    // Actual rendered height
}

// Render all pages at 400px width
const previews = await converter.renderPagePreviews(pptxBuffer, 'pptx', {
  width: 400,
});

console.log(`Rendered ${previews.length} pages`);
previews.forEach(p => console.log(`Page ${p.page}: ${p.width}x${p.height}`));

// Render only specific pages
const selectedPreviews = await converter.renderPagePreviews(pptxBuffer, 'pptx', {
  width: 800,
  pageIndices: [0, 2, 4],  // Only pages 1, 3, and 5
});

interface RenderOptions {
  /** Width of rendered image in pixels (default: 800) */
  width?: number;
  /** Height of rendered image in pixels (0 = auto based on aspect ratio) */
  height?: number;
  /** Specific page indices to render (0-based). If empty, renders all pages */
  pageIndices?: number[];
}

const text = await converter.getDocumentText(docxBuffer, 'docx');
if (text) {
  console.log('Document text:', text);
} else {
  console.log('No text content found');
}

// For presentations - get slide names
const slideNames = await converter.getPageNames(pptxBuffer, 'pptx');
console.log('Slides:', slideNames);
// ['Introduction', 'Overview', 'Conclusion']

// For spreadsheets - get sheet names
const sheetNames = await converter.getPageNames(xlsxBuffer, 'xlsx');
console.log('Sheets:', sheetNames);
// ['Sheet1', 'Data', 'Summary']

const session = await converter.openDocument(docxBuffer, 'docx');
console.log(session);
// {
//   sessionId: 'edit_session_0_1234567890',
//   documentType: 'writer',  // 'writer', 'calc', or 'impress'
//   pageCount: 5
// }

interface EditorSession {
  sessionId: string;      // Unique session ID for this document
  documentType: string;   // 'writer', 'calc', or 'impress'
  pageCount: number;      // Number of pages/slides/sheets
}

// Get document structure
const structure = await converter.editorOperation(session.sessionId, 'getStructure');
console.log(structure.data);

// Get document type
const docType = await converter.editorOperation(session.sessionId, 'getDocumentType');
console.log(docType.data);  // 'writer', 'calc', or 'impress'

// Insert text (Writer documents)
const result = await converter.editorOperation(
  session.sessionId,
  'insertText',
  'Hello, World!'
);

// Set cell value (Calc documents)
const cellResult = await converter.editorOperation(
  session.sessionId,
  'setCellValue',
  'A1',
  42
);

interface EditorOperationResult<T = unknown> {
  success: boolean;      // Whether the operation succeeded
  verified?: boolean;    // Whether the result was verified
  data?: T;              // Operation result data
  error?: string;        // Error message if failed
  suggestion?: string;   // Suggested fix if failed
}

// Close and get modified document
const modifiedData = await converter.closeDocument(session.sessionId);

if (modifiedData) {
  fs.writeFileSync('modified.docx', modifiedData);
  console.log('Document saved!');
} else {
  console.log('No changes or save failed');
}

import { createWorkerConverter } from '@matbee/libreoffice-converter';
import fs from 'fs';

const converter = await createWorkerConverter({ wasmPath: './wasm' });

// Read document
const docx = fs.readFileSync('template.docx');

// Open for editing
const session = await converter.openDocument(docx, 'docx');
console.log(`Opened ${session.documentType} document with ${session.pageCount} pages`);

// Get current structure
const structure = await converter.editorOperation(session.sessionId, 'getStructure');
console.log('Structure:', structure.data);

// Make modifications...
// (specific operations depend on document type)

// Close and save
const modified = await converter.closeDocument(session.sessionId);
if (modified) {
  fs.writeFileSync('output.docx', modified);
}

await converter.destroy();

import { WorkerBrowserConverter, createWasmPaths } from '@matbee/libreoffice-converter/browser';

const converter = new WorkerBrowserConverter({
  ...createWasmPaths('/wasm/'),
  browserWorkerJs: '/dist/browser-worker.js',
});
await converter.initialize();

const docInfo = await converter.getDocumentInfo(fileBuffer, 'document.docx');

const lokInfo = await converter.getLokInfo();
console.log(lokInfo);
// {
//   version: "24.8.0.0.alpha0...",
//   buildInfo: "..."
// }

import { WorkerBrowserConverter, createWasmPaths } from '@matbee/libreoffice-converter/browser';

const converter = new WorkerBrowserConverter({
  ...createWasmPaths('/wasm/'),
  browserWorkerJs: '/dist/browser-worker.js',
});
await converter.initialize();

async function renderThumbnails(fileBuffer: Uint8Array, filename: string) {
  const docInfo = await converter.getDocumentInfo(fileBuffer, filename);
  const thumbnails: string[] = [];

  for (let i = 0; i < docInfo.pageCount; i++) {
    const pageData = await converter.renderSinglePage(fileBuffer, filename, {
      pageIndex: i,
      dpi: 72,  // Low DPI for thumbnails
    });

    const blob = new Blob([pageData], { type: 'image/png' });
    thumbnails.push(URL.createObjectURL(blob));
  }

  return thumbnails;
}

const result = await converter.convert(input, {
  outputFormat: 'pdf',
  pdf: {
    // PDF/A compliance level
    pdfaLevel: 'PDF/A-2b',  // 'PDF/A-1b', 'PDF/A-2b', 'PDF/A-3b'
    
    // Image quality (0-100)
    quality: 90,
  },
});

const result = await converter.convert(input, {
  outputFormat: 'png',
  image: {
    width: 1920,
    height: 1080,
    dpi: 150,
  },
});

const result = await converter.convert(encryptedDoc, {
  outputFormat: 'pdf',
  password: 'document-password',
});