class Order {
  constructor(
    private customerName: string,
    private customerEmail: string,
    private address: string,
    private totalAmount: number,
    private currency: string,
  ) {
  }

  sendInvoice() {
    if (!this.customerEmail.includes('@')) {
      throw new Error('Email inválido')
    }
    if (this.totalAmount <= 0) {
      throw new Error('El monto debe ser mayor que cero')
    }
    console.log(`Factura enviada a ${this.customerEmail} por ${this.totalAmount} ${this.currency}`)
  }
}

class Order {
    constructor(
        private customerName: string,
        private customerEmail: string,
        private address: string,
        private totalAmount: number,
        private currency: string,
    ) {
    }

    sendInvoice() {
        if (!this.customerEmail.includes('@')) {
            throw new Error('Email inválido')
        }
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        
        let amountWithCurrency: string;
        if (this.currency == 'USD') {
            amountWithCurrency = `$${this.totalAmount}`
        } else if (this.currency == 'EUR') {
            amountWithCurrency = `${this.totalAmount} €`
        } else {
            throw new Error('Moneda no soportada')
        }

        console.log(`Factura enviada a ${this.customerEmail} por ${amountWithCurrency}`)
    }
}

class Order {
    constructor(
        private customerName: string,
        private customerEmail: string,
        private address: string,
        private totalAmount: number,
        private currency: string,
    ) {
    }

    sendInvoice() {
        if (!this.customerEmail.includes('@')) {
            throw new Error('Email inválido')
        }
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${this.customerEmail} por ${(this.formatAmount())}`)
    }

    private formatAmount() {
        if (this.currency == 'USD') {
            return `$${this.totalAmount}`
        } else if (this.currency == 'EUR') {
            return `${this.totalAmount} €`
        } else {
            throw new Error('Moneda no soportada')
        }
    }
}

class Order {
    // Code removed for clarity

    private formatAmount() {
        return formatAmount(this.totalAmount, this.currency)
    }
}

function formatAmount(amount: number, currency: string) {
    if (currency == 'USD') {
        return `$${amount}`
    } else if (currency == 'EUR') {
        return `${amount} €`
    } else {
        throw new Error('Moneda no soportada')
    }
}

class Order {
    // Code removed for clarity

    private formatAmount() {
        return formatAmount(this.totalAmount, this.currency)
    }
}

const currencyFormatters = new Map<string, (amount: number) => string>([
    ['USD', (amount) => `$${amount}`],
    ['EUR', (amount) => `${amount} €`],
])

function formatAmount(amount: number, currency: string) {
    const formatter = currencyFormatters.get(currency)
    if (!formatter) {
        throw new Error('Moneda no soportada')
    }
    return formatter(amount)
}

class Order {
// Code removed for clarity

    private formatAmount() {
        return formatAmount(this.totalAmount, this.currency)
    }
}

const currencyFormatters = new Map<string, (amount: number) => string>([
    ['USD', (amount) => `$${amount}`],
    ['$', (amount) => `$${amount}`],
    ['EUR', (amount) => `${amount} €`],
    ['€', (amount) => `${amount} €`],
])

function formatAmount(amount: number, currency: string) {
    const formatter = currencyFormatters.get(currency.toUpperCase())
    if (!formatter) {
        throw new Error('Moneda no soportada')
    }
    return formatter(amount)
}

class Order {
    constructor(
        private customerName: string,
        private customerEmail: string,
        private address: string,
        private totalAmount: number,
        private currency: string,
    ) {
    }

    sendInvoice() {
        if (!this.customerEmail.includes('@')) {
            throw new Error('Email inválido')
        }
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${this.customerEmail} por ${this.totalAmount} ${this.currency}`)
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
    }

    sendInvoice() {
        if (!this.customerEmail.includes('@')) {
            throw new Error('Email inválido')
        }
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${this.customerEmail} por ${this.totalAmount} ${this.currency}`)
    }
}

class Email {
    private readonly email: string;

    constructor(email: string) {
        if (!email.includes('@')) {
            throw new Error('Email inválido')
        }
        this.email = email;
    }

    toString() {
        return this.email;
    }
}

class Email {
    private readonly email: string;

    private constructor(email: string) {

        this.email = email;
    }

    static valid(email: string): Email {
        if (!email.includes('@')) {
            throw new Error('Email inválido')
        }

        return new Email(email);
    }

    toString() {
        return this.email;
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
    }

    sendInvoice() {
        const email = Email.valid(this.customerEmail);
        if (!this.customerEmail.includes('@')) {
            throw new Error('Email inválido')
        }
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${this.customerEmail} por ${this.totalAmount} ${this.currency}`)
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
    }

    sendInvoice() {
        const email = Email.valid(this.customerEmail);
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${this.customerEmail} por ${this.totalAmount} ${this.currency}`)
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
    }

    sendInvoice() {
        const email = Email.valid(this.customerEmail);
        if (this.totalAmount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }
        console.log(`Factura enviada a ${email.toString()} por ${this.totalAmount} ${this.currency}`)
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;
    private email: Email;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
        this.email = Email.valid(customerEmail);
    }

    sendInvoice() {
        // Code removed for clarity
    }
}

class Amount {
    private readonly amount: number;

    private constructor(amount: number) {
        this.amount = amount;
    }

    static valid(amount: number): Amount {
        if (amount <= 0) {
            throw new Error('El monto debe ser mayor que cero')
        }

        return new Amount(amount);
    }

    format(currency: Currency) {
        return currency.format(this.amount)
    }
}

class Currency {
    private readonly currency: string

    private constructor(currency: string) {
        this.currency = currency;
    }

    static valid(currency: string): Currency {
        if (!['USD', 'EUR', 'GBP'].includes(currency)) {
            throw new Error('Currency not supported')
        }
        if (currency.length !== 3) {
            throw new Error('Currency must be 3 characters long')
        }
        return new Currency(currency.toUpperCase());
    }

    format(amount: number): string {
        return `${amount} ${this.currency}`
    }
}

class InvoiceAmount {
    private readonly amount: Amount;
    private readonly currency: Currency;

    private constructor(amount: Amount, currency: Currency) {
        this.amount = amount
        this.currency = currency
    }

    static valid(amount: number, currency: string): InvoiceAmount {
        return new InvoiceAmount(Amount.valid(amount), Currency.valid(currency))
    }

    toString(): string {
        return this.amount.format(this.currency)
    }
}

class Order {
    private customerName: string;
    private customerEmail: string;
    private address: string;
    private totalAmount: number;
    private currency: string;
    private email: Email;

    constructor(
        customerName: string,
        customerEmail: string,
        address: string,
        totalAmount: number,
        currency: string,
    ) {
        this.currency = currency;
        this.totalAmount = totalAmount;
        this.address = address;
        this.customerEmail = customerEmail;
        this.customerName = customerName;
        this.email = Email.valid(customerEmail);
    }

    sendInvoice() {
        const email = Email.valid(this.customerEmail);
        const invoiceAmount = InvoiceAmount.valid(this.totalAmount, this.currency);

        console.log(`Factura enviada a ${email.toString()} por ${invoiceAmount.toString()}`)
    }
}

abstract class Currency {
    static valid(currency: string): Currency {
        if (currency === 'EUR') {
            return new Euro()
        }
        if (currency === 'GBP') {
            return new Gbp()
        }
        if (currency === 'USD') {
            return new Usd()
        }
        throw new Error('Currency not supported')
    }

    abstract format(amount: number): string
}

class Euro extends Currency {
    format(amount: number): string {
        return `${amount} €`
    }
}

class Gbp extends Currency {
    format(amount: number): string {
        return `£${amount}`
    }
}

class Usd extends Currency {
    format(amount: number): string {
        return `$${amount}`
    }
}

abstract class Currency {
    static valid(currency: string): Currency {
        // Registry of supported currencies using a map for easy extensibility
        const registry = new Map<string, () => Currency>([
            ['EUR', () => new Euro()],
            ['GBP', () => new Gbp()],
            ['USD', () => new Usd()],
        ])

        const factory = registry.get(currency)
        if (!factory) {
            throw new Error('Currency not supported')
        }
        return factory()
    }

    abstract format(amount: number): string
}

class Euro extends Currency {
    format(amount: number): string {
        return `${amount} €`
    }
}

class Gbp extends Currency {
    format(amount: number): string {
        return `£${amount}`
    }
}

class Usd extends Currency {
    format(amount: number): string {
        return `$${amount}`
    }
}

class Address {
    private readonly street: string;
    private readonly city: string;
    private readonly zip: string;
    private readonly country: string;

    private constructor(street: string, city: string, zip: string, country: string) {
        this.street = street;
        this.city = city;
        this.zip = zip;
        this.country = country;
    }

    static parse(address: string): Address {
        const parts = address.split(', ');
        if (parts.length !== 4) {
            throw new Error('Invalid address format. Expected: street, city, zip, country');
        }
        const [street, city, zip, country] = parts;
        if (!street || !city || !zip || !country) {
            throw new Error('All address components are required');
        }
        return new Address(street, city, zip, country);
    }
}

class CustomerName {
    private readonly name: string
    private constructor(name: string) {
        this.name = name;
    }
    static valid(name: string): CustomerName {
        if (!name) {
            throw new Error('Customer name cannot be empty')
        }
        return new CustomerName(name)
    }
}

class ReportGenerator {
  generateReport(
    title: string,
    startDate: Date,
    endDate: Date,
    includeCharts: boolean,
    includeSummary: boolean,
    authorName: string,
    authorEmail: string,
  ) {
    console.log(`Generando reporte: ${title}`)
    console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
    console.log(`Autor: ${authorName} (${authorEmail})`)
    if (includeCharts) console.log('Incluyendo gráficos...')
    if (includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
  }
}

export function demoLongParameterList(): void {
  const gen = new ReportGenerator()
  gen.generateReport(
    'Ventas Q1',
    new Date('2025-01-01'),
    new Date('2025-03-31'),
    true,
    false,
    'Pat Smith',
    'pat@example.com',
  )
}

class ReportGenerator {
  generateReport(
    title: string,
    startDate: Date,
    endDate: Date,
    includeCharts: boolean,
    includeSummary: boolean,
    authorName: string,
    authorEmail: string,
    locale: string,
    pageSize: string
  )
}

export class ReportGenerator {
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
        locale: string = 'es-ES',
        pageSize: string = 'A4',
    ) {
        console.log(`Generando reporte: ${title}`)
        console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
        console.log(`Autor: ${authorName} (${authorEmail})`)
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

import {describe, expect, it, vi} from "vitest";
import {ReportGenerator} from "./long-parameter-list";

function formatConsoleCalls(spy: ReturnType<typeof vi.spyOn>) {
  return spy.mock.calls.map((call) => call.join(' ')).join('\n')
}

describe('Long Parameter List', () => {
  it('Generates a report', () => {
    const logSpy = vi.spyOn(console, 'log')

    const gen = new ReportGenerator()
      gen.generateReport(
        'Ventas Q1',
        new Date('2025-01-01'),
        new Date('2025-03-31'),
        true,
        false,
        'Pat Smith',
        'pat@example.com',
      )

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
  })
})

export interface GenerateReport {
    title: string
    startDate: Date
    endDate: Date
    includeCharts: boolean
    includeSummary: boolean
    authorName: string
    authorEmail: string
}

const generateReport = {
    title: 'Ventas Q1',
    startDate: new Date('2025-01-01'),
    endDate: new Date('2025-03-31'),
    includeCharts: true,
    includeSummary: false,
    authorName: 'Pat Smith',
    authorEmail: 'pat@example.com'
} as GenerateReport

class ReportGenerator {
  generateReport(
    title: string,
    startDate: Date,
    endDate: Date,
    includeCharts: boolean,
    includeSummary: boolean,
    authorName: string,
    authorEmail: string,
  ) {
    console.log(`Generando reporte: ${title}`)
    console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
    console.log(`Autor: ${authorName} (${authorEmail})`)
    if (includeCharts) console.log('Incluyendo gráficos...')
    if (includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
  }
}

export class DateRange {
  private startDate: Date
  private endDate: Date

  constructor(
    startDate: Date,
    endDate: Date,
  ) {
    this.endDate = endDate;
    this.startDate = startDate;
  }
}

export class Author {
  private name: string;
  private email: string
  
  constructor(name: string, email: string) {
    this.name = name;
    this.email = email;
  }
}

export class ReportGenerator {
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        console.log(`Generando reporte: ${title}`)
        console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
        console.log(`Autor: ${authorName} (${authorEmail})`)
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }

    generate(title: string,  range: DateRange, author: Author, includeCharts: boolean, includeSummary: boolean) {
        // no-op
    }
}

describe('Long Parameter List', () => {
    it('Generates a report', () => {
        const logSpy = vi.spyOn(console, 'log')

        const gen = new ReportGenerator()
        gen.generateReport(
            'Ventas Q1',
            new Date('2025-01-01'),
            new Date('2025-03-31'),
            true,
            false,
            'Pat Smith',
            'pat@example.com',
        )

        let output = formatConsoleCalls(logSpy)
        expect(output).toMatchSnapshot()
    })

    it('Generates a report with Value Objects', () => {
        const logSpy = vi.spyOn(console, 'log')

        const range = new DateRange(
            new Date('2025-01-01'),
            new Date('2025-03-31')
        )

        const author = new Author(
            'Pat Smith',
            'pat@example.com',
        )

        const gen = new ReportGenerator()
        gen.generate(
            'Ventas Q1',
            range,
            author,
            true,
            false,
        )

        let output = formatConsoleCalls(logSpy)
        expect(output).toMatchSnapshot()
    })
})

export class ReportGenerator {
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        console.log(`Generando reporte: ${title}`)
        console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
        console.log(`Autor: ${authorName} (${authorEmail})`)
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }

    generate(title: string,  range: DateRange, author: Author, includeCharts: boolean, includeSummary: boolean) { {
        console.log(`Generando reporte: ${title}`)
        console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
        console.log(`Autor: ${authorName} (${authorEmail})`)
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export class DateRange {
    private startDate: Date
    private endDate: Date

    constructor(
        startDate: Date,
        endDate: Date,
    ) {
        this.startDate = startDate;
        this.endDate = endDate;
    }

    print(template: string): string {
        return template
            .replace('', this.startDate.toDateString())
            .replace('', this.endDate.toDateString());
    }
}

export class Author {
    private name: string;
    private email: string

    constructor(name: string, email: string) {
        this.name = name;
        this.email = email;
    }

    print(template: string): string {
        return template
            .replace('', this.name)
            .replace('', this.email);
    }
}

export class ReportGenerator {
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        console.log(`Generando reporte: ${title}`)
        console.log(`Desde ${startDate.toDateString()} hasta ${endDate.toDateString()}`)
        console.log(`Autor: ${authorName} (${authorEmail})`)
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }

    generate(title: string,  range: DateRange, author: Author, includeCharts: boolean, includeSummary: boolean) {
        console.log(`Generando reporte: ${title}`)
        console.log(range.print(`Desde  hasta `))
        console.log(author.print(`Autor:  ()`))
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export class ReportGenerator {
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        const range = new DateRange(startDate, endDate)
        const author = new Author(authorName, authorEmail)
        return this.generate(title, range, author, includeCharts, includeSummary)
    }

    generate(title: string,  range: DateRange, author: Author, includeCharts: boolean, includeSummary: boolean) {
        console.log(`Generando reporte: ${title}`)
        console.log(range.print(`Desde  hasta `))
        console.log(author.print(`Autor:  ()`))
        if (includeCharts) console.log('Incluyendo gráficos...')
        if (includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export class ReportGenerator {
    private includeCharts: boolean;
    private includeSummary: boolean;

    constructor(includeCharts: boolean = true, includeSummary: boolean = false) {
        this.includeCharts = includeCharts;
        this.includeSummary = includeSummary;
    }

    // Code removed for clarity
}

export class ReportGenerator {
    private includeCharts: boolean;
    private includeSummary: boolean;

    constructor(includeCharts: boolean = true, includeSummary: boolean = false) {
        this.includeCharts = includeCharts;
        this.includeSummary = includeSummary;
    }
    
    // Code removed for clarity
}

export class ReportGenerator {
    private includeCharts: boolean;
    private includeSummary: boolean;

    constructor(includeCharts: boolean = true, includeSummary: boolean = false) {
        this.includeCharts = includeCharts;
        this.includeSummary = includeSummary;
    }

    /** @deprecated Use ReportGenerator.generate instead */
    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        const range = new DateRange(startDate, endDate)
        const author = new Author(authorName, authorEmail)
        this.includeCharts = includeCharts
        this.includeSummary = includeSummary
        return this.generate(title, range, author)
    }

    generate(title: string, range: DateRange, author: Author) {
        console.log(`Generando reporte: ${title}`)
        console.log(range.print(`Desde  hasta `))
        console.log(author.print(`Autor:  ()`))
        if (this.includeCharts) console.log('Incluyendo gráficos...')
        if (this.includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export class ReportGeneratorBuilder {
    private includeCharts: boolean = false
    private includeSummary: boolean = false

    withCharts(): ReportGeneratorBuilder {
        this.includeCharts = true;
        return this;
    }

    withSummary(): ReportGeneratorBuilder {
        this.includeSummary = true;
        return this;
    }

    build(): ReportGenerator {
        return new ReportGenerator(this.includeCharts, this.includeSummary);
    }
}

it('Generates a report with Value Objects', () => {
    const logSpy = vi.spyOn(console, 'log')

    const range = new DateRange(
        new Date('2025-01-01'),
        new Date('2025-03-31')
    )

    const author = new Author(
        'Pat Smith',
        'pat@example.com',
    )

    const builder = new ReportGeneratorBuilder()
    const gen = builder
        .withCharts()
        .build()

    gen.generate(
        'Ventas Q1',
        range,
        author,
    )

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
})

export class ReportGeneratorBuilder {
    private includeCharts: boolean = false
    private includeSummary: boolean = false

    withCharts(): ReportGeneratorBuilder {
        this.includeCharts = true
        return this
    }

    withoutCharts(): ReportGeneratorBuilder {
        this.includeCharts = false
        return this
    }

    withSummary(): ReportGeneratorBuilder {
        this.includeSummary = true
        return this
    }

    withoutSummary(): ReportGeneratorBuilder {
        this.includeSummary = false
        return this
    }

    build(): ReportGenerator {
        return new ReportGenerator(this.includeCharts, this.includeSummary)
    }
}

interface ReportConfiguration {
    includeCharts: boolean
    includeSummary: boolean
}

export class ReportGenerator {
    private configuration: ReportConfiguration

    constructor(configuration: ReportConfiguration = {includeCharts: false, includeSummary: false}) {
        this.configuration = configuration
    }

    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        const range = new DateRange(startDate, endDate)
        const author = new Author(authorName, authorEmail)
        this.configuration = {
            includeCharts: includeCharts,
            includeSummary: includeSummary,
        }
        return this.generate(title, range, author)
    }

    generate(title: string, range: DateRange, author: Author) {
        console.log(`Generando reporte: ${title}`)
        console.log(range.print(`Desde  hasta `))
        console.log(author.print(`Autor:  ()`))
        if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
        if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export class ReportGeneratorBuilder {
    private includeCharts: boolean = false
    private includeSummary: boolean = false

    withCharts(): ReportGeneratorBuilder {
        this.includeCharts = true
        return this
    }

    withoutCharts(): ReportGeneratorBuilder {
        this.includeCharts = false
        return this
    }

    withSummary(): ReportGeneratorBuilder {
        this.includeSummary = true
        return this
    }

    withoutSummary(): ReportGeneratorBuilder {
        this.includeSummary = false
        return this
    }

    build(): ReportGenerator {
        const configuration = {
            includeCharts: this.includeCharts,
            includeSummary: this.includeSummary,
        }
        return new ReportGenerator(configuration)
    }
}

it('Generates a report with Value Objects', () => {
    const logSpy = vi.spyOn(console, 'log')

    const range = new DateRange(new Date('2025-01-01'), new Date('2025-03-31'))

    const author = new Author('Pat Smith', 'pat@example.com')

    const builder = new ReportGeneratorBuilder()
    const gen = builder.withCharts().build()

    gen.generate('Ventas Q1', range, author)

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
})

interface ReportConfiguration {
    includeCharts: boolean
    includeSummary: boolean
    pageSize: string
}

export class ReportGeneratorBuilder {
    private includeCharts: boolean = false
    private includeSummary: boolean = false
    private pageSize?: string

    withCharts(): ReportGeneratorBuilder {
        this.includeCharts = true
        return this
    }

    withoutCharts(): ReportGeneratorBuilder {
        this.includeCharts = false
        return this
    }

    withSummary(): ReportGeneratorBuilder {
        this.includeSummary = true
        return this
    }

    withoutSummary(): ReportGeneratorBuilder {
        this.includeSummary = false
        return this
    }

    withPageSize(pageSize: string): ReportGeneratorBuilder {
        this.pageSize = pageSize
        return this
    }

    build(): ReportGenerator {
        if (!this.pageSize) {
            throw new Error('PageSize is required. Use withPageSize(\'A4\').')
        }
        const configuration = {
            includeCharts: this.includeCharts,
            includeSummary: this.includeSummary,
            pageSize: this.pageSize
        }
        return new ReportGenerator(configuration)
    }
}

export class ReportGenerator {
    private configuration: ReportConfiguration

    constructor(configuration: ReportConfiguration = {includeCharts: false, includeSummary: false, pageSize: 'A4'}) {
        this.configuration = configuration
    }

    // Code removed for clarity

    generate(title: string, range: DateRange, author: Author) {
        if (this.configuration.pageSize !== 'A4') {
            console.log(`Ajustando página a ${this.configuration.pageSize}...`)
        }
        console.log(`Generando reporte: ${title}`);
        console.log(range.print(`Desde  hasta `))
        console.log(author.print(`Autor:  ()`))
        if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
        if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

  it('Generates a report with custom page Size', () => {
    const logSpy = vi.spyOn(console, 'log')

    const range = new DateRange(new Date('2025-01-01'), new Date('2025-03-31'))
    const author = new Author('Pat Smith', 'pat@example.com')
    const builder = new ReportGeneratorBuilder()
    const gen = builder.withCharts().withPageSize('A5').build()

    gen.generate('Ventas Q1', range, author)

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
  })

export interface ReportContent {
    title: string
    range: DateRange
    author: Author
}

generate(title: string, range: DateRange, author: Author, content?: ReportContent) {
    if (this.configuration.pageSize !== 'A4') {
        console.log(`Ajustando página a ${this.configuration.pageSize}...`)
    }
    console.log(`Generando reporte: ${title}`);
    console.log(range.print(`Desde  hasta `))
    console.log(author.print(`Autor:  ()`))
    if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
    if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
}

generate(title: string, range: DateRange, author: Author, content?: ReportContent) {
    if (this.configuration.pageSize !== 'A4') {
        console.log(`Ajustando página a ${this.configuration.pageSize}...`)
    }
    console.log(`Generando reporte: ${content?.title ?? title}`);
    console.log(range.print(`Desde  hasta `))
    console.log(author.print(`Autor:  ()`))
    if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
    if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
}

generate(title: string, range: DateRange, author: Author, content?: ReportContent) {
    if (!content) {
        content = {
            title: title,
            range: range,
            author: author
        }
    }
    if (this.configuration.pageSize !== 'A4') {
        console.log(`Ajustando página a ${this.configuration.pageSize}...`);
    }
    console.log(`Generando reporte: ${content.title}`);
    console.log(content.range.print(`Desde  hasta `))
    console.log(content.author.print(`Autor:  ()`))
    if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
    if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
}

it('Generates a report using ReportContent object', () => {
    const logSpy = vi.spyOn(console, 'log')

    const range = new DateRange(new Date('2025-01-01'), new Date('2025-03-31'))
    const author = new Author('Pat Smith', 'pat@example.com')
    const builder = new ReportGeneratorBuilder()
    const content = {
        title: 'Updated Report',
        author: new Author('Jane Doe', 'jane@example.com'),
        range: new DateRange(new Date('2025-04-01'), new Date('2025-06-31')),
    }
    const gen = builder.withCharts().withPageSize('A5').build()

    gen.generate('Ventas Q1', range, author, content)

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
})

generate(title: string, range: DateRange, author: Author, content?: ReportContent) {
    if (!content) {
        content = {
            title: title,
            range: range,
            author: author
        }
    }
    this.generateWithContent(content);
}

generateWithContent(content: ReportContent) {
    if (this.configuration.pageSize !== 'A4') {
        console.log(`Ajustando página a ${this.configuration.pageSize}...`);
    }
    console.log(`Generando reporte: ${content.title}`);
    console.log(content.range.print(`Desde  hasta `))
    console.log(content.author.print(`Autor:  ()`))
    if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
    if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
    console.log('Reporte generado exitosamente.')
}

it('Generates a report using ReportContent object', () => {
    const logSpy = vi.spyOn(console, 'log')

    const builder = new ReportGeneratorBuilder()
    const content = {
        title: 'Updated Report',
        author: new Author('Jane Doe', 'jane@example.com'),
        range: new DateRange(new Date('2025-04-01'), new Date('2025-06-31')),
    }
    const gen = builder.withCharts().withPageSize('A5').build()

    gen.generateWithContent(content)

    let output = formatConsoleCalls(logSpy)
    expect(output).toMatchSnapshot()
})

export class ReportGenerator {
    private configuration: ReportConfiguration

    constructor(configuration: ReportConfiguration = {includeCharts: false, includeSummary: false, pageSize: 'A4'}) {
        this.configuration = configuration
    }

    generateReport(
        title: string,
        startDate: Date,
        endDate: Date,
        includeCharts: boolean,
        includeSummary: boolean,
        authorName: string,
        authorEmail: string,
    ) {
        const range = new DateRange(startDate, endDate)
        const author = new Author(authorName, authorEmail)
        this.configuration = {
            includeCharts: includeCharts,
            includeSummary: includeSummary,
            pageSize: this.configuration.pageSize,
        }
        return this.generate(title, range, author)
    }

    generate(title: string, range: DateRange, author: Author, content?: ReportContent) {
        if (!content) {
            content = {
                title: title,
                range: range,
                author: author
            }
        }
        this.generateWithContent(content);
    }

    generateWithContent(content: ReportContent) {
        if (this.configuration.pageSize !== 'A4') {
            console.log(`Ajustando página a ${this.configuration.pageSize}...`);
        }
        console.log(`Generando reporte: ${content.title}`);
        console.log(content.range.print(`Desde  hasta `))
        console.log(content.author.print(`Autor:  ()`))
        if (this.configuration.includeCharts) console.log('Incluyendo gráficos...')
        if (this.configuration.includeSummary) console.log('Incluyendo resumen...')
        console.log('Reporte generado exitosamente.')
    }
}

export interface ReportContent {
    title: string
    range: DateRange
    author: Author
    locale?: string
}

class OrderService {
    process(order: Order) {
        // Validar el pedido
        if (!order.items || order.items.length === 0) {
            console.log('El pedido no tiene productos')
            return
        }

        // Validar precios y cantidades
        for (const item of order.items) {
            if (item.price < 0 || item.quantity <= 0) {
                console.log('Producto inválido en el pedido')
                return
            }
        }

        // Constantes de negocio (simples por ahora)
        const TAX_RATE = 0.21 // 21% IVA
        const FREE_SHIPPING_THRESHOLD = 50
        const SHIPPING_FLAT = 5

        // Calcular subtotal
        let subtotal = 0
        for (const item of order.items) {
            subtotal += item.price * item.quantity
        }

        // Descuento por cliente VIP (10% del subtotal)
        let discount = 0
        if (order.customerType === 'VIP') {
            discount = roundMoney(subtotal * 0.1)
            console.log('Descuento VIP aplicado')
        }

        // Base imponible
        const taxable = Math.max(0, subtotal - discount)

        // Impuestos
        const tax = roundMoney(taxable * TAX_RATE)

        // Envío
        const shipping = taxable >= FREE_SHIPPING_THRESHOLD ? 0 : SHIPPING_FLAT

        // Total
        const total = roundMoney(taxable + tax + shipping)

        // Actualizar el pedido (side-effects requeridos)
        order.subtotal = roundMoney(subtotal)
        order.discount = discount
        order.tax = tax
        order.shipping = shipping
        order.total = total

        // Registrar en la base de datos (simulado)
        // Bloque gigantesco y sobrecargado para simular persistencia con múltiples pasos innecesarios
        const dbConnectionString = 'Server=fake.db.local;Database=orders;User=demo;Password=demo'
        const dbConnected = true // pretendemos que ya está conectado
        const dbRetriesMax = 3
        let dbRetries = 0
        const dbNow = new Date()
        const dbRecordId = Math.floor(Math.random() * 1000000)

        // Preparar registro a guardar
        const dbRecord = {
            id: dbRecordId,
            customerEmail: order.customerEmail,
            customerType: order.customerType,
            items: order.items.map(i => ({name: i.name, price: i.price, quantity: i.quantity})),
            amounts: {
                subtotal: order.subtotal,
                discount: order.discount,
                tax: order.tax,
                shipping: order.shipping,
                total: order.total,
            },
            status: 'PENDING',
            createdAt: dbNow.toISOString(),
            updatedAt: dbNow.toISOString(),
            currency: 'USD',
        }

        // Validaciones redundantes antes de guardar
        const hasItems = Array.isArray(dbRecord.items) && dbRecord.items.length > 0
        const totalsConsistent = typeof dbRecord.amounts.total === 'number' && dbRecord.amounts.total >= 0
        if (!hasItems) {
            console.warn('[DB] No se puede guardar: el pedido no tiene items')
        }
        if (!totalsConsistent) {
            console.warn('[DB] No se puede guardar: total inconsistente')
        }

        // Simular transformación/serialización pesada
        const serialized = JSON.stringify(dbRecord, null, 2)
        const payloadBytes = Buffer.byteLength(serialized, 'utf8')
        console.log(`[DB] Serializando registro ${dbRecord.id} (${payloadBytes} bytes) para ${dbConnectionString}`)

        // Simular reintentos de escritura
        let dbSaved = false
        while (!dbSaved && dbRetries < dbRetriesMax) {
            dbRetries++
            if (!dbConnected) {
                console.log(`[DB] Intento ${dbRetries}/${dbRetriesMax}: reconectando a la base de datos...`)
            } else {
                console.log(`[DB] Intento ${dbRetries}/${dbRetriesMax}: guardando pedido ${dbRecord.id} con total ${formatMoney(total)}`)
            }
            // Resultado aleatorio simulado, pero aquí siempre "exitoso" para no complicar flujos de prueba
            dbSaved = true
        }

        if (dbSaved) {
            console.log(`[DB] Pedido ${dbRecord.id} guardado correctamente`)
        } else {
            console.error(`[DB] No se pudo guardar el pedido ${dbRecord.id} tras ${dbRetriesMax} intentos`)
        }

        // Auditoría/bitácora adicional innecesaria
        const auditLogEntry = {
            type: 'ORDER_SAVED',
            orderId: dbRecord.id,
            actor: 'system',
            at: new Date().toISOString(),
            metadata: {
                ip: '127.0.0.1',
                userAgent: 'OrderService/1.0',
            }
        }
        console.log('[AUDIT] Registro:', JSON.stringify(auditLogEntry))

        // Enviar correo de confirmación
        // Bloque gigantesco para simular el envío de un correo con plantillas, adjuntos, y seguimiento
        const smtpConfig = {
            host: 'smtp.fake.local',
            port: 587,
            secure: false,
            auth: {user: 'notifier', pass: 'notifier'},
            tls: {rejectUnauthorized: false}
        }
        const emailTemplate = `
      Hola,
      Gracias por tu pedido. Aquí tienes el resumen:\n
      Subtotal: ${formatMoney(order.subtotal)}\n
      Descuento: ${order.discount && order.discount > 0 ? '-' + formatMoney(order.discount) : formatMoney(0)}\n
      Impuestos: ${formatMoney(order.tax)}\n
      Envío: ${formatMoney(order.shipping)}\n
      Total: ${formatMoney(order.total)}\n

      Nº de pedido: ${dbRecord.id}\n
      Fecha: ${new Date().toLocaleString()}\n

      Saludos,
      Equipo Demo
    `
        const trackingPixelUrl = `https://tracker.fake.local/pixel?orderId=${dbRecord.id}&t=${Date.now()}`
        const emailBodyHtml = `
      <html>
        <body>
          <p>Hola,</p>
          <p>Gracias por tu pedido. Aquí tienes el resumen:</p>
          <ul>
            <li>Subtotal: <strong>${formatMoney(order.subtotal)}</strong></li>
            <li>Descuento: <strong>${order.discount && order.discount > 0 ? '-' + formatMoney(order.discount) : formatMoney(0)}</strong></li>
            <li>Impuestos: <strong>${formatMoney(order.tax)}</strong></li>
            <li>Envío: <strong>${formatMoney(order.shipping)}</strong></li>
            <li>Total: <strong>${formatMoney(order.total)}</strong></li>
          </ul>
          <p>Nº de pedido: <code>${dbRecord.id}</code></p>
          <p>Fecha: ${new Date().toLocaleString()}</p>
          <img src="${trackingPixelUrl}" width="1" height="1" alt=""/>
        </body>
      </html>
    `

        const attachments = [
            {filename: `pedido-${dbRecord.id}.json`, content: serialized, contentType: 'application/json'},
            {filename: 'terminos.txt', content: 'Términos y condiciones...', contentType: 'text/plain'}
        ]

        // Simular cálculo de tamaño del correo
        const emailSize = Buffer.byteLength(emailBodyHtml, 'utf8') + attachments.reduce((acc, a) => acc + Buffer.byteLength(a.content, 'utf8'), 0)
        console.log(`[MAIL] Preparando correo (${emailSize} bytes) vía ${smtpConfig.host}:${smtpConfig.port}`)

        // Simular colas de envío y priorización
        const emailPriority = order.customerType === 'VIP' ? 'HIGH' : 'NORMAL'
        console.log(`[MAIL] Encolando correo (${emailPriority}) para ${order.customerEmail}`)

        // Simular envío con reintentos
        let mailAttempts = 0
        const mailAttemptsMax = 2
        let mailSent = false
        while (!mailSent && mailAttempts < mailAttemptsMax) {
            mailAttempts++
            console.log(`[MAIL] Intento ${mailAttempts}/${mailAttemptsMax}: enviando correo a ${order.customerEmail}`)
            // Simulación simple de éxito
            mailSent = true
        }

        const messageId = `msg-${dbRecord.id}-${Date.now()}`
        if (mailSent) {
            console.log(`[MAIL] Correo enviado a ${order.customerEmail} (messageId=${messageId})`)
        } else {
            console.error(`[MAIL] Fallo al enviar correo a ${order.customerEmail} tras ${mailAttemptsMax} intentos`)
        }

        // Imprimir resumen -> enviar a impresora
        const printJob: PrintJob = {
            title: 'Resumen del pedido',
            items: order.items.map(i => ({
                name: i.name,
                quantity: i.quantity,
                lineTotal: roundMoney(i.price * i.quantity),
                lineTotalFormatted: formatMoney(i.price * i.quantity),
            })),
            subtotal: order.subtotal ?? 0,
            discount: order.discount ?? 0,
            tax: order.tax ?? 0,
            shipping: order.shipping ?? 0,
            total: order.total ?? 0,
            currency: 'USD',
            formatted: {
                subtotal: formatMoney(order.subtotal),
                discount: order.discount && order.discount > 0 ? `-${formatMoney(order.discount)}` : formatMoney(0),
                tax: formatMoney(order.tax),
                shipping: formatMoney(order.shipping),
                total: formatMoney(order.total),
            },
            metadata: {
                customerEmail: order.customerEmail,
                createdAt: new Date().toISOString(),
            }
        }

        // Simulación de envío a impresora: bloque deliberadamente grande y sobrecargado
        // Configuración de impresora (ficticia)
        const printerConfig = {
            name: 'Demo Thermal Printer TP-80',
            model: 'TP-80',
            dpi: 203,
            widthMm: 80,
            maxCharsPerLine: 42, // típico en papel de 80mm con fuente estándar
            interface: 'USB',
            driver: 'ESC/POS',
            location: 'Front Desk',
        }

        // Capabilities detectadas (simuladas)
        const printerCaps = {
            supportsBold: true,
            supportsUnderline: true,
            supportsQr: true,
            supportsBarcode: true,
            supportsImages: false,
            codepage: 'cp437'
        }

        // Conexión (simulada)
        const printerConn = {connected: true, retries: 0, maxRetries: 2}
        console.log(`[PRN] Preparando conexión a impresora ${printerConfig.name} (${printerConfig.interface}/${printerConfig.driver})`)

        // Crear contenido del recibo
        const now = new Date()
        const lineWidth = printerConfig.maxCharsPerLine

        const padRight = (text: string, len: number) => text.length >= len ? text.slice(0, len) : text + ' '.repeat(len - text.length)
        const padLeft = (text: string, len: number) => text.length >= len ? text.slice(0, len) : ' '.repeat(len - text.length) + text
        const repeat = (ch: string, n: number) => new Array(n + 1).join(ch)

        const formatLine = (left: string, right: string) => {
            const leftTrim = left ?? ''
            const rightTrim = right ?? ''
            const space = Math.max(1, lineWidth - leftTrim.length - rightTrim.length)
            const spaces = repeat(' ', space)
            const tooLong = leftTrim.length + rightTrim.length > lineWidth
            if (tooLong) {
                // Si no cabe, forzamos salto para la izquierda y mantenemos derecha alineada
                return leftTrim + '\n' + padLeft(rightTrim, lineWidth)
            }
            return leftTrim + spaces + rightTrim
        }

        // Cabecera
        const receiptLines: string[] = []
        receiptLines.push(repeat('=', lineWidth))
        receiptLines.push(padRight('RESUMEN DEL PEDIDO', lineWidth))
        receiptLines.push(padRight(now.toLocaleString(), lineWidth))
        receiptLines.push(padRight(`Cliente: ${order.customerEmail}`, lineWidth))
        receiptLines.push(repeat('-', lineWidth))

        // Items
        for (const it of printJob.items) {
            const left = `${it.quantity} x ${it.name}`
            const right = it.lineTotalFormatted
            receiptLines.push(formatLine(left, right))
        }

        // Totales
        receiptLines.push(repeat('-', lineWidth))
        receiptLines.push(formatLine('Subtotal', printJob.formatted.subtotal))
        if ((printJob.discount ?? 0) > 0) {
            receiptLines.push(formatLine('Descuento', `-${formatMoney(printJob.discount)}`))
        } else {
            receiptLines.push(formatLine('Descuento', printJob.formatted.discount))
        }
        receiptLines.push(formatLine('Impuestos', printJob.formatted.tax))
        receiptLines.push(formatLine('Envío', printJob.formatted.shipping))
        receiptLines.push(formatLine('TOTAL', printJob.formatted.total))
        receiptLines.push(repeat('=', lineWidth))

        // Pie con metadatos
        receiptLines.push(padRight(`Nº pedido: ${Math.abs((order.total ?? 0) * 1000) | 0}`, lineWidth))
        receiptLines.push(padRight(`Moneda: ${printJob.currency}`, lineWidth))
        receiptLines.push(padRight(`Creado: ${printJob.metadata.createdAt}`, lineWidth))

        // Comandos ESC/POS simulados (no operativos, solo logging)
        const escposCommands = [
            '[INIT]',
            '[ALIGN LEFT]',
            '[FONT A]',
            printerCaps.supportsBold ? '[BOLD ON]' : '[BOLD N/A]',
            '[PRINT LINES]',
            '[BOLD OFF]',
            '[CUT PARTIAL]'
        ]

        // Montar payload a imprimir
        const textPayload = receiptLines.join('\n') + '\n' + repeat('-', lineWidth) + '\n'
        const commandSection = escposCommands.join(' ')
        const printable = `\n${commandSection}\n${textPayload}`
        const spoolBuffer = Buffer.from(printable, 'utf8')
        const spoolBytes = Buffer.byteLength(printable, 'utf8')

        // Simulación de QR/barcode en el ticket (solo registro)
        const qrData = `ORDER|${order.customerEmail}|${printJob.total}|${now.getTime()}`
        if (printerCaps.supportsQr) {
            console.log(`[PRN] Agregando QR con datos: ${qrData}`)
        } else if (printerCaps.supportsBarcode) {
            console.log(`[PRN] Agregando BARCODE con datos: ${qrData.slice(0, 12)}`)
        } else {
            console.log('[PRN] Sin soporte para QR/BARCODE')
        }

        // Vista previa ASCII (limitada para no saturar logs)
        const preview = textPayload.split('\n').slice(0, 12).join('\n')
        console.log('[PRN] Vista previa del recibo:\n' + preview + (receiptLines.length > 12 ? `\n...(${receiptLines.length - 12} líneas más)` : ''))

        // Encolado de trabajo de impresión
        const printPriority = order.customerType === 'VIP' ? 'HIGH' : 'NORMAL'
        const printJobId = `prn-${Date.now()}-${Math.floor(Math.random() * 1000)}`
        console.log(`[PRN] Encolando trabajo ${printJobId} (${spoolBytes} bytes, prioridad=${printPriority}) en ${printerConfig.location}`)

        // Envío en trozos (chunking) para simular buffer limitado de la impresora
        const chunkSize = 256 // bytes
        let sentBytes = 0
        let chunkIndex = 0
        let sentOk = true
        while (sentBytes < spoolBytes) {
            const remaining = spoolBytes - sentBytes
            const size = Math.min(chunkSize, remaining)
            const chunk = spoolBuffer.subarray(sentBytes, sentBytes + size)
            // Simular reintentos por chunk
            let attempts = 0
            let delivered = false
            while (!delivered && attempts < 2) {
                attempts++
                console.log(`[PRN] Enviando chunk #${chunkIndex} (${size} bytes) intento ${attempts}/2`)
                // Éxito simulado
                delivered = true
            }
            if (!delivered) {
                console.error(`[PRN] Fallo al enviar chunk #${chunkIndex}`)
                sentOk = false
                break
            }
            sentBytes += size
            chunkIndex++
        }

        // Resultado final de impresión
        if (printerConn.connected && sentOk) {
            console.log(`[PRN] Trabajo ${printJobId} impreso correctamente. Total enviado: ${sentBytes} bytes`)
        } else {
            console.error(`[PRN] Error al imprimir trabajo ${printJobId}. Enviado: ${sentBytes}/${spoolBytes} bytes`)
        }
    }
}

function roundMoney(n: number): number {
    return Math.round(n * 100) / 100
}

function formatMoney(n: number | undefined): string {
    const v = typeof n === 'number' ? n : 0
    return `$${v.toFixed(2)}`
}

interface Order {
    customerEmail: string
    customerType: 'NORMAL' | 'VIP'
    items: { name: string; price: number; quantity: number }[]
    subtotal?: number
    discount?: number
    tax?: number
    shipping?: number
    total?: number
}


interface PrintJob {
    title: string
    items: { name: string; quantity: number; lineTotal: number; lineTotalFormatted: string }[]
    subtotal: number
    discount: number
    tax: number
    shipping: number
    total: number
    currency: string
    formatted: {
        subtotal: string
        discount: string
        tax: string
        shipping: string
        total: string
    }
    metadata: {
        customerEmail: string
        createdAt: string
    }
}