Flyweight

// Flyweight — stores INTRINSIC state (shared, immutable)
public class TreeType {
    private final String name;    // intrinsic
    private final String color;   // intrinsic
    private final String texture; // intrinsic (large data!)

    public TreeType(String name, String color, String texture) {
        this.name=name; this.color=color; this.texture=texture;
    }

    // Extrinsic state (x, y) passed in at call time — NOT stored here
    public void draw(int x, int y) {
        System.out.printf("Drawing %s tree [%s] at (%d,%d)%n", name, color, x, y);
    }
}

// FlyweightFactory — cache of shared TreeType instances
public class TreeFactory {
    private static final Map<String, TreeType> cache = new HashMap<>();

    public static TreeType getTreeType(String name, String color, String tex) {
        String key = name + "_" + color;
        return cache.computeIfAbsent(key, k -> {
            System.out.println("Creating new TreeType: " + key);
            return new TreeType(name, color, tex); // expensive creation once
        });
    }

    public static int getCacheSize() { return cache.size(); }
}

// Context — stores EXTRINSIC state (unique per tree instance)
public class Tree {
    private final int x, y;           // extrinsic — unique per tree
    private final TreeType type;     // reference to shared flyweight

    public Tree(int x, int y, TreeType type) {
        this.x=x; this.y=y; this.type=type;
    }

    public void draw() {
        type.draw(x, y); // passes extrinsic state to flyweight
    }
}

// Forest — creates 10,000 trees using only 2 TreeType objects
public class Forest {
    private final List<Tree> trees = new ArrayList<>();

    public void plantTree(int x, int y, String name, String color, String tex) {
        TreeType type = TreeFactory.getTreeType(name, color, tex);
        trees.add(new Tree(x, y, type)); // Tree is tiny — just x,y + reference
    }

    public void draw() { trees.forEach(Tree::draw); }
}

// Client
public class Main {
    public static void main(String[] args) {
        Forest forest = new Forest();

        for (int i = 0; i < 5000; i++)
            forest.plantTree(i*2, i*3, "Oak", "Green", "oak_texture");

        for (int i = 0; i < 5000; i++)
            forest.plantTree(i*4, i*5, "Pine", "DarkGreen", "pine_texture");

        System.out.println("TreeType objects in cache: " + TreeFactory.getCacheSize());
        // Output: TreeType objects in cache: 2  (not 10,000!)

        forest.draw(); // all 10,000 trees rendered
    }
}

// ❌ BREAKING — mutable intrinsic state in flyweight
public class BrokenTreeType {
    public String color; // ❌ mutable! One context changes it, all see the change
    public void setColor(String c) { this.color = c; } // ❌ NEVER do this
}
// Thread A: treeType.setColor("Red")  → all trees using this type turn red

// ✅ FIX — all intrinsic fields final, no setters
public class TreeType {
    private final String name;
    private final String color;   // ✅ final — never changes after creation
    private final String texture; // ✅ final
    // No setters
}

// ❌ BREAKING — storing extrinsic state in flyweight
public class BrokenTreeType {
    private int x, y; // ❌ extrinsic! Shared by all — overwrites per request
    public void draw() { /* uses this.x, this.y */ } // ❌ race condition
}

// ✅ FIX — extrinsic state passed as parameters, never stored
public void draw(int x, int y) { // ✅ x,y are parameters, not fields
    System.out.printf("Drawing %s at (%d,%d)%n", name, x, y);
}

// ❌ BREAKING — non-thread-safe factory
public static TreeType getTreeType(String key) {
    if (!cache.containsKey(key)) {      // ❌ check-then-act race condition
        cache.put(key, new TreeType(key)); // two threads create duplicates
    }
    return cache.get(key);
}

// ✅ FIX — atomic computeIfAbsent on ConcurrentHashMap
private static final ConcurrentHashMap<String, TreeType> cache
    = new ConcurrentHashMap<>();

public static TreeType getTreeType(String name, String color, String tex) {
    return cache.computeIfAbsent(name + "_" + color,
        k -> new TreeType(name, color, tex)); // ✅ atomic — thread-safe
}