import java.time.Clock;
import java.time.Instant;
import java.util.*;

public class LoginDemo {
    enum Method { PASSWORD, COMPANY_SSO }

    record LoginRequest(Method method, String proof) {
        LoginRequest {
            Objects.requireNonNull(method);
            Objects.requireNonNull(proof);
        }
        @Override public String toString() {
            return "LoginRequest[method=" + method + ", proof=REDACTED]";
        }
    }

    record IdentityKey(String issuer, String subject) {
        IdentityKey {
            Objects.requireNonNull(issuer);
            Objects.requireNonNull(subject);
            if (issuer.isBlank() || subject.isBlank()) {
                throw new IllegalArgumentException("Identity key is required");
            }
        }
    }

    record VerifiedIdentity(IdentityKey key) {
        VerifiedIdentity { Objects.requireNonNull(key); }
    }
    record Account(String id, String alertEmail, boolean enabled) {
        Account {
            Objects.requireNonNull(id);
            Objects.requireNonNull(alertEmail);
            if (id.isBlank() || alertEmail.isBlank()) {
                throw new IllegalArgumentException("Account data is required");
            }
        }
        boolean canSignIn() { return enabled; }
    }
    record LoginRecord(String id, String accountId, Method method, Instant at) {}
    record LoginAlert(String eventId, String recipient, String message) {}

    static final class LoginRejected extends RuntimeException {
        LoginRejected() { super("Unable to sign in"); }
    }
    static final class StorageFailure extends RuntimeException {
        StorageFailure() { super("Login persistence unavailable"); }
    }

    interface IdentityVerifier {
        // Supported valid proof -> verified identity.
        // Invalid or unsupported proof -> LoginRejected.
        // Infrastructure failure must never become success.
        VerifiedIdentity verify(LoginRequest request);
    }
    interface AccountLookup {
        Optional<Account> find(IdentityKey key);
    }
    interface LoginWriter {
        // Save record and alert intent together, or report failure.
        // No external email call here. Return does NOT create a web session.
        void save(LoginRecord record, LoginAlert alert);
    }

    static final class LoginPolicy {
        void check(Account account) {
            if (!account.canSignIn()) {
                throw new LoginRejected();
            }
        }
    }

    static final class LoginService {
        private final IdentityVerifier verifier;
        private final AccountLookup accounts;
        private final LoginPolicy policy;
        private final LoginWriter writer;
        private final Clock clock;

        LoginService(IdentityVerifier verifier, AccountLookup accounts,
                     LoginPolicy policy, LoginWriter writer, Clock clock) {
            this.verifier = Objects.requireNonNull(verifier);
            this.accounts = Objects.requireNonNull(accounts);
            this.policy = Objects.requireNonNull(policy);
            this.writer = Objects.requireNonNull(writer);
            this.clock = Objects.requireNonNull(clock);
        }

        LoginRecord login(LoginRequest request) {
            VerifiedIdentity identity = verifier.verify(request);
            Account account = accounts.find(identity.key())
                    .orElseThrow(LoginRejected::new);
            policy.check(account);
            LoginRecord record = new LoginRecord(UUID.randomUUID().toString(),
                    account.id(), request.method(), clock.instant());
            LoginAlert alert = new LoginAlert(record.id(), account.alertEmail(),
                    "A new sign-in was accepted for your account.");
            writer.save(record, alert);
            return record; // Framework session establishment is outside this demo.
        }
    }

    // TEST FIXTURE ONLY. This is NOT password or OIDC verification.
    // The labels below represent outcomes supplied by a trusted test harness.
    static final class FixtureVerifier implements IdentityVerifier {
        private final Map<Method, Map<String, IdentityKey>> accepted;
        FixtureVerifier(Map<Method, Map<String, IdentityKey>> accepted) {
            Map<Method, Map<String, IdentityKey>> copy = new EnumMap<>(Method.class);
            accepted.forEach((method, proofs) -> copy.put(method, Map.copyOf(proofs)));
            this.accepted = Map.copyOf(copy);
        }
        @Override public VerifiedIdentity verify(LoginRequest request) {
            IdentityKey key = accepted.getOrDefault(request.method(), Map.of())
                    .get(request.proof());
            if (key == null) throw new LoginRejected();
            return new VerifiedIdentity(key);
        }
    }

    // Learning adapter only: atomic visibility for sequential workflow tests.
    // Not durable, not a browser session store, and not an email worker.
    static final class InMemoryLoginWriter implements LoginWriter {
        private final Map<String, LoginRecord> records = new HashMap<>();
        private final Map<String, LoginAlert> pending = new HashMap<>();
        @Override public synchronized void save(LoginRecord record, LoginAlert alert) {
            if (!record.id().equals(alert.eventId())) {
                throw new IllegalArgumentException("Record and alert IDs must match");
            }
            if (records.containsKey(record.id())) {
                throw new IllegalStateException("Duplicate login record");
            }
            records.put(record.id(), record);
            pending.put(alert.eventId(), alert);
        }
        synchronized int recordsCount() { return records.size(); }
        synchronized int alertsCount() { return pending.size(); }
    }

    static final class UnsafeVerifier implements IdentityVerifier {
        private final IdentityKey identity;
        UnsafeVerifier(IdentityKey identity) { this.identity = identity; }
        @Override public VerifiedIdentity verify(LoginRequest request) {
            return new VerifiedIdentity(identity); // Deliberate contract violation.
        }
    }

    static void requireRejected(IdentityVerifier verifier, LoginRequest invalid) {
        try {
            verifier.verify(invalid);
        } catch (LoginRejected expected) {
            return;
        }
        throw new AssertionError("Invalid proof was accepted");
    }

    public static void main(String[] args) {
        IdentityKey local = new IdentityKey("local", "user-42");
        IdentityKey company = new IdentityKey("https://identity.example", "employee-7");
        FixtureVerifier verifier = new FixtureVerifier(Map.of(
                Method.PASSWORD, Map.of("VALID_PASSWORD_FIXTURE", local),
                Method.COMPANY_SSO, Map.of("VALID_SSO_FIXTURE", company)));
        Map<IdentityKey, Account> linked = Map.of(
                local, new Account("account-42", "reader@example.com", true),
                company, new Account("account-7", "staff@example.com", false));
        InMemoryLoginWriter writer = new InMemoryLoginWriter();
        LoginService service = new LoginService(verifier,
                key -> Optional.ofNullable(linked.get(key)),
                new LoginPolicy(), writer, Clock.systemUTC());

        LoginRecord record = service.login(
                new LoginRequest(Method.PASSWORD, "VALID_PASSWORD_FIXTURE"));
        System.out.println("Accepted account: " + record.accountId());
        try {
            service.login(new LoginRequest(Method.PASSWORD, "INVALID_FIXTURE"));
        } catch (LoginRejected expected) {
            System.out.println("Invalid proof: rejected");
        }
        try {
            service.login(new LoginRequest(Method.COMPANY_SSO, "VALID_SSO_FIXTURE"));
        } catch (LoginRejected expected) {
            System.out.println("Disabled account: rejected");
        }
        System.out.println("Saved login records: " + writer.recordsCount());
        System.out.println("Pending alerts: " + writer.alertsCount());

        requireRejected(verifier,
                new LoginRequest(Method.PASSWORD, "INVALID_FIXTURE"));
        System.out.println("Good verifier: rejection contract passed");
        try {
            requireRejected(new UnsafeVerifier(local),
                    new LoginRequest(Method.PASSWORD, "INVALID_FIXTURE"));
        } catch (AssertionError expected) {
            System.out.println("Unsafe verifier: " + expected.getMessage());
        }
    }
}
