function Customer(data) {
  this.id = data.id;
  this.name = data.name;
  this.lastName = data.lastName;
  this.email = data.email;
  this.phone = data.phone;
  this.addresses = data.addresses || [];
  this.currency = data.currency;
  this.metadata = data.metadata;
  this.createdAt = data.createdAt;
  this.discounts = data.discounts || [];
}

function mapCustomer(providerCustomer) {
  return new Customer({
    id: providerCustomer.id,
    name: providerCustomer.name || `${providerCustomer.firstName || ''} ${providerCustomer.lastName || ''}`.trim(),
    lastName: providerCustomer.lastName,
    email: providerCustomer.email,
    phone: providerCustomer.phone,
    addresses: mapAddresses(providerCustomer.addresses),
    currency: providerCustomer.currency,
    metadata: providerCustomer.metadata,
    createdAt: new Date(providerCustomer.created_at).toISOString(),
    discounts: mapDiscounts(providerCustomer.discounts),
  });
}

function mapAddresses(providerAddresses) {
  if (!providerAddresses) return [];
  return providerAddresses.map(addr => ({
    line1: addr.line1,
    line2: addr.line2,
    city: addr.city,
    state: addr.state,
    postalCode: addr.postal_code,
    country: addr.country,
  }));
}

// Customer-level Coupons

function Coupon(data) {
  this.id = data.id;
  this.name = data.name;
  this.code = data.code;
  this.duration = data.duration;
  this.value = data.value;
  this.redemptions = data.redemptions;
  this.expiresAt = data.expiresAt;
  this.whitelist = data.whitelist;
  this.blacklist = data.blacklist;
}

function mapDiscounts(providerDiscounts) {
  if (!providerDiscounts) return [];
  return providerDiscounts.map(discount => ({
    coupon: new Coupon(discount.coupon),
    start: discount.start ? new Date(discount.start) : undefined,
    end: discount.end ? new Date(discount.end) : undefined,
  }));
}

function Subscription(data) {
  this.id = data.id;
  this.customerId = data.customerId;
  this.status = data.status;
  this.trial = data.trial;
  this.items = data.items || [];
  this.discounts = data.discounts || [];
  this.duration = data.duration;
  this.start = data.start;
  this.metadata = data.metadata;
}

function mapSubscription(providerSubscription) {
  return new Subscription({
    id: providerSubscription.id,
    customerId: providerSubscription.customerId,
    status: mapStatus(providerSubscription.status),
    trial: mapTrial(providerSubscription.trial),
    items: mapItems(providerSubscription.items),
    discounts: mapDiscounts(providerSubscription.discounts),
    duration: mapDuration(providerSubscription.duration),
    start: new Date(providerSubscription.start).toISOString(),
    metadata: providerSubscription.metadata,
  });
}

function mapStatus(providerStatus) {
  const statusMap = {
    future: { name: 'future' },
    trial: {
      name: 'trial',
      currentPeriod: mapPeriod(providerStatus.currentPeriod),
    },
    active: {
      name: 'active',
      currentPeriod: mapPeriod(providerStatus.currentPeriod),
    },
    paused: {
      name: 'paused',
      start: providerStatus.start ? new Date(providerStatus.start).toISOString() : undefined,
      end: providerStatus.end ? new Date(providerStatus.end).toISOString() : undefined,
    },
    canceled: {
      name: 'canceled',
      canceledAt: providerStatus.canceledAt ? new Date(providerStatus.canceledAt).toISOString() : undefined,
    },
    unpaid: {
      name: 'unpaid',
      currentPeriod: mapPeriod(providerStatus.currentPeriod),
    },
    error: {
      name: 'error',
      reason: providerStatus.reason,
    },
  };

  return statusMap[providerStatus.name] || { name: 'unknown' };
}

function mapPeriod(period) {
  if (!period) return undefined;
  return {
    start: new Date(period.start).toISOString(),
    end: new Date(period.end).toISOString(),
  };
}

function mapTrial(trial) {
  return trial ? mapPeriod(trial) : undefined;
}

function mapItems(providerItems) {
  if (!providerItems) return [];
  return providerItems.map(item => ({
    id: item.id,
    price: mapPrice(item.price),
    quantity: item.quantity,
    createdAt: item.createdAt ? new Date(item.createdAt).toISOString() : undefined,
  }));
}

function mapPrice(providerPrice) {
  // Implement price mapping based on your Price model, see the next section.
}

function mapDiscounts(providerDiscounts) {
  // Implement discount mapping based on your specific discount structure
  return providerDiscounts || [];
}

function mapDuration(providerDuration) {
  return {
    amount: providerDuration.amount,
    unit: providerDuration.unit,
  };
}

function mapPrice(providerPrice) {
  return {
    id: providerPrice.id,
    name: providerPrice.name || 'Unnamed Price',
    description: providerPrice.description || undefined,
    currency: providerPrice.currency.toUpperCase(),
    amount: mapAmount(providerPrice.amount),
    duration: mapDuration(providerPrice.duration),
    overrides: mapOverrides(providerPrice.overrides),
  };
}

function mapAmount(providerAmount) {
  if (providerAmount.model === 'fixed') {
    return {
      model: 'fixed',
      currency: providerAmount.currency,
      unit: providerAmount.unit,
      flat: providerAmount.flat || undefined,
    };
  } else if (providerAmount.model === 'tiered') {
    return {
      model: 'tiered',
      currency: providerAmount.currency,
      tiers: providerAmount.tiers.map(mapTier),
      mode: providerAmount.mode || 'total',
    };
  }
}

function mapTier(providerTier) {
  return {
    upTo: providerTier.upTo,
    unit: providerTier.unit,
    flat: providerTier.flat || undefined,
  };
}

function mapDuration(providerDuration) {
  return {
    value: providerDuration.value,
    unit: providerDuration.unit,
  };
}

function mapOverrides(providerOverrides) {
  return {
    currency: providerOverrides.currency || {},
    country: providerOverrides.country || {},
  };
}

function mapProductPrice(providerPrice) {
  const basePrice = mapPrice(providerPrice);
  return {
    ...basePrice,
    productId: providerPrice.productId,
  };
}

function mapFamily(providerFamily) {
  return {
    id: providerFamily.id,
    name: providerFamily.name,
    description: providerFamily.description || undefined,
  };
}

function mapProduct(providerProduct) {
  return {
    id: providerProduct.id,
    familyId: providerProduct.familyId,
    name: providerProduct.name,
    description: providerProduct.description || undefined,
  };
}

function mapFamilyPrice(providerPrice) {
  const productPrice = mapProductPrice(providerPrice);
  return {
    ...productPrice,
    familyId: providerPrice.familyId,
  };
}

// Standalone Price
const rawPrice = await provider.fetchPrice(priceId);
const price = mapPrice(rawPrice);
console.log(`Price: ${price.name} (${price.currency} ${price.amount.unit / 100})`);

// Product Price
const rawProductPrice = await provider.fetchProductPrice(productPriceId);
const productPrice = mapProductPrice(rawProductPrice);
console.log(`Product Price: ${productPrice.name} for Product ${productPrice.productId}`);

// Family Price
const rawFamily = await provider.fetchFamily(familyId);
const family = mapFamily(rawFamily);

const rawProducts = await provider.fetchProductsForFamily(familyId);
const products = rawProducts.map(mapProduct);

const rawPrices = await provider.fetchPricesForProduct(productId);
const prices = rawPrices.map(mapFamilyPrice);

console.log(`Family: ${family.name}`);
products.forEach(product => {
  console.log(`- Product: ${product.name}`);
  const productPrices = prices.filter(price => price.productId === product.id);
  productPrices.forEach(price => {
    console.log(`  - Price: ${price.name} (${price.currency} ${price.amount.unit / 100})`);
  });
});

const coupon = {
  id: 'SUMMERSALE2023',
  code: 'SUMMER20',
  name: 'Summer Sale 20% Off',
  duration: {
    type: 'period',
    amount: 3,
    unit: 'month',
  },
  value: {
    type: 'percent',
    value: 20,
  },
  redemptions: {
    current: 50,
    max: 1000,
  },
  expiresAt: '2023-08-31T23:59:59Z',
  whitelist: {
    productIds: ['PROD001', 'PROD002'],
    productFamilyIds: ['FAM001'],
  },
};