import {
  validateShippingConfig,
  getAvailableShippingMethods,
  type EvaluationContext,
} from "shipping-methods-dsl";

// Load and validate config
const config = validateShippingConfig(configJson);

// Create evaluation context from cart/order data
const context: EvaluationContext = {
  orderValue: 100.0,
  itemCount: 3,
  country: "US",
  locale: "en",
};

// Get available shipping methods
const methods = getAvailableShippingMethods(config, context);
console.log(methods);

interface ShippingCalculationResult {
  id: string;           // Full ID - use this for backend validation
  methodId: string;     // Base method ID
  tierId?: string;      // Tier ID if tiered pricing
  price: number;
  available: boolean;
  // ... other fields
}

// Tiered pricing result
{
  id: "shipping.us.free:tier_express",
  methodId: "shipping.us.free",
  tierId: "tier_express",
  price: 0
}

// Non-tiered pricing result
{
  id: "shipping.us.standard",
  methodId: "shipping.us.standard",
  tierId: undefined,
  price: 4.97
}

import { registerPricingPlugin } from "shipping-methods-dsl";

registerPricingPlugin("my_plugin", (config, context) => {
  // Your custom pricing logic
  return calculatedPrice;
});

import {
  type ShippingConfig,
  getShippingMethodById,
  validateShippingConfig,
} from "shipping-methods-dsl";

// Load your config (from KV, R2, or environment)
const config = validateShippingConfig(configJson);

export default {
  async fetch(request: Request): Promise<Response> {
    const body = await request.json();
    const { shippingMethodId, orderValue, itemCount, country } = body;

    // Create context from order data
    const context = {
      orderValue,
      itemCount,
      country,
      locale: request.headers.get("Accept-Language") || "en",
    };

    // Validate the shipping method ID from frontend
    const shippingMethod = getShippingMethodById(config, shippingMethodId, context);

    if (!shippingMethod) {
      return Response.json({ error: "Invalid shipping method" }, { status: 400 });
    }

    if (!shippingMethod.available) {
      return Response.json({
        error: "Shipping method not available",
        message: shippingMethod.message
      }, { status: 400 });
    }

    // Use the validated shipping price
    const shippingCost = shippingMethod.price;
    const total = orderValue + shippingCost;

    return Response.json({
      shippingCost,
      shippingMethod: {
        id: shippingMethod.id,
        name: shippingMethod.name,
        estimatedDays: shippingMethod.estimatedDays,
      },
      total,
    });
  }
};

import { getAvailableShippingMethods } from "shipping-methods-dsl";

// Frontend gets available methods and displays to user
const methods = getAvailableShippingMethods(config, {
  orderValue: cart.total,
  itemCount: cart.items.length,
  country: user.country,
  locale: "en",
});

// Display methods to user
methods.forEach(method => {
  console.log(`${method.id}: $${method.price}`);
  // For tiered pricing: id is "method_id:tier_id"
  // For non-tiered: id is just "method_id"
  if (method.tierId) {
    console.log(`  (Tiered: ${method.methodId}:${method.tierId})`);
  }
});

// User selects a method - use the id directly (no need to construct)
const selectedMethod = methods[0]; // User's selection

await fetch("/api/checkout", {
  method: "POST",
  body: JSON.stringify({
    shippingMethodId: selectedMethod.id, // Use id directly
    orderValue: cart.total,
    itemCount: cart.items.length,
    country: user.country,
  }),
});

import { getTieredMethodOptions, getShippingMethodById } from "shipping-methods-dsl";

// Get all tier options for a tiered method
const tiers = getTieredMethodOptions(config, "shipping.express", context);
// Returns:
// [
//   { id: "shipping.express:standard", price: 8.99, available: true, ... },
//   { id: "shipping.express:premium", price: 12.99, available: true, ... }
// ]

// Validate a specific tier selection
const selected = getShippingMethodById(config, "shipping.express:premium", context);
if (selected?.available) {
  console.log(`${selected.name}: $${selected.price}`);
}

import type {
  ShippingConfig,
  ShippingMethod,
  Pricing,
  EvaluationContext,
  ShippingCalculationResult,
} from "shipping-methods-dsl";

const methods = getShippingMethodsForDisplay(config, context);
methods.forEach(method => {
  // Progress is shown when:
  // - Tiered: user is in lower tier, better tier has availability config
  // - Non-tiered: method conditions not met, has availability config
  if (method.progress) {
    const { current, required, remaining, percentage } = method.progress;
    console.log(`Progress: ${percentage.toFixed(0)}%`);
    console.log(`${method.upgradeMessage}`); // e.g., "Add $25 more to unlock free shipping"
  }
});

const method = getShippingMethodById(config, "shipping.us.express", context);
console.log(method?.meta?.carrier); // "FedEx"

// Configuration context for evaluation
interface EvaluationContext {
  orderValue: number;
  itemCount: number;
  weight?: number;
  country: string;        // ISO 3166-1 alpha-2 (e.g., "US", "CA")
  currency?: string;      // ISO 4217 (e.g., "USD")
  locale?: string;        // Language code (e.g., "en", "vi")
}

// Localized string (single string or locale map)
type LocalizedString = string | Record<string, string>;

// Numeric range
interface RangeNumber {
  min?: number;
  max?: number;
}

// Estimated delivery days
interface EstimatedDays {
  min: number;
  max: number;
}

// Geographic conditions
interface GeoCountry {
  include?: string[];     // Country codes to include
  exclude?: string[];     // Country codes to exclude
}

// Order-based conditions
interface OrderConditions {
  value?: RangeNumber;    // Order value range
  items?: RangeNumber;    // Item count range
  weight?: RangeNumber;   // Weight range
}

// Pricing types
type Pricing =
  | { type: "flat"; amount: number }
  | { type: "item_based"; firstItemPrice: number; additionalItemPrice: number }
  | { type: "value_based"; percentage: number; minAmount?: number; maxAmount?: number }
  | { type: "tiered"; rules: Rule[] }
  | { type: "custom"; plugin: string; config: Record<string, unknown> };

// Tiered pricing rule
interface Rule {
  id: string;
  label?: LocalizedString;
  criteria: {
    geo?: { country?: GeoCountry };
    order?: OrderConditions;
  };
  price: number;
  estimatedDays?: EstimatedDays;
  promoText?: LocalizedString;
  upgradeMessage?: LocalizedString;
  availability?: Availability; // Tier-level availability for upgrade hints
}

// Availability configuration
interface Availability {
  mode: "hide" | "show_disabled" | "show_hint";
  when?: Array<"order.value.min" | "order.items.min" | "order.weight.min">;
  message?: LocalizedString;
  showProgress?: boolean;
}

// Display configuration
interface Display {
  priority?: number;
  badge?: string;
  promoText?: LocalizedString;
}

// Shipping method definition
interface ShippingMethod {
  id: string;
  enabled: boolean;
  name: LocalizedString;
  description?: LocalizedString;
  icon?: string;
  display?: Display;
  conditions?: {
    geo?: { country?: GeoCountry };
    order?: OrderConditions;
  };
  pricing: Pricing;
  availability?: Availability; // Method-level availability for non-tiered pricing
  estimatedDays?: EstimatedDays;
  meta?: Record<string, unknown>;
}

// Root configuration
interface ShippingConfig {
  $schema?: string;
  version: "1.0";
  currency?: string;
  methods: ShippingMethod[];
}

// Calculation result
interface ShippingCalculationResult {
  id: string;              // Full ID: "method_id" or "method_id:tier_id"
  methodId: string;        // Base method ID
  tierId?: string;         // Tier ID (for tiered pricing)
  price: number;
  available: boolean;
  availabilityMode?: "hide" | "show_disabled" | "show_hint"; // How to display when not available/showing hints
  message?: string;
  estimatedDays?: EstimatedDays;
  promoText?: string;
  upgradeMessage?: string;
  progress?: {
    current: number;
    required: number;
    remaining: number;
    percentage: number;
  };
}

// Detailed method information
interface ShippingMethodDetail extends ShippingCalculationResult {
  name: string;            // Localized name
  description?: string;    // Localized description
  icon?: string;
  badge?: string;
  enabled: boolean;
  meta?: Record<string, unknown>;
}

// Custom pricing plugin function
type CustomPricingPlugin = (
  config: Record<string, unknown>,
  context: EvaluationContext
) => number;

function validateShippingConfig(data: unknown): ShippingConfig

try {
  const config = validateShippingConfig(configJson);
  console.log("Config is valid");
} catch (error) {
  console.error("Invalid config:", error.message);
}

function calculateShippingMethod(
  method: ShippingMethod,
  context: EvaluationContext
): ShippingCalculationResult

function calculateAllShippingMethods(
  config: ShippingConfig,
  context: EvaluationContext
): ShippingCalculationResult[]

function getAvailableShippingMethods(
  config: ShippingConfig,
  context: EvaluationContext
): ShippingCalculationResult[]

function getCheapestShippingMethod(
  config: ShippingConfig,
  context: EvaluationContext
): ShippingCalculationResult | undefined

function getShippingMethodsForDisplay(
  config: ShippingConfig,
  context: EvaluationContext
): Array<ShippingCalculationResult & {
  name: string;
  description?: string;
  icon?: string;
  badge?: string;
}>

function getShippingMethodById(
  config: ShippingConfig,
  id: string,
  context: EvaluationContext
): ShippingMethodDetail | undefined

function getTieredMethodOptions(
  config: ShippingConfig,
  methodId: string,
  context: EvaluationContext
): ShippingMethodDetail[]

function registerPricingPlugin(
  name: string,
  handler: CustomPricingPlugin
): void

import { registerPricingPlugin } from "shipping-methods-dsl";

registerPricingPlugin("weight_based", (config, context) => {
  const ratePerKg = config.ratePerKg as number;
  const minCharge = config.minCharge as number;
  const weight = context.weight || 0;
  return Math.max(weight * ratePerKg, minCharge);
});

function getPricingPlugin(name: string): CustomPricingPlugin | undefined

function evaluateConditions(
  conditions: Conditions | undefined,
  context: EvaluationContext
): boolean

function calculateRemaining(
  condition: string,
  conditions: Conditions | undefined,
  context: EvaluationContext
): number

function getMinimumRequired(
  condition: string,
  conditions: Conditions | undefined
): number | undefined

import { validateShippingConfig } from "shipping-methods-dsl";

// In your app initialization
const config = validateShippingConfig(await loadConfig());

let cachedConfig: ShippingConfig | null = null;

export function getConfig(): ShippingConfig {
  if (!cachedConfig) {
    cachedConfig = validateShippingConfig(rawConfig);
  }
  return cachedConfig;
}

// Frontend sends: { shippingMethodId: "shipping.express:tier_premium", ... }

// Backend validates:
const method = getShippingMethodById(config, shippingMethodId, context);

if (!method || !method.available) {
  throw new Error("Invalid shipping method");
}

// Use method.price for final calculation
const total = orderValue + method.price;

const methods = getAvailableShippingMethods(config, context);

if (methods.length === 0) {
  // Show message: "No shipping methods available for your location"
  // Or suggest changes: "Reduce order weight" or "Change delivery country"
}

const context: EvaluationContext = {
  orderValue: cart.total,
  itemCount: cart.items.length,
  country: user.country,
  locale: user.preferredLanguage || "en",
};

// Test different countries
const usContext = { ...baseContext, country: "US" };
const caContext = { ...baseContext, country: "CA" };

// Test different order values
const smallOrder = { ...baseContext, orderValue: 25 };
const largeOrder = { ...baseContext, orderValue: 500 };

// Test item counts
const singleItem = { ...baseContext, itemCount: 1 };
const bulkOrder = { ...baseContext, itemCount: 50 };

import type {
  ShippingConfig,
  EvaluationContext,
  ShippingCalculationResult,
  ShippingMethodDetail,
} from "shipping-methods-dsl";