package com.aydinsude.workbench.claims.complexrefactoring;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Bewusst problematischer Ausgangscode der Fallstudie.
 * Er verbindet Validierung, Regeln, Persistenz, Fremdsystem, Audit und Benachrichtigung.
 */
public final class LegacyClaimProcessor {
    private final Map<String, ClaimRow> database;
    private final List<String> auditLog;
    private final List<String> messages;
    private final FraudClient fraudClient;

    public LegacyClaimProcessor(
            Map<String, ClaimRow> database,
            List<String> auditLog,
            List<String> messages,
            FraudClient fraudClient) {
        this.database = Objects.requireNonNull(database);
        this.auditLog = Objects.requireNonNull(auditLog);
        this.messages = Objects.requireNonNull(messages);
        this.fraudClient = Objects.requireNonNull(fraudClient);
    }

    public Result process(String id, String customerId, BigDecimal amount,
                          String currency, String type, boolean vip,
                          int customerYears, boolean completeDocuments) {
        if (id == null || id.isBlank()) return new Result("REJECTED", BigDecimal.ZERO, "missing id");
        if (amount == null || amount.signum() <= 0) return new Result("REJECTED", BigDecimal.ZERO, "invalid amount");
        if (!completeDocuments) return new Result("MANUAL_REVIEW", BigDecimal.ZERO, "documents incomplete");
        if (!List.of("EUR", "USD").contains(currency)) return new Result("REJECTED", BigDecimal.ZERO, "unsupported currency");

        int fraudScore;
        try {
            fraudScore = fraudClient.score(customerId, amount, type);
        } catch (RuntimeException failure) {
            auditLog.add(LocalDate.now() + " FRAUD_UNAVAILABLE " + id);
            return new Result("MANUAL_REVIEW", BigDecimal.ZERO, "fraud service unavailable");
        }

        BigDecimal deductible = BigDecimal.ZERO;
        if ("DAMAGE".equals(type)) deductible = amount.multiply(new BigDecimal("0.10"));
        else if ("LIABILITY".equals(type)) deductible = amount.multiply(new BigDecimal("0.05"));
        else if ("TRAVEL".equals(type)) deductible = new BigDecimal("75.00");

        String status;
        String reason;
        if (fraudScore > 75 && !vip && customerYears < 2 && amount.compareTo(new BigDecimal("10000")) > 0) {
            status = "MANUAL_REVIEW";
            reason = "high fraud risk";
        } else if (amount.compareTo(new BigDecimal("25000")) > 0) {
            status = "MANUAL_REVIEW";
            reason = "amount above automatic limit";
        } else {
            status = "APPROVED";
            reason = "automatic approval";
        }

        BigDecimal reserve = amount.subtract(deductible).max(BigDecimal.ZERO);
        ClaimRow row = new ClaimRow(id, customerId, amount, currency, type, status, reserve, reason);
        database.put(id, row);
        auditLog.add(LocalDate.now() + " CLAIM_PROCESSED " + id + " " + status);
        messages.add("claim." + status.toLowerCase() + ":" + id + ":" + reserve);
        return new Result(status, reserve, reason);
    }

    public interface FraudClient {
        int score(String customerId, BigDecimal amount, String type);
    }

    public record ClaimRow(String id, String customerId, BigDecimal amount,
                           String currency, String type, String status,
                           BigDecimal reserve, String reason) {}
    public record Result(String status, BigDecimal reserve, String reason) {}
}

package com.aydinsude.workbench.claims.complexrefactoring;

import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import static org.junit.jupiter.api.Assertions.*;
import static com.aydinsude.workbench.claims.complexrefactoring.ClaimCommand.*;

final class ComplexClaimRefactoringTest {
    @Test
    void golden_master_high_risk_case_remains_manual_review() {
        var legacy = new LegacyClaimProcessor(new HashMap<>(), new ArrayList<>(), new ArrayList<>(),
                (customerId, amount, type) -> 90);
        var oldResult = legacy.process("CL-4711", "CU-9", new BigDecimal("12500.00"),
                "EUR", "DAMAGE", false, 1, true);

        var command = new ClaimCommand(new ClaimId("CL-4711"), new CustomerId("CU-9"),
                new Money(new BigDecimal("12500.00"), "EUR"), ClaimType.DAMAGE, false, 1, true);
        var modern = new ClaimDecisionEngine(new DeductiblePolicy(), new ManualReviewPolicy())
                .decide(command, new FraudAssessmentPort.Assessment(90, true));

        assertEquals("MANUAL_REVIEW", oldResult.status());
        assertEquals(oldResult.status(), modern.status().name());
        assertEquals(0, oldResult.reserve().compareTo(modern.reserve().amount()));
    }

    @Test
    void unavailable_fraud_service_is_not_silently_approved() {
        var command = new ClaimCommand(new ClaimId("CL-5"), new CustomerId("CU-2"),
                new Money(new BigDecimal("900.00"), "EUR"), ClaimType.DAMAGE, true, 10, true);
        var decision = new ClaimDecisionEngine(new DeductiblePolicy(), new ManualReviewPolicy())
                .decide(command, FraudAssessmentPort.Assessment.unavailable());
        assertEquals(ClaimDecision.Status.MANUAL_REVIEW, decision.status());
    }
}

public interface FraudAssessmentPort {
    Assessment assess(ClaimCommand command);
}
public interface ClaimRepository {
    void save(ClaimCommand command, ClaimDecision decision);
}
public interface ClaimEventPort {
    void append(ClaimProcessed event);
}
public interface ClaimAuditPort {
    void record(String claimId, String action, String detail);
}

package com.aydinsude.workbench.claims.complexrefactoring;

import java.math.BigDecimal;
import java.util.Objects;

public record ClaimCommand(
        ClaimId id,
        CustomerId customerId,
        Money amount,
        ClaimType type,
        boolean vip,
        int customerYears,
        boolean completeDocuments) {

    public ClaimCommand {
        Objects.requireNonNull(id);
        Objects.requireNonNull(customerId);
        Objects.requireNonNull(amount);
        Objects.requireNonNull(type);
        if (customerYears < 0) throw new IllegalArgumentException("customerYears must not be negative");
    }

    public record ClaimId(String value) {
        public ClaimId { if (value == null || value.isBlank()) throw new IllegalArgumentException("claim id required"); }
    }
    public record CustomerId(String value) {
        public CustomerId { if (value == null || value.isBlank()) throw new IllegalArgumentException("customer id required"); }
    }
    public record Money(BigDecimal amount, String currency) {
        public Money {
            Objects.requireNonNull(amount); Objects.requireNonNull(currency);
            if (amount.signum() <= 0) throw new IllegalArgumentException("amount must be positive");
            if (!currency.equals("EUR") && !currency.equals("USD")) throw new IllegalArgumentException("unsupported currency");
        }
        public Money subtract(Money other) {
            if (!currency.equals(other.currency)) throw new IllegalArgumentException("currency mismatch");
            return new Money(amount.subtract(other.amount).max(BigDecimal.ZERO), currency);
        }
    }
    public enum ClaimType { DAMAGE, LIABILITY, TRAVEL }
}

public ClaimDecision process(ClaimCommand command) {
    var assessment = safeAssessment(command);
    var decision = engine.decide(command, assessment);
    repository.save(command, decision);
    events.append(toEvent(command, decision));
    audit.record(command.id().value(), "CLAIM_PROCESSED", decision.status().name());
    return decision;
}

package com.aydinsude.workbench.claims.complexrefactoring;

import static com.aydinsude.workbench.claims.complexrefactoring.ClaimDecision.Status.*;

/** Reine fachliche Query: keine Persistenz, keine Nachricht und kein Audit. */
public final class ClaimDecisionEngine {
    private final DeductiblePolicy deductiblePolicy;
    private final ManualReviewPolicy manualReviewPolicy;

    public ClaimDecisionEngine(DeductiblePolicy deductiblePolicy, ManualReviewPolicy manualReviewPolicy) {
        this.deductiblePolicy = deductiblePolicy;
        this.manualReviewPolicy = manualReviewPolicy;
    }

    public ClaimDecision decide(ClaimCommand command, FraudAssessmentPort.Assessment fraud) {
        var deductible = deductiblePolicy.calculate(command);
        var reserve = command.amount().subtract(deductible);
        if (manualReviewPolicy.isRequired(command, fraud)) {
            return new ClaimDecision(MANUAL_REVIEW, reserve, reviewReason(command, fraud));
        }
        return new ClaimDecision(APPROVED, reserve, "automatic approval");
    }

    private String reviewReason(ClaimCommand command, FraudAssessmentPort.Assessment fraud) {
        if (!command.completeDocuments()) return "documents incomplete";
        if (!fraud.available()) return "fraud service unavailable";
        if (fraud.score() > 75) return "high fraud risk";
        return "amount above automatic limit";
    }
}

var deductible = deductiblePolicy.calculate(command);
if (manualReviewPolicy.requiresReview(command, assessment)) {
    return ClaimDecision.manualReview(deductible.reserveFor(command.amount()), "high fraud risk");
}
return ClaimDecision.approved(deductible.reserveFor(command.amount()));

package com.aydinsude.workbench.claims.complexrefactoring;

/**
 * Design Patterns: Application Service, Ports & Adapters, Transaction Script auf Use-Case-Ebene.
 * Zweck: fachliche Entscheidung und Seiteneffekte in einer nachvollziehbaren Reihenfolge koordinieren.
 */
public final class ProcessClaimUseCase {
    private final FraudAssessmentPort fraud;
    private final ClaimDecisionEngine engine;
    private final ClaimRepository repository;
    private final ClaimEventPort events;
    private final ClaimAuditPort audit;

    public ProcessClaimUseCase(FraudAssessmentPort fraud, ClaimDecisionEngine engine,
                               ClaimRepository repository, ClaimEventPort events,
                               ClaimAuditPort audit) {
        this.fraud = fraud;
        this.engine = engine;
        this.repository = repository;
        this.events = events;
        this.audit = audit;
    }

    public ClaimDecision process(ClaimCommand command) {
        var assessment = safeAssessment(command);
        var decision = engine.decide(command, assessment);
        repository.save(command, decision);
        events.append(new ClaimEventPort.ClaimProcessed(
                command.id().value(), decision.status().name(),
                decision.reserve().amount().toPlainString(), decision.reason()));
        audit.record(command.id().value(), "CLAIM_PROCESSED", decision.status().name());
        return decision;
    }

    private FraudAssessmentPort.Assessment safeAssessment(ClaimCommand command) {
        try {
            return fraud.assess(command);
        } catch (RuntimeException failure) {
            audit.record(command.id().value(), "FRAUD_UNAVAILABLE", failure.getClass().getSimpleName());
            return FraudAssessmentPort.Assessment.unavailable();
        }
    }
}

package com.aydinsude.workbench.claims.complexrefactoring;

import java.util.Objects;

/** Design Pattern: Parallel Run / Reconciliation. Zweck: Alt- und Neupfad fachlich vergleichen. */
public final class ReconciliationService {
    public Difference compare(LegacyClaimProcessor.Result legacy, ClaimDecision modern) {
        boolean sameStatus = Objects.equals(legacy.status(), modern.status().name());
        boolean sameReserve = legacy.reserve().compareTo(modern.reserve().amount()) == 0;
        boolean sameReason = Objects.equals(legacy.reason(), modern.reason());
        return new Difference(sameStatus, sameReserve, sameReason);
    }
    public record Difference(boolean sameStatus, boolean sameReserve, boolean sameReason) {
        public boolean equivalent() { return sameStatus && sameReserve && sameReason; }
    }
}

package com.aydinsude.workbench.legacy.supportstory;

import java.time.*;
import java.util.*;

/** Problematischer Ausgangscode: Regeln, Status, SLA, Audit und Benachrichtigung sind vermischt. */
public final class LegacyTicketProcessor {
    private final List<String> database;
    private final List<String> audit;
    private final List<String> notifications;
    private final Clock clock;
    public LegacyTicketProcessor(List<String> database, List<String> audit, List<String> notifications, Clock clock) {
        this.database=database; this.audit=audit; this.notifications=notifications; this.clock=clock;
    }
    public String process(String id, String category, String tier, String message, String actorRole) {
        if(id==null || id.isBlank() || message==null || message.isBlank()) return "INVALID";
        String team="GENERAL"; int slaHours=48; String status="NEW";
        if("SECURITY".equalsIgnoreCase(category)) { team="SECURITY"; slaHours=1; }
        else if("BILLING".equalsIgnoreCase(category)) { team="BILLING"; slaHours="GOLD".equalsIgnoreCase(tier)?4:12; }
        else if("TECH".equalsIgnoreCase(category)) { team="TECHNICAL"; slaHours="GOLD".equalsIgnoreCase(tier)?2:8; }
        if("AGENT".equals(actorRole) || "SUPERVISOR".equals(actorRole)) status="ASSIGNED";
        if("SUPERVISOR".equals(actorRole) && message.toLowerCase().contains("urgent")) team="SECOND_LEVEL";
        Instant due=Instant.now(clock).plus(Duration.ofHours(slaHours));
        database.add(id+"|"+status+"|"+team+"|"+due);
        audit.add(id+"|CREATED|"+actorRole+"|"+Instant.now(clock));
        notifications.add("MAIL:"+id+":"+team);
        return status+":"+team+":"+slaHours;
    }
}

package com.aydinsude.workbench.legacy.supportstory;

import org.junit.jupiter.api.Test;
import java.time.*;
import java.util.*;
import static org.junit.jupiter.api.Assertions.*;

class CustomerSupportStoryTest {
    private static final Instant NOW=Instant.parse("2026-07-11T10:00:00Z");
    @Test void legacy_security_ticket_keeps_observed_contract(){
        var db=new ArrayList<String>(); var audit=new ArrayList<String>(); var notes=new ArrayList<String>();
        var legacy=new LegacyTicketProcessor(db,audit,notes,Clock.fixed(NOW,ZoneOffset.UTC));
        assertEquals("ASSIGNED:SECURITY:1",legacy.process("T-1","SECURITY","STANDARD","breach","AGENT"));
        assertEquals(1,db.size()); assertEquals(1,audit.size()); assertEquals("MAIL:T-1:SECURITY",notes.get(0));
    }
    @Test void modern_service_assigns_security_and_calculates_sla(){
        var saved=new ArrayList<SupportTicket>(); var audit=new ArrayList<String>(); var notes=new ArrayList<String>();
        var service=new SupportTicketService(new AssignmentPolicy(),new SlaPolicy(),saved::add,(id,a,d)->audit.add(a+":"+d),new SupportNotificationPort(){ public void assigned(TicketId id,SupportTeam t){notes.add(t.name());} public void escalated(TicketId id,int level){}},Clock.fixed(NOW,ZoneOffset.UTC));
        var result=service.open(new TicketCommand("T-1","SECURITY","STANDARD","breach"));
        assertEquals(SupportTeam.SECURITY,result.team()); assertEquals(NOW.plus(Duration.ofHours(1)),result.dueAt()); assertEquals(TicketStatus.ASSIGNED,result.status());
    }
    @Test void aggregate_rejects_invalid_transition(){
        var ticket=new SupportTicket(new TicketId("T-2"),NOW);
        assertThrows(IllegalStateException.class,ticket::resolve);
    }
}

package com.aydinsude.workbench.legacy.supportstory;

import java.time.Instant;
import java.util.Objects;

/** Aggregate Root: schützt Status und Eskalationsinvarianten. */
public final class SupportTicket {
    private final TicketId id;
    private TicketStatus status;
    private SupportTeam assignedTeam;
    private final Instant openedAt;
    private int escalationLevel;

    public SupportTicket(TicketId id, Instant openedAt) {
        this.id = Objects.requireNonNull(id);
        this.openedAt = Objects.requireNonNull(openedAt);
        this.status = TicketStatus.NEW;
        this.assignedTeam = SupportTeam.UNASSIGNED;
    }
    public void assignTo(SupportTeam team) {
        if (status == TicketStatus.CLOSED) throw new IllegalStateException("closed ticket cannot be assigned");
        assignedTeam = Objects.requireNonNull(team);
        status = TicketStatus.ASSIGNED;
    }
    public void startWork() {
        if (status != TicketStatus.ASSIGNED) throw new IllegalStateException("ticket must be assigned");
        status = TicketStatus.IN_PROGRESS;
    }
    public void resolve() {
        if (status != TicketStatus.IN_PROGRESS) throw new IllegalStateException("ticket must be in progress");
        status = TicketStatus.RESOLVED;
    }
    public void close() {
        if (status != TicketStatus.RESOLVED) throw new IllegalStateException("ticket must be resolved");
        status = TicketStatus.CLOSED;
    }
    public void escalate() { escalationLevel++; }
    public TicketId id(){ return id; }
    public TicketStatus status(){ return status; }
    public SupportTeam assignedTeam(){ return assignedTeam; }
    public Instant openedAt(){ return openedAt; }
    public int escalationLevel(){ return escalationLevel; }
}

package com.aydinsude.workbench.legacy.supportstory;

/** Policy Pattern: fachliche Team- und SLA-Entscheidung. */
public final class AssignmentPolicy {
    public AssignmentDecision decide(TicketCommand command) {
        return switch(command.category()) {
            case "SECURITY" -> new AssignmentDecision(SupportTeam.SECURITY, 1);
            case "BILLING" -> new AssignmentDecision(SupportTeam.BILLING, command.customerTier().equals("GOLD")?4:12);
            case "TECH" -> new AssignmentDecision(SupportTeam.TECHNICAL, command.customerTier().equals("GOLD")?2:8);
            default -> new AssignmentDecision(SupportTeam.SECOND_LEVEL, 24);
        };
    }
    public record AssignmentDecision(SupportTeam team, int slaHours) {}
}

package com.aydinsude.workbench.legacy.supportstory;

import java.time.*;
/** Policy Pattern: SLA-Frist und Eskalation werden unabhängig vom Workflow entschieden. */
public final class SlaPolicy {
    public Instant dueAt(Instant openedAt, int hours) { return openedAt.plus(Duration.ofHours(hours)); }
    public boolean isBreached(Instant dueAt, Instant now) { return !now.isBefore(dueAt); }
}

package com.aydinsude.workbench.legacy.supportstory;
public interface TicketRepository { void save(SupportTicket ticket); }

package com.aydinsude.workbench.legacy.supportstory;
public interface SupportAuditPort { void record(TicketId id, String action, String detail); }

package com.aydinsude.workbench.legacy.supportstory;
public interface SupportNotificationPort { void assigned(TicketId id, SupportTeam team); void escalated(TicketId id, int level); }

package com.aydinsude.workbench.legacy.supportstory;

import java.time.*;
import java.util.Objects;

/** Application Service: koordiniert Aggregate, Policies und Ports. */
public final class SupportTicketService {
    private final AssignmentPolicy assignment; private final SlaPolicy sla; private final TicketRepository repository;
    private final SupportAuditPort audit; private final SupportNotificationPort notifications; private final Clock clock;
    public SupportTicketService(AssignmentPolicy assignment, SlaPolicy sla, TicketRepository repository, SupportAuditPort audit, SupportNotificationPort notifications, Clock clock) {
        this.assignment=Objects.requireNonNull(assignment); this.sla=Objects.requireNonNull(sla); this.repository=Objects.requireNonNull(repository); this.audit=Objects.requireNonNull(audit); this.notifications=Objects.requireNonNull(notifications); this.clock=Objects.requireNonNull(clock);
    }
    public TicketResult open(TicketCommand command) {
        var openedAt=Instant.now(clock);
        var decision=assignment.decide(command);
        var ticket=new SupportTicket(new TicketId(command.ticketId()), openedAt);
        ticket.assignTo(decision.team());
        repository.save(ticket);
        audit.record(ticket.id(), "ASSIGNED", decision.team().name());
        notifications.assigned(ticket.id(), decision.team());
        return new TicketResult(ticket.id(), ticket.status(), decision.team(), sla.dueAt(openedAt, decision.slaHours()));
    }
    public record TicketResult(TicketId id, TicketStatus status, SupportTeam team, Instant dueAt) {}
}

package com.aydinsude.workbench.legacy.supportstory;

import java.time.*;
import java.util.Objects;

/** Domain Service: Eskalation nur bei belegtem SLA-Verstoß. */
public final class EscalationService {
    private final SlaPolicy sla; private final TicketRepository repository; private final SupportAuditPort audit; private final SupportNotificationPort notifications;
    public EscalationService(SlaPolicy sla, TicketRepository repository, SupportAuditPort audit, SupportNotificationPort notifications) { this.sla=Objects.requireNonNull(sla); this.repository=Objects.requireNonNull(repository); this.audit=Objects.requireNonNull(audit); this.notifications=Objects.requireNonNull(notifications); }
    public boolean escalateIfRequired(SupportTicket ticket, Instant dueAt, Instant now) {
        if(!sla.isBreached(dueAt, now) || ticket.status()==TicketStatus.CLOSED) return false;
        ticket.escalate(); repository.save(ticket); audit.record(ticket.id(), "ESCALATED", "level="+ticket.escalationLevel()); notifications.escalated(ticket.id(), ticket.escalationLevel()); return true;
    }
}