import json
import sys
from typing import Any, Dict, List
from datetime import datetime, timedelta


def to_float(value: Any, default: float = 0.0) -> float:
    try:
        if value is None or value == '':
            return default
        return float(value)
    except (TypeError, ValueError):
        return default


def to_bool(value: Any) -> bool:
    if isinstance(value, bool):
        return value
    if isinstance(value, (int, float)):
        return value != 0
    if isinstance(value, str):
        return value.strip().lower() in {'1', 'true', 'yes', 'y'}
    return False


def normalize_order(row: Dict[str, Any]) -> Dict[str, Any]:
    return {
        'order_id': str(row.get('order_id', '')),
        'customer_id': None if row.get('customer_id') is None else str(row.get('customer_id')),
        'destination': str(row.get('destination', '')),
        'length_cm': to_float(row.get('length_cm')),
        'width_cm': to_float(row.get('width_cm')),
        'area_sqm': to_float(row.get('area_sqm')),
        'weight_kg': to_float(row.get('weight_kg')),
        'expect_date': row.get('expect_date'),
        'status': str(row.get('status', 'pending')),
        'is_vip': to_bool(row.get('is_vip')),
        'import_date': row.get('import_date'),
    }


def normalize_quote(row: Dict[str, Any]) -> Dict[str, Any]:
    return {
        'supplier': str(row.get('supplier', '')),
        'vehicle_type': str(row.get('vehicle_type', '')),
        'destination': str(row.get('destination', '')),
        'available_area': to_float(row.get('available_area')),
        'base_price': to_float(row.get('base_price')),
        'unit_price': to_float(row.get('unit_price')),
        'transit_days': to_float(row.get('transit_days')),
        'is_active': True if row.get('is_active') is None else to_bool(row.get('is_active')),
    }


def compute_vehicle_cost(vehicle: Dict[str, Any]) -> float:
    return to_float(vehicle['base_price']) + to_float(vehicle['used_area']) * to_float(vehicle['unit_price'])


def build_vehicle(vehicle_id: str, quote: Dict[str, Any], destination: str) -> Dict[str, Any]:
    return {
        'vehicle_id': vehicle_id,
        'supplier': quote['supplier'],
        'vehicle_type': quote['vehicle_type'],
        'destination': destination,
        'capacity_area': to_float(quote['available_area']),
        'used_area': 0.0,
        'remaining_area': to_float(quote['available_area']),
        'utilization': 0.0,
        'base_price': to_float(quote['base_price']),
        'unit_price': to_float(quote['unit_price']),
        'transit_days': to_float(quote['transit_days']),
        'total_cost': 0.0,
        'orders': [],
    }


def sort_orders(orders: List[Dict[str, Any]], mode: str) -> List[Dict[str, Any]]:
    if mode == 'speed':
        return sorted(
            orders,
            key=lambda item: (
                0 if item['is_vip'] else 1,
                item['expect_date'] or '9999-12-31',
                -item['area_sqm'],
                -item['weight_kg'],
            ),
        )
    return sorted(
        orders,
        key=lambda item: (
            -item['area_sqm'],
            -item['weight_kg'],
            item['expect_date'] or '9999-12-31',
        ),
    )


def sort_quotes(quotes: List[Dict[str, Any]], mode: str, order_area: float) -> List[Dict[str, Any]]:
    if mode == 'speed':
        return sorted(
            quotes,
            key=lambda item: (
                item['transit_days'],
                item['base_price'] + item['unit_price'] * order_area,
                -item['available_area'],
            ),
        )
    return sorted(
        quotes,
        key=lambda item: (
            item['base_price'] + item['unit_price'] * order_area,
            item['transit_days'],
            item['available_area'],
        ),
    )


def parse_date(value: Any):
    if value is None:
        return None
    if isinstance(value, str):
        value = value.strip()
        if not value:
            return None
        try:
            return datetime.strptime(value[:10], '%Y-%m-%d').date()
        except ValueError:
            return None
    return None


def can_meet_deadline(order: Dict[str, Any], transit_days: float, plan_date: str, hard_deadline_order_ids) -> bool:
    if order['order_id'] not in hard_deadline_order_ids:
        return True
    expected_date = parse_date(order.get('expect_date'))
    dispatch_date = parse_date(plan_date)
    if expected_date is None or dispatch_date is None:
        return False
    arrival_date = dispatch_date + timedelta(days=int(round(transit_days)))
    return arrival_date <= expected_date


def compute_late_days(order: Dict[str, Any], transit_days: float, plan_date: str) -> int:
    expected_date = parse_date(order.get('expect_date'))
    dispatch_date = parse_date(plan_date)
    if expected_date is None or dispatch_date is None:
        return 0
    arrival_date = dispatch_date + timedelta(days=int(round(transit_days)))
    return max(0, (arrival_date - expected_date).days)


def compute_lateness_penalty(order: Dict[str, Any], transit_days: float, plan_date: str, penalty_config: Dict[str, float]) -> float:
    late_days = compute_late_days(order, transit_days, plan_date)
    if late_days <= 0:
        return 0.0

    base_penalty = penalty_config['vip_lateness_penalty_per_day'] if order['is_vip'] else penalty_config['lateness_penalty_per_day']
    if base_penalty <= 0:
        return 0.0

    multiplier = 1.0
    threshold = penalty_config['severe_delay_threshold_days']
    if threshold > 0 and late_days > threshold:
        multiplier = penalty_config['severe_delay_multiplier']

    return late_days * base_penalty * multiplier


def build_assignment_score(mode: str, shipping_cost: float, lateness_penalty: float, remaining_after: float, transit_days: float):
    if mode == 'speed':
        return (lateness_penalty, transit_days, shipping_cost, remaining_after)
    return (shipping_cost + lateness_penalty, remaining_after, transit_days)


def choose_existing_vehicle(order: Dict[str, Any], vehicles: List[Dict[str, Any]], mode: str, plan_date: str, hard_deadline_order_ids, penalty_config: Dict[str, float]):
    fits = []
    for vehicle in vehicles:
        if vehicle['remaining_area'] + 1e-9 < order['area_sqm']:
            continue
        if not can_meet_deadline(order, vehicle['transit_days'], plan_date, hard_deadline_order_ids):
            continue
        remaining_after = vehicle['remaining_area'] - order['area_sqm']
        cost_after = vehicle['base_price'] + (vehicle['used_area'] + order['area_sqm']) * vehicle['unit_price']
        lateness_penalty = compute_lateness_penalty(order, vehicle['transit_days'], plan_date, penalty_config)
        score = build_assignment_score(mode, cost_after, lateness_penalty, remaining_after, vehicle['transit_days'])
        fits.append((score, vehicle))

    if not fits:
        return None

    fits.sort(key=lambda item: item[0])
    return fits[0][1]


def finalize_vehicle(vehicle: Dict[str, Any]) -> None:
    capacity = to_float(vehicle['capacity_area'])
    used_area = to_float(vehicle['used_area'])
    vehicle['remaining_area'] = max(0.0, capacity - used_area)
    vehicle['utilization'] = 0.0 if capacity <= 0 else used_area / capacity
    vehicle['total_cost'] = compute_vehicle_cost(vehicle)


def solve(payload: Dict[str, Any]) -> Dict[str, Any]:
    mode = str(payload.get('mode', 'speed'))
    destination = str(payload.get('destination', ''))
    plan_date = str(payload.get('date', ''))
    hard_deadline_order_ids = set(str(item) for item in payload.get('hardDeadlineOrderIds', []) if str(item).strip())
    penalty_config = {
        'lateness_penalty_per_day': to_float(payload.get('latenessPenaltyPerDay')),
        'vip_lateness_penalty_per_day': to_float(payload.get('vipLatenessPenaltyPerDay'), to_float(payload.get('latenessPenaltyPerDay'))),
        'severe_delay_threshold_days': to_float(payload.get('severeDelayThresholdDays')),
        'severe_delay_multiplier': max(1.0, to_float(payload.get('severeDelayMultiplier'), 1.0)),
    }
    orders = [normalize_order(item) for item in payload.get('orders', [])]
    quotes = []
    for item in payload.get('quotes', []):
        quote = normalize_quote(item)
        if quote['is_active']:
            quotes.append(quote)

    vehicles: List[Dict[str, Any]] = []
    unassigned_orders: List[Dict[str, Any]] = []
    vehicle_index = 0
    total_lateness_penalty = 0.0

    for order in sort_orders(orders, mode):
        existing_vehicle = choose_existing_vehicle(order, vehicles, mode, plan_date, hard_deadline_order_ids, penalty_config)
        if existing_vehicle is not None:
            existing_vehicle['orders'].append(order)
            existing_vehicle['used_area'] += order['area_sqm']
            finalize_vehicle(existing_vehicle)
            total_lateness_penalty += compute_lateness_penalty(order, existing_vehicle['transit_days'], plan_date, penalty_config)
            continue

        quote_candidates = [
            quote for quote in quotes
            if quote['available_area'] + 1e-9 >= order['area_sqm']
            and can_meet_deadline(order, quote['transit_days'], plan_date, hard_deadline_order_ids)
        ]
        if not quote_candidates:
            unassigned_orders.append(order)
            continue

        quote_candidates = sorted(
            quote_candidates,
            key=lambda quote: build_assignment_score(
                mode,
                quote['base_price'] + quote['unit_price'] * order['area_sqm'],
                compute_lateness_penalty(order, quote['transit_days'], plan_date, penalty_config),
                quote['available_area'] - order['area_sqm'],
                quote['transit_days'],
            ),
        )

        vehicle_index += 1
        vehicle = build_vehicle(f'vehicle-{vehicle_index}', quote_candidates[0], destination or order['destination'])
        vehicle['orders'].append(order)
        vehicle['used_area'] = order['area_sqm']
        finalize_vehicle(vehicle)
        total_lateness_penalty += compute_lateness_penalty(order, vehicle['transit_days'], plan_date, penalty_config)
        vehicles.append(vehicle)

    total_cost = sum(vehicle['total_cost'] for vehicle in vehicles)
    total_area = sum(vehicle['used_area'] for vehicle in vehicles)
    average_utilization = 0.0 if not vehicles else sum(vehicle['utilization'] for vehicle in vehicles) / len(vehicles)
    max_transit_days = max([vehicle['transit_days'] for vehicle in vehicles], default=0.0)
    objective_value = total_cost + total_lateness_penalty

    return {
        'destination': destination,
        'plan_date': plan_date,
        'mode': mode,
        'vehicles': vehicles,
        'orders': orders,
        'quotes': quotes,
        'total_cost': round(total_cost, 2),
        'total_area': round(total_area, 4),
        'average_utilization': average_utilization,
        'max_transit_days': max_transit_days,
        'total_lateness_penalty': round(total_lateness_penalty, 2),
        'objective_value': round(objective_value, 2),
        'unassigned_orders': unassigned_orders,
    }


def main() -> int:
    payload = json.loads(sys.stdin.read() or '{}')
    result = solve(payload)
    sys.stdout.write(json.dumps(result, ensure_ascii=False))
    return 0


if __name__ == '__main__':
    raise SystemExit(main())
