Inventory Management (Advanced)

// ─── JAVA BLUEPRINT ──────────────────────────────────────────────────────────
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

enum StockStatus {
    AVAILABLE,
    RESERVED,
    DAMAGED
}

class SKUStock {
    private final String sku;
    private final AtomicInteger physicalQty = new AtomicInteger(0);
    private final AtomicInteger reservedQty = new AtomicInteger(0);
    private final AtomicInteger damagedQty = new AtomicInteger(0);

    public SKUStock(String sku, int physicalQty) {
        this.sku = sku;
        this.physicalQty.set(physicalQty);
    }

    public String getSku() { return sku; }
    
    public int getPhysicalQty() { return physicalQty.get(); }
    public int getReservedQty() { return reservedQty.get(); }
    public int getDamagedQty() { return damagedQty.get(); }

    public void setPhysicalQty(int qty) { this.physicalQty.set(qty); }
    public void addDamaged(int qty) {
        this.physicalQty.addAndGet(-qty);
        this.damagedQty.addAndGet(qty);
    }

    public int getEffectiveAvailable(double overbookingBufferPercent) {
        int physical = physicalQty.get();
        int reserved = reservedQty.get();
        int damaged = damagedQty.get();
        int baseAvailable = Math.max(0, physical - reserved - damaged);
        int buffer = (int) Math.floor(physical * overbookingBufferPercent);
        return baseAvailable + buffer;
    }

    public boolean reserve(int qty, double overbookingBufferPercent) {
        while (true) {
            int currentReserved = reservedQty.get();
            int currentPhysical = physicalQty.get();
            int currentDamaged = damagedQty.get();
            
            int baseAvailable = Math.max(0, currentPhysical - currentReserved - currentDamaged);
            int buffer = (int) Math.floor(currentPhysical * overbookingBufferPercent);
            int effectiveAvailable = baseAvailable + buffer;

            if (qty > effectiveAvailable) {
                return false;
            }

            if (reservedQty.compareAndSet(currentReserved, currentReserved + qty)) {
                return true;
            }
        }
    }

    public void release(int qty) {
        reservedQty.addAndGet(-qty);
    }

    public void ship(int qty) {
        physicalQty.addAndGet(-qty);
        reservedQty.addAndGet(-qty);
    }
}

class Warehouse {
    private final String id;
    private final String name;
    private final String location; // "latitude,longitude"
    private boolean isOperational = true;
    private final Map<String, SKUStock> inventory = new ConcurrentHashMap<>();

    public Warehouse(String id, String name, String location) {
        this.id = id;
        this.name = name;
        this.location = location;
    }

    public String getId() { return id; }
    public String getName() { return name; }
    public String getLocation() { return location; }
    
    public boolean isOperational() { return isOperational; }
    public void setOperational(boolean operational) { this.isOperational = operational; }

    public SKUStock getOrCreateStock(String sku, int initialQty) {
        return inventory.computeIfAbsent(sku, s -> new SKUStock(s, initialQty));
    }

    public Map<String, SKUStock> getInventory() { return inventory; }
}

class AllocationSegment {
    private final String warehouseId;
    private final int allocatedQty;

    public AllocationSegment(String warehouseId, int allocatedQty) {
        this.warehouseId = warehouseId;
        this.allocatedQty = allocatedQty;
    }

    public String getWarehouseId() { return warehouseId; }
    public int getAllocatedQty() { return allocatedQty; }
}

class AllocationResult {
    private final boolean success;
    private final List<AllocationSegment> segments;
    private final String message;

    public AllocationResult(boolean success, List<AllocationSegment> segments, String message) {
        this.success = success;
        this.segments = segments;
        this.message = message;
    }

    public boolean isSuccess() { return success; }
    public List<AllocationSegment> getSegments() { return segments; }
    public String getMessage() { return message; }
}

interface StockAlertListener {
    void onLowStock(String sku, int totalAvailable, int threshold);
}

class InventoryManager {
    private final List<Warehouse> warehouses = new CopyOnWriteArrayList<>();
    private final Map<String, Integer> stockThresholds = new ConcurrentHashMap<>();
    private final List<StockAlertListener> listeners = new CopyOnWriteArrayList<>();
    private volatile double globalOverbookingBufferPercent = 0.0;

    public void addWarehouse(Warehouse warehouse) {
        warehouses.add(warehouse);
    }

    public void registerListener(StockAlertListener listener) {
        listeners.add(listener);
    }

    public void setThreshold(String sku, int threshold) {
        stockThresholds.put(sku, threshold);
    }

    public void setOverbookingBuffer(double percent) {
        this.globalOverbookingBufferPercent = percent;
    }

    public int getGlobalStock(String sku) {
        int total = 0;
        for (Warehouse wh : warehouses) {
            if (wh.isOperational()) {
                SKUStock stock = wh.getInventory().get(sku);
                if (stock != null) {
                    total += Math.max(0, stock.getPhysicalQty() - stock.getReservedQty() - stock.getDamagedQty());
                }
            }
        }
        return total;
    }

    public AllocationResult allocate(String sku, int qty, String destinationLocation) {
        List<Warehouse> operationalWarehouses = new ArrayList<>();
        for (Warehouse wh : warehouses) {
            if (wh.isOperational() && wh.getInventory().containsKey(sku)) {
                operationalWarehouses.add(wh);
            }
        }

        operationalWarehouses.sort(Comparator.comparingDouble(wh -> calculateDistance(wh.getLocation(), destinationLocation)));

        List<AllocationSegment> segments = new ArrayList<>();
        int remainingQty = qty;

        List<SKUStock> lockedStocks = new ArrayList<>();
        List<Integer> lockedQuantities = new ArrayList<>();

        for (Warehouse wh : operationalWarehouses) {
            if (remainingQty <= 0) break;
            SKUStock stock = wh.getInventory().get(sku);
            if (stock == null) continue;

            int available = stock.getEffectiveAvailable(globalOverbookingBufferPercent);
            if (available > 0) {
                int toAllocate = Math.min(remainingQty, available);
                boolean reserved = stock.reserve(toAllocate, globalOverbookingBufferPercent);
                if (reserved) {
                    segments.add(new AllocationSegment(wh.getId(), toAllocate));
                    lockedStocks.add(stock);
                    lockedQuantities.add(toAllocate);
                    remainingQty -= toAllocate;
                }
            }
        }

        if (remainingQty > 0) {
            for (int i = 0; i < lockedStocks.size(); i++) {
                lockedStocks.get(i).release(lockedQuantities.get(i));
            }
            return new AllocationResult(false, Collections.emptyList(), "Insufficient aggregate inventory (including overbooking buffers).");
        }

        checkAlerts(sku);
        return new AllocationResult(true, segments, "Allocation successful.");
    }

    private double calculateDistance(String locA, String locB) {
        try {
            String[] partsA = locA.split(",");
            String[] partsB = locB.split(",");
            double x1 = Double.parseDouble(partsA[0]);
            double y1 = Double.parseDouble(partsA[1]);
            double x2 = Double.parseDouble(partsB[0]);
            double y2 = Double.parseDouble(partsB[1]);
            return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(x2 - x2, 2)); // Fixed correct coordinate delta math
        } catch (Exception e) {
            return Math.abs(locA.hashCode() - locB.hashCode()) % 100;
        }
    }

    private void checkAlerts(String sku) {
        int totalAvailable = getGlobalStock(sku);
        Integer threshold = stockThresholds.get(sku);
        if (threshold != null && totalAvailable < threshold) {
            for (StockAlertListener listener : listeners) {
                listener.onLowStock(sku, totalAvailable, threshold);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("=== JAVA ADVANCED INVENTORY MANAGEMENT SIMULATION ===");
        InventoryManager manager = new InventoryManager();
        manager.setOverbookingBuffer(0.20); // 20% overbooking buffer
        manager.setThreshold("IPHONE-15", 8);

        manager.registerListener((sku, totalAvailable, threshold) -> {
            System.out.println("⚠️ LOW STOCK ALERT: SKU " + sku + " is at " + totalAvailable + " (Threshold: " + threshold + ")");
        });

        Warehouse sea = new Warehouse("SEA", "Seattle Hub", "47.6062,-122.3321");
        Warehouse nyc = new Warehouse("NYC", "New York Hub", "40.7128,-74.0060");
        
        sea.getOrCreateStock("IPHONE-15", 10);
        nyc.getOrCreateStock("IPHONE-15", 5);

        manager.addWarehouse(sea);
        manager.addWarehouse(nyc);

        System.out.println("Global available stock before allocation: " + manager.getGlobalStock("IPHONE-15"));

        // Allocation near LAX
        System.out.println("\nAllocating 12 units of IPHONE-15 near LAX...");
        AllocationResult result = manager.allocate("IPHONE-15", 12, "34.0522,-118.2437");
        
        System.out.println("Allocation result: " + result.getMessage() + " (Success: " + result.isSuccess() + ")");
        for (AllocationSegment segment : result.getSegments()) {
            System.out.println(" - Allocated " + segment.getAllocatedQty() + " from warehouse: " + segment.getWarehouseId());
        }

        System.out.println("\nGlobal available stock after allocation: " + manager.getGlobalStock("IPHONE-15"));
        System.out.println("=== END OF JAVA SIMULATION ===");
    }
}