// customer-specific-price-calculation-strategy.ts
import {
CacheService,
Customer,
Injector,
Logger,
PriceCalculationResult,
ProductVariantPriceCalculationArgs,
ProductVariantPriceCalculationStrategy,
RequestContext,
TransactionalConnection
} from "@vendure/core";
import { parse } from "csv-parse/sync";

// The column names coming from the CSV
interface Row {
sku: string;
"Premium restaurant": number;
"Bio winkel": number;
Groothandel: number;
Consument: number;
}

const loggerCtx = "CustomerSpecificPriceCalculationStrategy";

export class CustomerSpecificPriceCalculationStrategy
implements ProductVariantPriceCalculationStrategy
{
private cache: CacheService;
private transactionalConnection: TransactionalConnection;

async init(injector: Injector) {
  this.cache = injector.get(CacheService);
  this.transactionalConnection = injector.get(TransactionalConnection);
}

async calculate({
  ctx,
  productVariant,
}: ProductVariantPriceCalculationArgs): Promise<PriceCalculationResult> {
  // Get customer group and price data
  const customerGroups = await this.getCustomerGroupNames(ctx);
  const priceData = await this.fetchPriceData();

  // Find the product row in our price data by matching SKU
  const productPrice = priceData.find(
    (p) => p.sku.toLowerCase() === productVariant.sku?.toLowerCase()
  );

  if (!productPrice) {
    // The SKU was not found in our price data sheet
    Logger.error(
      `No price data found for product ${productVariant.sku}`,
      loggerCtx
    );
    return {
      price: productVariant.listPrice,
      priceIncludesTax: productVariant.listPriceIncludesTax,
    };
  }

  // Get price based on customer group
  const price = this.getPriceForCustomerGroup(productPrice, customerGroups);

  return {
    price: Math.round(price * 100), // Convert to cents
    priceIncludesTax: false, // We manage prices in the sheet without tax
  };
}

/**
 * Get the name of the customer groups of the logged in customers
 */
private async getCustomerGroupNames(ctx: RequestContext): Promise<string[]> {
  if (!ctx.activeUserId) {
    return [];
  }
  const cacheKey = `customer-groups-${ctx.activeUserId}`;
  const cacheHit = await this.cache.get(cacheKey);
  if (cacheHit) {
    return cacheHit as string[];
  }
  const customer = await this.transactionalConnection
    .getRepository(ctx, Customer)
    .findOne({
      where: { user: { id: ctx.activeUserId } },
      relations: ["groups"],
    });
  const customerGroups = customer?.groups?.map((group) => group.name) || [];
  await this.cache.set(cacheKey, customerGroups, {
    ttl: 5 * 60 * 1000, // Cache for five minutes
  });
  return customerGroups;
}

private async fetchPriceData(): Promise<Row[]> {
  // TODO: prevent concurrent requests when no cache is present
  const cacheKey = "customer-specific-price-data";
  const cacheHit = await this.cache.get(cacheKey);
  if (cacheHit) {
    return cacheHit as Row[];
  }
  const response = await fetch(
    "https://docs.google.com/spreadsheets/d/e/2PACX-1vRHjU-Bfw7_DbgCxfUvEN7g3Up-vc879xuJN1fTcTo8P8jGGiuc11lZumH9Krw1jNeQpZoTGmsYuyYv/pub?output=csv"
  );
  const csvData = await response.text();
  const records = parse(csvData, {
    columns: true,
    skip_empty_lines: true,
  });
  // Cache for one minute
  await this.cache.set(cacheKey, records, {
    ttl: 1 * 60 * 1000,
  });
  return records;
}

/**
 * Get price for given customer group.
 * Falls back to consumer price if no price is found for the given group.
 */
private getPriceForCustomerGroup(
  row: Row,
  groups: string[]
): number {
  const prices = groups.map((group) => (row[group as keyof Row] as number));
  if (!prices.length) {
    // Fall back to consument price if no price is found for the given group
    return row.Consument;
  }
  return Math.min(...prices);
}
}