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

// 1. Load and validate config (do this once, cache it)
const config = validateShippingConfig(configJson);

// 2. Create context from current cart state
const context: EvaluationContext = {
  orderValue: cart.total,
  itemCount: cart.items.length,
  country: user.country,
  locale: user.language,
};

// 3. Get all methods with complete UI information
const methods: DisplayShippingMethod[] = getShippingMethodsForDisplay(config, context);

// 4. Display in your UI
// Note: Methods with availabilityMode: "hide" are automatically filtered out
methods.forEach(method => {
  if (method.available) {
    // Show as selectable option
    console.log(`${method.name} - $${method.price}`);
    if (method.badge) console.log(`Badge: ${method.badge}`);
  }

  // Show upgrade hint (progress bar, etc.)
  if (method.nextTier && method.progress) {
    console.log(`${method.upgradeMessage}`);
    console.log(`Progress: ${method.progress.percentage}%`);
    console.log(`Next: ${method.nextTier.label} - $${method.nextTier.price}`);
  }
});

// Filter/sort as needed
const available = methods.filter(m => m.available);
const cheapest = available.sort((a, b) => a.price - b.price)[0];

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

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

// 2. Frontend sends shipping method ID
// POST /api/checkout
// { shippingMethodId: "shipping.us.standard:tier_free", ... }

// 3. Validate the selection
const context: EvaluationContext = {
  orderValue: cart.total,
  itemCount: cart.items.length,
  country: user.country,
};

const method: ValidatedShippingMethod | undefined =
  getShippingMethodById(config, req.body.shippingMethodId, context);

if (!method || !method.available) {
  return res.status(400).json({ error: "Invalid shipping method" });
}

// 4. Use validated price for final total
const total = cart.total + method.price;
const estimatedDelivery = method.estimatedDays;

// Process order...

const context = {
  orderValue: 100,
  itemCount: 2,
  country: "US",
  orderDate: new Date(), // Required for date-based criteria
};

// Date range: Dec 10-19 (inclusive start, exclusive end)
"date": { "after": "2024-12-10", "before": "2024-12-20" }
// Matches: Dec 10 00:00:00 through Dec 19 23:59:59
// Does NOT match: Dec 9, Dec 20

// Only after (no end date)
"date": { "after": "2024-12-31" }
// Matches: Dec 31 00:00:00 and later

// Only before (no start date)
"date": { "before": "2024-12-15" }
// Matches: Any time before Dec 15 00:00:00

// Business hours: 9 AM - 5 PM UTC
"date": {
  "after": "2024-12-15T09:00:00Z",
  "before": "2024-12-15T17:00:00Z"
}
// Matches: 9:00:00 AM through 4:59:59 PM on Dec 15
// Excludes: 5:00:00 PM and later (before is exclusive)

// After 2 PM EST (3 PM UTC during standard time)
"date": { "after": "2024-12-15T15:00:00Z" }
// Matches: Dec 15 3:00 PM UTC and later
// Note: EST is UTC-5, so 2 PM EST = 7 PM UTC (in daylight time)

// With timezone offset notation
"date": { "after": "2024-12-15T14:00:00-05:00" }
// Matches: Dec 15 2:00 PM EST and later (automatically converted to UTC)

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

const config = validateShippingConfig(configJson);

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

const methods = getShippingMethodsForDisplay(config, {
  orderValue: 75,
  itemCount: 2,
  country: "US",
  locale: "en",
});

// Display in UI
methods.forEach(method => {
  if (method.available) {
    // Show as selectable option
    console.log(`${method.name} - $${method.price}`);
  }

  // Show upgrade hint
  if (method.nextTier && method.progress) {
    console.log(`${method.upgradeMessage}`);
    console.log(`Next: ${method.nextTier.label} - $${method.nextTier.price}`);
  }
});

// Get only available methods
const available = methods.filter(m => m.available);

// Get cheapest method
const cheapest = available.sort((a, b) => a.price - b.price)[0];

// Filter by availabilityMode
const hints = methods.filter(m => m.availabilityMode === "show_hint");

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

// Frontend sends: { shippingMethodId: "shipping.us.standard:tier_free" }

// Backend validates
const method = getShippingMethodById(config, shippingMethodId, {
  orderValue: cart.total,
  itemCount: cart.items.length,
  country: user.country,
});

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

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

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

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

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 { getProcessingTime } from "shipping-methods-dsl";

// Get current processing time
const processingTime = getProcessingTime(config);
console.log(`Processing: ${processingTime.min}-${processingTime.max} days`);

// Get processing time for specific date
const christmasTime = getProcessingTime(config, new Date("2024-12-15"));
console.log(`Christmas processing: ${christmasTime.min}-${christmasTime.max} days`);

const methods = getShippingMethodsForDisplay(config, context);
const processingTime = getProcessingTime(config, context.orderDate);

methods.forEach(method => {
  const shipping = method.estimatedDays;
  const total = {
    min: processingTime.min + (shipping?.min || 0),
    max: processingTime.max + (shipping?.max || 0)
  };

  console.log(`${method.name}`);
  console.log(`Processing: ${processingTime.min}-${processingTime.max} days`);
  console.log(`Shipping: ${shipping?.min}-${shipping?.max} days`);
  console.log(`Total delivery: ${total.min}-${total.max} days`);
});

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 && method.nextTier) {
    const { current, required, remaining, percentage } = method.progress;
    const { label, price, estimatedDays } = method.nextTier;

    console.log(`Current: ${method.name} - $${method.price}`);
    console.log(`Progress: ${percentage.toFixed(0)}%`);
    console.log(`Next tier: ${label} - $${price}`);
    if (estimatedDays) {
      console.log(`Delivery: ${estimatedDays.min}-${estimatedDays.max} days`);
    }
    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")
  state?: string;         // ISO 3166-2 (e.g., "US-CA") or simple code (e.g., "CA", "AK")
  currency?: string;      // ISO 4217 (e.g., "USD")
  locale?: string;        // Language code (e.g., "en", "vi")
  orderDate?: Date;       // Order date for seasonal/holiday pricing
}

// 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 (ISO 3166-1 alpha-2)
  exclude?: string[];     // Country codes to exclude
}

interface GeoState {
  include?: string[];     // State codes to include (ISO 3166-2 or simple codes)
  exclude?: string[];     // State codes to exclude
}

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

// Date-based conditions for seasonal/holiday pricing
interface DateCriteria {
  after?: string;         // ISO 8601 date string - inclusive (orderDate >= after)
  before?: string;        // ISO 8601 date string - exclusive (orderDate < before)
}

// 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;
    date?: DateCriteria;          // Date-based criteria for seasonal pricing
  };
  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;
    date?: DateCriteria;          // Date-based criteria (method-level)
  };
  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[];
}

// ============================================
// FRONTEND TYPE - For UI display
// ============================================
interface DisplayShippingMethod {
  // Identity
  id: string;              // Full ID: "method_id" or "method_id:tier_id"
  methodId: string;
  tierId?: string;

  // Display Information
  name: string;            // Localized
  description?: string;    // Localized
  icon?: string;
  badge?: string;

  // Pricing & Availability
  price: number;
  available: boolean;
  enabled: boolean;
  estimatedDays?: EstimatedDays;

  // Availability Mode (how to display in UI)
  availabilityMode?: "hide" | "show_disabled" | "show_hint";
  message?: string;
  promoText?: string;      // Localized
  upgradeMessage?: string; // Localized

  // Progress Tracking
  progress?: {
    current: number;
    required: number;
    remaining: number;
    percentage: number;
  };

  // Next Tier Information (for upgrade hints)
  nextTier?: {
    id: string;
    label?: string;        // Localized
    price: number;
    estimatedDays?: EstimatedDays;
  };

  // Custom Metadata
  meta?: Record<string, unknown>;
}

// ============================================
// BACKEND TYPE - For order validation
// ============================================
interface ValidatedShippingMethod {
  // Identity
  id: string;              // Full ID that was validated
  methodId: string;
  tierId?: string;

  // Validation Result
  available: boolean;
  enabled: boolean;

  // Pricing (what matters for checkout)
  price: number;
  estimatedDays?: EstimatedDays;

  // Display info (for order confirmation)
  name: string;            // Localized
  description?: string;    // Localized

  // Custom Metadata
  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 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,
  DisplayShippingMethod,
} from "shipping-methods-dsl";

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