export const BILLING_UNITS = {
  perCall: 'per_call',
  per1MTokens: 'per_1m_tokens',
};

export const PRECONSUME_STRATEGIES = {
  exact: 'exact',
  minimum: 'minimum',
};

export const FALLBACKS = {
  reject: 'reject',
  max: 'max',
  default: 'default',
};

export const ROW_SOURCES = {
  manual: 'manual',
  generated: 'generated',
};

const RESERVED_KEYS = new Set([
  'price',
  'source',
  '__fallback__',
  'price_formula',
  'pricing_mode',
  'fallback_strategy',
  'schema_version',
  'scope',
  'billing_unit',
  'preconsume_strategy',
]);

export const createDefaultConfig = () => ({
  schema_version: 1,
  scope: 'model',
  billing_unit: BILLING_UNITS.perCall,
  preconsume_strategy: PRECONSUME_STRATEGIES.exact,
  dimensions: [
    {
      key: 'resolution',
      source: 'request.resolution',
      type: 'string',
      default: null,
    },
  ],
  table: [
    {
      resolution: '*',
      price: 0.1,
      source: ROW_SOURCES.manual,
    },
  ],
  fallback: {
    strategy: FALLBACKS.reject,
  },
});

export const validatePricingConfig = (config) => {
  const errors = [];
  if (!config || typeof config !== 'object') {
    return { ok: false, errors: ['config must be an object'] };
  }

  if (config.schema_version !== 1) errors.push('schema_version must be 1');
  if (config.scope !== 'model') errors.push('scope must be model');

  const billingUnit = config.billing_unit || BILLING_UNITS.perCall;
  const preconsume = config.preconsume_strategy || PRECONSUME_STRATEGIES.exact;
  if (!Object.values(BILLING_UNITS).includes(billingUnit)) errors.push('billing_unit is invalid');
  if (!Object.values(PRECONSUME_STRATEGIES).includes(preconsume)) errors.push('preconsume_strategy is invalid');
  if (billingUnit === BILLING_UNITS.perCall && preconsume !== PRECONSUME_STRATEGIES.exact) {
    errors.push('per_call requires exact preconsume_strategy');
  }
  if (billingUnit === BILLING_UNITS.per1MTokens && preconsume !== PRECONSUME_STRATEGIES.minimum) {
    errors.push('per_1m_tokens requires minimum preconsume_strategy');
  }

  if (!Array.isArray(config.dimensions) || config.dimensions.length === 0) errors.push('dimensions must not be empty');
  if (!Array.isArray(config.table) || config.table.length === 0) errors.push('table must not be empty');

  const dimensionKeys = new Set();
  for (const dim of config.dimensions || []) {
    if (!/^[a-z][a-z0-9_]{0,31}$/.test(dim.key || '')) errors.push(`dimension key "${dim.key || ''}" is invalid`);
    if (RESERVED_KEYS.has(dim.key)) errors.push(`dimension key "${dim.key}" is reserved`);
    if (dimensionKeys.has(dim.key)) errors.push(`dimension key "${dim.key}" is duplicated`);
    dimensionKeys.add(dim.key);
    if (!['string', 'number', 'boolean'].includes(dim.type)) errors.push(`dimension "${dim.key}" type is invalid`);
    if (dim.optional && (dim.default === null || dim.default === undefined)) {
      errors.push(`optional dimension "${dim.key}" requires a default value`);
    }
    if (!dim.optional && dim.default !== null && dim.default !== undefined) {
      errors.push(`required dimension "${dim.key}" must use null default`);
    }
    if (dim.optional && dim.default !== null && dim.default !== undefined && !valueMatchesType(dim.default, dim.type)) {
      errors.push(`dimension "${dim.key}" default does not match type`);
    }
  }

  const rowSignatures = new Set();
  const rowPatterns = [];
  for (const [index, row] of (config.table || []).entries()) {
    for (const key of Object.keys(row || {})) {
      if (!dimensionKeys.has(key) && key !== 'price' && key !== 'source') errors.push(`row ${index + 1} contains extra field "${key}"`);
    }
    for (const dim of config.dimensions || []) {
      if (!(dim.key in row)) {
        errors.push(`row ${index + 1} missing "${dim.key}"`);
        continue;
      }
      if (row[dim.key] !== '*' && !valueMatchesType(row[dim.key], dim.type)) {
        errors.push(`row ${index + 1} value for "${dim.key}" does not match type`);
      }
    }
    const price = Number(row.price);
    if (Number.isNaN(price) || price < 0) errors.push(`row ${index + 1} price must be >= 0`);
    if (!Object.values(ROW_SOURCES).includes(row.source)) errors.push(`row ${index + 1} source must be manual or generated`);

    const signature = (config.dimensions || []).map((dim) => String(row[dim.key])).join('\u0001');
    if (rowSignatures.has(signature)) errors.push(`row ${index + 1} duplicates another row`);
    rowSignatures.add(signature);
    rowPatterns.push({
      index,
      values: (config.dimensions || []).map((dim) => row[dim.key]),
      wildcards: (config.dimensions || []).filter((dim) => row[dim.key] === '*').length,
    });
  }

  for (let i = 0; i < rowPatterns.length; i += 1) {
    for (let j = i + 1; j < rowPatterns.length; j += 1) {
      if (rowPatterns[i].wildcards !== rowPatterns[j].wildcards) continue;
      if (patternsOverlap(rowPatterns[i].values, rowPatterns[j].values)) {
        errors.push(`rows ${rowPatterns[i].index + 1} and ${rowPatterns[j].index + 1} are ambiguous`);
      }
    }
  }

  const strategy = config.fallback?.strategy;
  if (!Object.values(FALLBACKS).includes(strategy)) errors.push('fallback.strategy is invalid');
  if (strategy === FALLBACKS.default && (config.fallback.default_price === undefined || Number(config.fallback.default_price) < 0)) {
    errors.push('fallback.default_price must be >= 0');
  }

  return { ok: errors.length === 0, errors };
};

export const generateRowsFromRatios = ({ dimensions, basePrice, ratios }) => {
  const dims = dimensions || [];
  if (dims.length === 0) return [];

  const build = (index, prefix, price) => {
    if (index >= dims.length) return [{ ...prefix, price: Number(Number(price).toFixed(6)), source: ROW_SOURCES.generated }];
    const dim = dims[index];
    const dimRatios = ratios?.[dim.key] || {};
    return Object.entries(dimRatios).flatMap(([value, ratio]) =>
      build(index + 1, { ...prefix, [dim.key]: parseDimensionValue(value, dim.type) }, price * Number(ratio || 1)),
    );
  };

  return build(0, {}, Number(basePrice || 0));
};

export const mergeGeneratedRows = ({ existingRows, generatedRows, strategy }) => {
  if (strategy === 'replace_all') return [...(generatedRows || [])];
  const manualRows = (existingRows || []).filter((row) => row.source === ROW_SOURCES.manual);
  return [...manualRows, ...(generatedRows || [])];
};

export const importPricingCsv = (text, dimensions) => {
  const lines = String(text || '').trim().split(/\r?\n/).filter(Boolean);
  if (lines.length === 0) return { rows: [], errors: [] };

  const headers = parseCsvLine(lines[0]);
  const errors = [];
  const rows = lines.slice(1).map((line, index) => {
    const cells = parseCsvLine(line);
    const row = {};
    headers.forEach((header, i) => {
      row[header] = cells[i] ?? '';
    });
    for (const dim of dimensions || []) row[dim.key] = row[dim.key] === '*' ? '*' : parseDimensionValue(row[dim.key], dim.type);
    row.price = Number(row.price);
    row.source = row.source || ROW_SOURCES.manual;
    if (Number.isNaN(row.price)) errors.push(`line ${index + 2} has invalid price`);
    return row;
  });

  return { rows, errors };
};

export const exportPricingCsv = (rows, dimensions) => {
  const headers = [...(dimensions || []).map((dim) => dim.key), 'price', 'source'];
  const body = (rows || []).map((row) => headers.map((header) => escapeCsvValue(row[header] ?? '')).join(','));
  return [headers.join(','), ...body].join('\n');
};

export const previewLookup = (config, requestValues) => {
  const validation = validatePricingConfig(config);
  if (!validation.ok) return { mode: 'invalid', error: validation.errors.join('\n') };

  const matches = [];
  for (const row of config.table || []) {
    let wildcards = 0;
    let matched = true;
    for (const dim of config.dimensions || []) {
      const expected = row[dim.key];
      if (expected === '*') {
        wildcards += 1;
        continue;
      }
      if (String(expected) !== String(requestValues?.[dim.key])) {
        matched = false;
        break;
      }
    }
    if (matched) matches.push({ row, wildcards });
  }

  matches.sort((a, b) => a.wildcards - b.wildcards);
  if (matches.length > 1 && matches[0].wildcards === matches[1].wildcards) return { mode: 'reject', error: 'ambiguous matching rows' };
  if (matches.length > 0) {
    const best = matches[0];
    return {
      mode: 'matched',
      row: best.row,
      price: Number(best.row.price),
      snapshot: buildSnapshot(config, requestValues, Number(best.row.price), 'matched'),
    };
  }

  if (config.fallback.strategy === FALLBACKS.reject) return { mode: 'reject', error: 'no pricing row matched' };
  if (config.fallback.strategy === FALLBACKS.max) {
    const price = Math.max(...config.table.map((row) => Number(row.price || 0)));
    return { mode: 'fallback_max', price, snapshot: buildSnapshot(config, requestValues, price, 'fallback_max', FALLBACKS.max) };
  }

  const price = Number(config.fallback.default_price || 0);
  return { mode: 'fallback_default', price, snapshot: buildSnapshot(config, requestValues, price, 'fallback_default', FALLBACKS.default) };
};

export const parseDimensionValue = (value, type) => {
  if (value === '*') return value;
  if (type === 'number') return Number(value);
  if (type === 'boolean') return value === true || value === 'true';
  return value;
};

const valueMatchesType = (value, type) => {
  if (type === 'number') return typeof value === 'number' && !Number.isNaN(value);
  if (type === 'boolean') return typeof value === 'boolean';
  return typeof value === 'string';
};

const patternsOverlap = (left, right) =>
  left.every((leftValue, index) => leftValue === '*' || right[index] === '*' || String(leftValue) === String(right[index]));

const parseCsvLine = (line) => line.split(',').map((item) => item.trim());

const escapeCsvValue = (value) => {
  const text = String(value);
  if (!/[",\n]/.test(text)) return text;
  return `"${text.replaceAll('"', '""')}"`;
};

const buildSnapshot = (config, values, price, mode, fallbackStrategy) => {
  const snapshot = {};
  for (const dim of config.dimensions || []) snapshot[dim.key] = values?.[dim.key] ?? null;
  snapshot.price = price;
  snapshot.billing_unit = config.billing_unit || BILLING_UNITS.perCall;
  snapshot.pricing_mode = mode;
  if (fallbackStrategy) snapshot.fallback_strategy = fallbackStrategy;
  return snapshot;
};