InventoryTracker.java

import java.util.Scanner;
import java.util.ArrayList;
import java.util.HashMap;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

// Tracks inventory for a single user with analytics and food tracking
// Each user gets their own instance upon login
public class InventoryTracker {
    private ArrayList<Asset> assets;

    // Represents a single inventory item with timestamps and metadata
    static class Asset {
        String id;
        String name;
        String category;
        int quantity;
        String status;
        LocalDateTime dateAdded;
        String foodSubcategory;
        String expirationDate;

        Asset(String id, String name, String category, int quantity) {
            this.id = id;
            this.name = name;
            this.category = category;
            this.quantity = quantity;
            this.status = "active";
            this.dateAdded = LocalDateTime.now();
            this.foodSubcategory = null;
            this.expirationDate = null;
        }

        // Custom toString for nice formatting when printing
        public String toString() {
            StringBuilder result = new StringBuilder();
            result.append(String.format("[%s] %s | Category: %s | Qty: %d | Status: %s | Added: %s",
                id, name, category, quantity, status,
                dateAdded.format(DateTimeFormatter.ofPattern("MMM dd, yyyy HH:mm"))));

            if (foodSubcategory != null) {
                result.append(String.format(" | Food Type: %s", foodSubcategory));
            }
            if (expirationDate != null) {
                result.append(String.format(" | Expires: %s", expirationDate));
            }
            return result.toString();
        }
    }

    public InventoryTracker() {
        assets = new ArrayList<>();
    }

    // Add asset to current user's inventory with food-specific options
    // If asset already exists with same name and category, increment quantity instead
    public void addAsset(Scanner scanner) {
        System.out.print("  Asset ID: ");
        String id = scanner.nextLine().trim();
        System.out.print("  Asset Name: ");
        String name = scanner.nextLine().trim();
        System.out.print("  Category (hardware/software/food/other): ");
        String category = scanner.nextLine().trim();
        System.out.print("  Quantity: ");
        int qty = Integer.parseInt(scanner.nextLine().trim());

        // Check if asset with same name and category already exists
        for (Asset existingAsset : assets) {
            if (existingAsset.name.equalsIgnoreCase(name) &&
                existingAsset.category.equalsIgnoreCase(category)) {
                // Asset exists, increment quantity
                existingAsset.quantity += qty;
                System.out.println("  [SUCCESS] Quantity updated! Total: " + existingAsset.quantity);
                return;
            }
        }

        // Asset doesn't exist, create new one
        Asset asset = new Asset(id, name, category, qty);

        // If food, ask for subcategory and expiration
        if (category.equalsIgnoreCase("food")) {
            System.out.print("  Food Type (packaged/produce): ");
            asset.foodSubcategory = scanner.nextLine().trim();
            System.out.print("  Expiration Date (MM/DD/YYYY): ");
            asset.expirationDate = scanner.nextLine().trim();
        }

        assets.add(asset);
        System.out.println("  [SUCCESS] Asset added!");
    }

    // Display all assets with nice formatting
    public void viewAssets() {
        if (assets.isEmpty()) {
            System.out.println("  No assets in inventory.");
            return;
        }

        System.out.println("\n  === Your Assets ===");
        for (Asset asset : assets) {
            System.out.println("  " + asset);
        }
    }

    // Find asset by ID and update quantity
    public void updateAssetQty(Scanner scanner) {
        if (assets.isEmpty()) {
            System.out.println("  No assets to update.");
            return;
        }

        System.out.print("  Asset ID to update: ");
        String id = scanner.nextLine().trim();

        // Linear search through ArrayList to find matching ID
        for (Asset asset : assets) {
            if (asset.id.equals(id)) {
                System.out.print("  New quantity: ");
                int newQty = Integer.parseInt(scanner.nextLine().trim());
                asset.quantity = newQty;
                System.out.println("  [SUCCESS] Asset updated!");
                return;
            }
        }
        System.out.println("  [ERROR] Asset not found!");
    }

    // Edit asset details by ID - allows changing name, category, and food metadata
    public void editAsset(Scanner scanner) {
        if (assets.isEmpty()) {
            System.out.println("  No assets to edit.");
            return;
        }

        System.out.print("  Asset ID to edit: ");
        String id = scanner.nextLine().trim();

        // Find asset by ID
        for (Asset asset : assets) {
            if (asset.id.equals(id)) {
                System.out.println("  Current Asset: " + asset);
                System.out.println("\n  What would you like to edit?");
                System.out.println("    1. Name");
                System.out.println("    2. Category");
                System.out.println("    3. Food Type (if food)");
                System.out.println("    4. Expiration Date (if food)");
                System.out.println("    5. Back");
                System.out.print("  Choose: ");

                String choice = scanner.nextLine().trim();

                switch (choice) {
                    case "1":
                        System.out.print("  New name: ");
                        asset.name = scanner.nextLine().trim();
                        System.out.println("  [SUCCESS] Name updated!");
                        break;

                    case "2":
                        System.out.print("  New category: ");
                        String newCategory = scanner.nextLine().trim();
                        asset.category = newCategory;
                        if (!newCategory.equalsIgnoreCase("food")) {
                            asset.foodSubcategory = null;
                            asset.expirationDate = null;
                        }
                        System.out.println("  [SUCCESS] Category updated!");
                        break;

                    case "3":
                        if (asset.category.equalsIgnoreCase("food")) {
                            System.out.print("  New food type (packaged/produce): ");
                            asset.foodSubcategory = scanner.nextLine().trim();
                            System.out.println("  [SUCCESS] Food type updated!");
                        } else {
                            System.out.println("  [ERROR] This asset is not food!");
                        }
                        break;

                    case "4":
                        if (asset.category.equalsIgnoreCase("food")) {
                            System.out.print("  New expiration date (MM/DD/YYYY): ");
                            asset.expirationDate = scanner.nextLine().trim();
                            System.out.println("  [SUCCESS] Expiration date updated!");
                        } else {
                            System.out.println("  [ERROR] This asset is not food!");
                        }
                        break;

                    case "5":
                        break;

                    default:
                        System.out.println("  [ERROR] Invalid option!");
                }
                return;
            }
        }
        System.out.println("  [ERROR] Asset not found!");
    }

    // Bubble sort implementation for custom sorting
    private void bubbleSort(ArrayList<Asset> list, int sortType) {
        int n = list.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                Asset current = list.get(j);
                Asset next = list.get(j + 1);
                boolean shouldSwap = false;

                if (sortType == 1) {
                    // Sort by name (A-Z)
                    shouldSwap = current.name.compareToIgnoreCase(next.name) > 0;
                } else if (sortType == 2) {
                    // Sort by quantity (High to Low)
                    shouldSwap = current.quantity < next.quantity;
                } else if (sortType == 3) {
                    // Sort by category
                    shouldSwap = current.category.compareToIgnoreCase(next.category) > 0;
                } else if (sortType == 4) {
                    // Sort by date (Newest First)
                    shouldSwap = current.dateAdded.isBefore(next.dateAdded);
                }

                if (shouldSwap) {
                    Asset temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }
    }

    // Sort assets by different parameters and display
    public void sortAndView(Scanner scanner) {
        if (assets.isEmpty()) {
            System.out.println("  No assets to sort.");
            return;
        }

        System.out.println("\n  === Sort Options ===");
        System.out.println("    1. By Name (A-Z)");
        System.out.println("    2. By Quantity (High to Low)");
        System.out.println("    3. By Category");
        System.out.println("    4. By Date Added (Newest First)");
        System.out.println("    5. Back");
        System.out.print("  Choose: ");

        String choice = scanner.nextLine().trim();

        // Create copy of assets list to sort (don't modify original order)
        ArrayList<Asset> sortedAssets = new ArrayList<>(assets);

        switch (choice) {
            case "1":
                bubbleSort(sortedAssets, 1);
                System.out.println("\n  === Assets (Sorted by Name) ===");
                break;

            case "2":
                bubbleSort(sortedAssets, 2);
                System.out.println("\n  === Assets (Sorted by Quantity) ===");
                break;

            case "3":
                bubbleSort(sortedAssets, 3);
                System.out.println("\n  === Assets (Sorted by Category) ===");
                break;

            case "4":
                bubbleSort(sortedAssets, 4);
                System.out.println("\n  === Assets (Sorted by Date Added - Newest First) ===");
                break;

            case "5":
                return;

            default:
                System.out.println("  [ERROR] Invalid option!");
                return;
        }

        // Display sorted assets
        for (Asset asset : sortedAssets) {
            System.out.println("  " + asset);
        }
    }

    // Show comprehensive stats including category breakdown and purchase frequency
    public void showStats() {
        int totalAssets = assets.size();
        int totalItems = 0;
        HashMap<String, Integer> categoryCount = new HashMap<>();

        // Count items by category
        for (Asset asset : assets) {
            totalItems += asset.quantity;
            String cat = asset.category.toLowerCase();
            categoryCount.put(cat, categoryCount.getOrDefault(cat, 0) + 1);
        }

        System.out.println("\n  === Inventory Stats ===");
        System.out.println("  Total Asset Types: " + totalAssets);
        System.out.println("  Total Items: " + totalItems);

        System.out.println("\n  === Items by Category ===");
        String mostBought = null;
        int maxCount = 0;
        for (String category : categoryCount.keySet()) {
            int count = categoryCount.get(category);
            System.out.println("  " + category + ": " + count + " items");
            if (count > maxCount) {
                maxCount = count;
                mostBought = category;
            }
        }

        if (mostBought != null) {
            System.out.println("\n  === Most Purchased Category ===");
            System.out.println("  " + mostBought + " (" + maxCount + " items)");
        }

        // Food-specific analytics
        int foodCount = 0;
        int packagedCount = 0;
        int produceCount = 0;
        for (Asset asset : assets) {
            if (asset.category.equalsIgnoreCase("food")) {
                foodCount++;
                if (asset.foodSubcategory != null) {
                    if (asset.foodSubcategory.equalsIgnoreCase("packaged")) {
                        packagedCount++;
                    } else if (asset.foodSubcategory.equalsIgnoreCase("produce")) {
                        produceCount++;
                    }
                }
            }
        }

        if (foodCount > 0) {
            System.out.println("\n  === Food Analytics ===");
            System.out.println("  Total Food Items: " + foodCount);
            if (packagedCount > 0) {
                System.out.println("  Packaged Food: " + packagedCount);
            }
            if (produceCount > 0) {
                System.out.println("  Produce: " + produceCount);
            }
        }
    }
}