package unit;

import java.util.*;

/**
 * django-0005: alt_constraints_name list → set
 * django-0006: remove_from_added / remove_from_removed lists → sets
 *
 * Models Django MigrationAutodetector.create_altered_constraints() and
 * create_altered_indexes() where a plain list is built during a double loop
 * and then searched with linear scans in filter comprehensions.
 *
 * Standalone Java — no JUnit required.
 */
public class AltConstraintsAlgorithm {

    // -----------------------------------------------------------------------
    // Simulated constraint / index model objects
    // -----------------------------------------------------------------------
    static class Constraint {
        final String name;
        final String definition;
        Constraint(String name, String definition) {
            this.name = name;
            this.definition = definition;
        }
        @Override public boolean equals(Object o) {
            if (!(o instanceof Constraint)) return false;
            Constraint c = (Constraint) o;
            return name.equals(c.name) && definition.equals(c.definition);
        }
        @Override public int hashCode() { return Objects.hash(name, definition); }
    }

    // -----------------------------------------------------------------------
    // SLOW: alt_constraints_name as plain List (django-0005)
    // -----------------------------------------------------------------------
    static Result slowAltConstraints(List<Constraint> oldConstraints,
                                     List<Constraint> newConstraints) {
        List<Constraint> altConstraints = new ArrayList<>();
        List<String> altConstraintsName = new ArrayList<>();   // ← plain list

        for (Constraint oldC : oldConstraints) {
            for (Constraint newC : newConstraints) {
                if (!oldC.definition.equals(newC.definition)
                        && oldC.name.equals(newC.name)) {
                    altConstraints.add(newC);
                    altConstraintsName.add(newC.name);          // ← append
                }
            }
        }

        List<Constraint> addConstraints = new ArrayList<>();
        for (Constraint c : newConstraints) {
            if (!oldConstraints.contains(c) && !altConstraintsName.contains(c.name)) { // ← O(N)
                addConstraints.add(c);
            }
        }
        List<Constraint> remConstraints = new ArrayList<>();
        for (Constraint c : oldConstraints) {
            if (!newConstraints.contains(c) && !altConstraintsName.contains(c.name)) { // ← O(N)
                remConstraints.add(c);
            }
        }
        return new Result(addConstraints, remConstraints, altConstraints);
    }

    // -----------------------------------------------------------------------
    // FAST: alt_constraints_name as HashSet (django-0005 fix)
    // -----------------------------------------------------------------------
    static Result fastAltConstraints(List<Constraint> oldConstraints,
                                     List<Constraint> newConstraints) {
        List<Constraint> altConstraints = new ArrayList<>();
        Set<String> altConstraintsName = new HashSet<>();       // ← set

        for (Constraint oldC : oldConstraints) {
            for (Constraint newC : newConstraints) {
                if (!oldC.definition.equals(newC.definition)
                        && oldC.name.equals(newC.name)) {
                    altConstraints.add(newC);
                    altConstraintsName.add(newC.name);           // ← O(1)
                }
            }
        }

        List<Constraint> addConstraints = new ArrayList<>();
        for (Constraint c : newConstraints) {
            if (!oldConstraints.contains(c) && !altConstraintsName.contains(c.name)) { // ← O(1)
                addConstraints.add(c);
            }
        }
        List<Constraint> remConstraints = new ArrayList<>();
        for (Constraint c : oldConstraints) {
            if (!newConstraints.contains(c) && !altConstraintsName.contains(c.name)) { // ← O(1)
                remConstraints.add(c);
            }
        }
        return new Result(addConstraints, remConstraints, altConstraints);
    }

    // -----------------------------------------------------------------------
    // SLOW: remove_from_added / remove_from_removed as Lists (django-0006)
    // -----------------------------------------------------------------------
    static long slowRemoveFromAdded(List<Constraint> addedIndexes,
                                    List<Constraint> removedIndexes) {
        List<Constraint> removeFromAdded = new ArrayList<>();    // ← plain list
        List<Constraint> removeFromRemoved = new ArrayList<>();  // ← plain list

        for (Constraint newIdx : addedIndexes) {
            for (Constraint oldIdx : removedIndexes) {
                // same fields, different name = rename
                if (newIdx.definition.equals(oldIdx.definition)
                        && !newIdx.name.equals(oldIdx.name)) {
                    removeFromAdded.add(newIdx);
                    removeFromRemoved.add(oldIdx);
                }
            }
        }

        List<Constraint> finalAdded = new ArrayList<>();
        for (Constraint idx : addedIndexes) {
            if (!removeFromAdded.contains(idx)) finalAdded.add(idx); // ← O(R)
        }
        List<Constraint> finalRemoved = new ArrayList<>();
        for (Constraint idx : removedIndexes) {
            if (!removeFromRemoved.contains(idx)) finalRemoved.add(idx); // ← O(R)
        }
        return finalAdded.size() + finalRemoved.size();
    }

    // -----------------------------------------------------------------------
    // FAST: remove_from_added / remove_from_removed as HashSets (django-0006 fix)
    // -----------------------------------------------------------------------
    static long fastRemoveFromAdded(List<Constraint> addedIndexes,
                                    List<Constraint> removedIndexes) {
        Set<Constraint> removeFromAdded = new HashSet<>();       // ← set
        Set<Constraint> removeFromRemoved = new HashSet<>();     // ← set

        for (Constraint newIdx : addedIndexes) {
            for (Constraint oldIdx : removedIndexes) {
                if (newIdx.definition.equals(oldIdx.definition)
                        && !newIdx.name.equals(oldIdx.name)) {
                    removeFromAdded.add(newIdx);
                    removeFromRemoved.add(oldIdx);
                }
            }
        }

        List<Constraint> finalAdded = new ArrayList<>();
        for (Constraint idx : addedIndexes) {
            if (!removeFromAdded.contains(idx)) finalAdded.add(idx); // ← O(1)
        }
        List<Constraint> finalRemoved = new ArrayList<>();
        for (Constraint idx : removedIndexes) {
            if (!removeFromRemoved.contains(idx)) finalRemoved.add(idx); // ← O(1)
        }
        return finalAdded.size() + finalRemoved.size();
    }

    // -----------------------------------------------------------------------
    // Result container
    // -----------------------------------------------------------------------
    static class Result {
        final List<Constraint> added;
        final List<Constraint> removed;
        final List<Constraint> altered;
        Result(List<Constraint> added, List<Constraint> removed, List<Constraint> altered) {
            this.added = added; this.removed = removed; this.altered = altered;
        }
    }

    // -----------------------------------------------------------------------
    // Test helpers
    // -----------------------------------------------------------------------
    static List<Constraint> makeConstraints(int n, String prefix) {
        List<Constraint> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(new Constraint(prefix + "_c" + i, "def_" + i));
        }
        return list;
    }

    // -----------------------------------------------------------------------
    // Main
    // -----------------------------------------------------------------------
    public static void main(String[] args) {
        int passed = 0;
        int total = 0;

        // ---- Correctness: django-0005 (alt_constraints_name) ----
        {
            List<Constraint> oldC = Arrays.asList(
                new Constraint("uq_a", "def_a"),
                new Constraint("uq_b", "def_b"),
                new Constraint("uq_c", "def_c")
            );
            List<Constraint> newC = Arrays.asList(
                new Constraint("uq_a", "def_a_modified"),  // altered
                new Constraint("uq_b", "def_b"),           // unchanged
                new Constraint("uq_d", "def_d")            // added
            );
            Result slow = slowAltConstraints(oldC, newC);
            Result fast = fastAltConstraints(oldC, newC);

            total++;
            assert slow.altered.size() == fast.altered.size() : "altered size mismatch";
            assert slow.added.size() == fast.added.size()
                    : "added size: slow=" + slow.added.size() + " fast=" + fast.added.size();
            assert slow.removed.size() == fast.removed.size() : "removed size mismatch";
            System.out.println("PASS 1/5: correctness django-0005 (alt_constraints_name)");
            passed++;
        }

        // ---- Correctness: django-0006 (remove_from_added) ----
        {
            List<Constraint> added = Arrays.asList(
                new Constraint("idx_new_name", "fields_x_y"),   // rename candidate
                new Constraint("idx_brand_new", "fields_z")     // genuinely added
            );
            List<Constraint> removed = Arrays.asList(
                new Constraint("idx_old_name", "fields_x_y"),   // rename candidate
                new Constraint("idx_truly_removed", "fields_w") // truly removed
            );
            long slow = slowRemoveFromAdded(added, removed);
            long fast = fastRemoveFromAdded(added, removed);

            total++;
            assert slow == fast : "remove_from_added result mismatch: slow=" + slow + " fast=" + fast;
            assert slow == 2 : "expected 2 remaining (1 added + 1 removed), got " + slow;
            System.out.println("PASS 2/5: correctness django-0006 (remove_from_added)");
            passed++;
        }

        // ---- Performance: django-0005 — isolate the filter step (list vs set membership) ----
        // Pre-build alt_constraints_name with N entries, then run the filter loop
        // over N candidates.  This isolates the O(N) scan vs O(1) hash lookup.
        {
            int N = 800;
            // alt_constraints_name has N/2 entries; candidates has N entries
            List<String> altNameList = new ArrayList<>();
            Set<String> altNameSet  = new HashSet<>();
            List<Constraint> candidates = new ArrayList<>();
            for (int i = 0; i < N/2; i++) {
                altNameList.add("alt_" + i);
                altNameSet.add("alt_" + i);
            }
            for (int i = 0; i < N; i++) {
                // every other candidate has a name in the alt set → skip half
                candidates.add(new Constraint(i % 2 == 0 ? "alt_" + (i/2) : "new_" + i, "def_" + i));
            }

            long t0 = System.nanoTime();
            for (int iter = 0; iter < 200; iter++) {
                List<Constraint> r = new ArrayList<>();
                for (Constraint c : candidates) {
                    if (!altNameList.contains(c.name)) r.add(c);  // ← O(N) scan
                }
            }
            long slowNs = (System.nanoTime() - t0) / 200;

            long t1 = System.nanoTime();
            for (int iter = 0; iter < 200; iter++) {
                List<Constraint> r = new ArrayList<>();
                for (Constraint c : candidates) {
                    if (!altNameSet.contains(c.name)) r.add(c);   // ← O(1) lookup
                }
            }
            long fastNs = (System.nanoTime() - t1) / 200;

            double ratio = (double) slowNs / fastNs;
            total++;
            System.out.printf("PERF  3/5: django-0005 N=%d slow=%dns fast=%dns ratio=%.1fx%n",
                    N, slowNs, fastNs, ratio);
            assert ratio >= 5.0 : "ratio too low: " + ratio;
            System.out.println("PASS 3/5: django-0005 ratio >= 5x");
            passed++;
        }

        // ---- Performance: django-0006 — isolate the filter step (list vs set membership) ----
        {
            int N = 800;
            List<Constraint> removeFromAddedList = new ArrayList<>();
            Set<Constraint> removeFromAddedSet  = new HashSet<>();
            List<Constraint> addedIndexes = new ArrayList<>();
            for (int i = 0; i < N/2; i++) {
                Constraint c = new Constraint("rename_" + i, "fields_" + i);
                removeFromAddedList.add(c);
                removeFromAddedSet.add(c);
            }
            for (int i = 0; i < N; i++) {
                addedIndexes.add(new Constraint(i % 2 == 0 ? "rename_" + (i/2) : "keep_" + i, "fields_" + i));
            }

            long t0 = System.nanoTime();
            for (int iter = 0; iter < 200; iter++) {
                List<Constraint> r = new ArrayList<>();
                for (Constraint idx : addedIndexes) {
                    if (!removeFromAddedList.contains(idx)) r.add(idx);  // ← O(R)
                }
            }
            long slowNs = (System.nanoTime() - t0) / 200;

            long t1 = System.nanoTime();
            for (int iter = 0; iter < 200; iter++) {
                List<Constraint> r = new ArrayList<>();
                for (Constraint idx : addedIndexes) {
                    if (!removeFromAddedSet.contains(idx)) r.add(idx);   // ← O(1)
                }
            }
            long fastNs = (System.nanoTime() - t1) / 200;

            double ratio = (double) slowNs / fastNs;
            total++;
            System.out.printf("PERF  4/5: django-0006 N=%d slow=%dns fast=%dns ratio=%.1fx%n",
                    N, slowNs, fastNs, ratio);
            assert ratio >= 5.0 : "ratio too low: " + ratio;
            System.out.println("PASS 4/5: django-0006 ratio >= 5x");
            passed++;
        }

        // ---- Edge case: empty old/new constraints ----
        {
            Result slow = slowAltConstraints(new ArrayList<>(), new ArrayList<>());
            Result fast = fastAltConstraints(new ArrayList<>(), new ArrayList<>());

            total++;
            assert slow.added.isEmpty() && fast.added.isEmpty() : "empty case added";
            assert slow.removed.isEmpty() && fast.removed.isEmpty() : "empty case removed";
            System.out.println("PASS 5/5: edge case empty constraints");
            passed++;
        }

        System.out.printf("%n%d/%d PASS%n", passed, total);
        if (passed < total) throw new AssertionError("Some tests failed");
    }
}