// Modern integration: REST call to T24
@Service
@RequiredArgsConstructor
@Slf4j
public class T24AccountService {

   private final WebClient t24Client;

   public AccountBalance getBalance(String accountId) {
       return t24Client.get()
           .uri("/api/v1/holdings/accounts/{accountId}", accountId)
           .header("Authorization", "Bearer " + getServiceToken())
           .retrieve()
           .bodyToMono(T24AccountResponse.class)
           .map(this::mapToBalance)
           .block();
   }

   public TransferResult createTransfer(TransferRequest request) {
       T24TransferPayload payload = T24TransferPayload.builder()
           .debitAccountId(request.getFromAccount())
           .creditAccountId(request.getToAccount())
           .amount(request.getAmount())
           .currency("VND")
           .transactionType("AC")
           .build();

       return t24Client.post()
           .uri("/api/v1/order/payments/transfers")
           .bodyValue(payload)
           .retrieve()
           .onStatus(HttpStatusCode::is4xxClientError, response ->
               response.bodyToMono(T24ErrorResponse.class)
                   .flatMap(error -> Mono.error(
                       new T24BusinessException(error.getErrorCode(), error.getMessage()))))
           .bodyToMono(T24TransferResponse.class)
           .map(this::mapToResult)
           .block();
   }
}

// T24 Local Routine (runs INSIDE T24 engine)
public class LR_ValidateTransfer extends LocalRoutine {

   @Override
   public void execute() {
       String debitAccount = getFieldValue("DEBIT.ACCT.NO");
       BigDecimal amount = new BigDecimal(getFieldValue("DEBIT.AMOUNT"));

       // Custom business validation
       if (amount.compareTo(new BigDecimal("10000000000")) > 0) {
           setError("DEBIT.AMOUNT", "Amount exceeds single transaction limit");
           return;
       }

       // Check sanctions
       if (sanctionService.isBlocked(debitAccount)) {
           setError("DEBIT.ACCT.NO", "Account is blocked by compliance");
       }
   }
}

// Middleware service: abstracts T24 complexity from digital channels
@Service
@RequiredArgsConstructor
@Slf4j
public class AccountMiddlewareService {

   private final T24Client t24Client;
   private final RedisTemplate<String, AccountDTO> cache;
   private final CircuitBreakerFactory circuitBreakerFactory;

   private static final Duration CACHE_TTL = Duration.ofMinutes(5);

   public AccountDTO getAccount(String accountId) {
       // 1. Check cache first
       AccountDTO cached = cache.opsForValue().get("account:" + accountId);
       if (cached != null) return cached;

       // 2. Call T24 with circuit breaker
       CircuitBreaker cb = circuitBreakerFactory.create("t24-accounts");
       AccountDTO account = cb.run(
           () -> t24Client.getAccount(accountId),
           throwable -> {
               log.error("T24 unavailable for account: {}", accountId, throwable);
               throw new CoreBankingUnavailableException("Cannot retrieve account");
           }
       );

       // 3. Cache result
       cache.opsForValue().set("account:" + accountId, account, CACHE_TTL);
       return account;
   }
}

@Configuration
public class ActivitiConfig {

   @Bean
   public SpringProcessEngineConfiguration processEngineConfiguration(
           DataSource dataSource,
           PlatformTransactionManager transactionManager,
           List<JavaDelegate> delegates) {

       SpringProcessEngineConfiguration config = new SpringProcessEngineConfiguration();
       config.setDataSource(dataSource);
       config.setTransactionManager(transactionManager);
       config.setDatabaseSchemaUpdate("true");
       config.setAsyncExecutorActivate(true);
       config.setHistoryLevel(HistoryLevel.FULL);

       // Custom ID generator (UUID thay vì sequential)
       config.setIdGenerator(new StrongUuidGenerator());

       // Async executor tuning
       config.setAsyncExecutorCorePoolSize(5);
       config.setAsyncExecutorMaxPoolSize(20);
       config.setAsyncExecutorDefaultAsyncJobAcquireWaitTime(5000);

       return config;
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class ProcessDefinitionService {

   private final RepositoryService repositoryService;

   /**
    * Deploy BPMN XML. Mỗi lần deploy cùng key → version tăng.
    * Instances đang chạy KHÔNG bị ảnh hưởng — giữ version cũ.
    * Instances mới start sẽ dùng version mới nhất.
    */
   public DeploymentResult deploy(String bpmnXml, String processName, String workspaceId) {
       Deployment deployment = repositoryService.createDeployment()
           .name(processName)
           .tenantId(workspaceId)  // Multi-tenant isolation
           .addString(processName + ".bpmn20.xml", bpmnXml)
           .deploy();

       // Lấy definition mới deploy
       ProcessDefinition definition = repositoryService.createProcessDefinitionQuery()
           .deploymentId(deployment.getId())
           .singleResult();

       log.info("Deployed process | name={} | version={} | deploymentId={}",
           definition.getName(), definition.getVersion(), deployment.getId());

       return new DeploymentResult(deployment.getId(), definition.getId(), definition.getVersion());
   }

   /**
    * Lấy tất cả versions của 1 process definition.
    * Hữu ích cho rollback: activate version cũ, suspend version mới.
    */
   public List<ProcessDefinitionDTO> getVersions(String processKey, String workspaceId) {
       return repositoryService.createProcessDefinitionQuery()
           .processDefinitionKey(processKey)
           .processDefinitionTenantId(workspaceId)
           .orderByProcessDefinitionVersion().desc()
           .list()
           .stream()
           .map(this::toDTO)
           .toList();
   }

   /**
    * Suspend definition → không thể start instances mới.
    * Useful khi phát hiện bug trong process, cần "pause" nó.
    */
   public void suspend(String definitionId) {
       repositoryService.suspendProcessDefinitionById(definitionId, true, null);
       // suspendProcessInstances=true → suspend cả running instances
       log.info("Suspended process definition: {}", definitionId);
   }

   /**
    * Lấy BPMN XML từ deployed definition.
    * Useful cho: hiển thị diagram, audit, export.
    */
   public String getBpmnXml(String definitionId) {
       ProcessDefinition def = repositoryService.getProcessDefinition(definitionId);
       try (InputStream is = repositoryService.getResourceAsStream(
               def.getDeploymentId(), def.getResourceName())) {
           return new String(is.readAllBytes(), StandardCharsets.UTF_8);
       } catch (IOException e) {
           throw new RuntimeException("Failed to read BPMN resource", e);
       }
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class ProcessInstanceService {

   private final RuntimeService runtimeService;

   /**
    * Start process instance.
    * businessKey = unique identifier từ business domain (order ID, loan ID).
    * Variables = initial data cho process.
    */
   public ProcessInstanceDTO startProcess(StartProcessRequest request) {
       Map<String, Object> variables = new HashMap<>();
       variables.put("applicantName", request.getApplicantName());
       variables.put("loanAmount", request.getLoanAmount());
       variables.put("applicationDate", LocalDate.now().toString());
       variables.put("workspaceId", request.getWorkspaceId());

       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           request.getProcessKey(),       // BPMN process ID (VD: "loan-approval")
           request.getBusinessKey(),      // Business identifier (VD: "LOAN-2024-001")
           variables
       );

       log.info("Process started | key={} | instanceId={} | businessKey={}",
           request.getProcessKey(), instance.getId(), request.getBusinessKey());

       return toDTO(instance);
   }

   /**
    * Gửi signal/message đến running instance.
    * Use case: external system callback, webhook response.
    */
   public void sendMessage(String messageName, String businessKey, Map<String, Object> payload) {
       // Find execution đang wait message
       Execution execution = runtimeService.createExecutionQuery()
           .messageEventSubscriptionName(messageName)
           .processInstanceBusinessKey(businessKey)
           .singleResult();

       if (execution == null) {
           throw new ProcessNotFoundException(
               "No process waiting for message: " + messageName + " with key: " + businessKey);
       }

       runtimeService.messageEventReceived(messageName, execution.getId(), payload);
       log.info("Message delivered | message={} | businessKey={}", messageName, businessKey);
   }

   /**
    * Get variables từ running instance.
    * Variables = shared state giữa tasks trong cùng instance.
    */
   public Map<String, Object> getVariables(String instanceId) {
       return runtimeService.getVariables(instanceId);
   }

   /**
    * Set/update variable dynamically.
    * Use case: external event update data giữa chừng process.
    */
   public void setVariable(String instanceId, String varName, Object value) {
       runtimeService.setVariable(instanceId, varName, value);
   }

   /**
    * Cancel running instance.
    * Use case: customer cancel application, admin abort stuck process.
    */
   public void cancel(String instanceId, String reason) {
       runtimeService.deleteProcessInstance(instanceId, reason);
       log.info("Process cancelled | instanceId={} | reason={}", instanceId, reason);
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class UserTaskService {

   private final TaskService taskService;

   /**
    * Lấy tasks assigned cho user cụ thể.
    * "Inbox" của user — tasks đang chờ user hoàn thành.
    */
   public Page<TaskDTO> getMyTasks(String userId, Pageable pageable) {
       long total = taskService.createTaskQuery()
           .taskAssignee(userId)
           .count();

       List<Task> tasks = taskService.createTaskQuery()
           .taskAssignee(userId)
           .orderByTaskCreateTime().desc()
           .listPage((int) pageable.getOffset(), pageable.getPageSize());

       List<TaskDTO> dtos = tasks.stream().map(this::toDTO).toList();
       return new PageImpl<>(dtos, pageable, total);
   }

   /**
    * Lấy tasks available cho group (chưa ai claim).
    * "Shared queue" — ai rảnh thì nhận.
    */
   public List<TaskDTO> getGroupTasks(String groupId) {
       return taskService.createTaskQuery()
           .taskCandidateGroup(groupId)
           .taskUnassigned()  // Chưa ai claim
           .orderByTaskCreateTime().desc()
           .list()
           .stream()
           .map(this::toDTO)
           .toList();
   }

   /**
    * Claim task từ group queue.
    * Sau khi claim, task không còn visible cho người khác trong group.
    */
   public void claim(String taskId, String userId) {
       taskService.claim(taskId, userId);
       log.info("Task claimed | taskId={} | userId={}", taskId, userId);
   }

   /**
    * Unclaim — trả task về queue (user bận, không thể handle).
    */
   public void unclaim(String taskId) {
       taskService.unclaim(taskId);
   }

   /**
    * Complete task với output variables.
    * Variables này available cho downstream tasks/gateways.
    *
    * Ví dụ: Approver complete với decision="approve", comments="Looks good"
    * → Gateway đọc ${decision == 'approve'} → route accordingly
    */
   public void complete(String taskId, Map<String, Object> variables, String userId) {
       // Verify task assigned to this user
       Task task = taskService.createTaskQuery()
           .taskId(taskId)
           .taskAssignee(userId)
           .singleResult();

       if (task == null) {
           throw new TaskNotFoundException("Task not found or not assigned to you: " + taskId);
       }

       taskService.complete(taskId, variables);
       log.info("Task completed | taskId={} | taskName={} | userId={} | vars={}",
           taskId, task.getName(), userId, variables.keySet());
   }

   /**
    * Delegate task cho người khác.
    * Use case: manager delegate cho subordinate.
    */
   public void delegate(String taskId, String fromUserId, String toUserId) {
       taskService.delegateTask(taskId, toUserId);
       log.info("Task delegated | taskId={} | from={} | to={}", taskId, fromUserId, toUserId);
   }

   /**
    * Add comment to task (audit trail).
    */
   public void addComment(String taskId, String userId, String message) {
       Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
       taskService.addComment(taskId, task.getProcessInstanceId(), message);
   }

   private TaskDTO toDTO(Task task) {
       Map<String, Object> variables = taskService.getVariables(task.getId());
       return TaskDTO.builder()
           .id(task.getId())
           .name(task.getName())
           .assignee(task.getAssignee())
           .createTime(task.getCreateTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime())
           .dueDate(task.getDueDate() != null ? task.getDueDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate() : null)
           .processInstanceId(task.getProcessInstanceId())
           .processDefinitionId(task.getProcessDefinitionId())
           .formKey(task.getFormKey())
           .variables(variables)
           .build();
   }
}

@Service
@RequiredArgsConstructor
public class ProcessHistoryService {

   private final HistoryService historyService;

   /**
    * Lấy toàn bộ history của 1 process instance.
    * Ai làm gì, khi nào, mất bao lâu — full timeline.
    */
   public ProcessHistoryDTO getInstanceHistory(String instanceId) {
       HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery()
           .processInstanceId(instanceId)
           .singleResult();

       List<HistoricActivityInstance> activities = historyService.createHistoricActivityInstanceQuery()
           .processInstanceId(instanceId)
           .orderByHistoricActivityInstanceStartTime().asc()
           .list();

       List<HistoricTaskInstance> tasks = historyService.createHistoricTaskInstanceQuery()
           .processInstanceId(instanceId)
           .orderByHistoricTaskInstanceStartTime().asc()
           .list();

       return ProcessHistoryDTO.builder()
           .instanceId(instanceId)
           .startTime(instance.getStartTime())
           .endTime(instance.getEndTime())
           .durationMs(instance.getDurationInMillis())
           .status(instance.getEndTime() != null ? "COMPLETED" : "RUNNING")
           .activities(activities.stream().map(this::toActivityDTO).toList())
           .tasks(tasks.stream().map(this::toTaskDTO).toList())
           .build();
   }

   /**
    * Phân tích performance: average duration per task.
    * Phát hiện bottleneck: task nào mất thời gian nhiều nhất?
    */
   public List<TaskPerformanceDTO> getTaskPerformance(String processKey, LocalDate from, LocalDate to) {
       return historyService.createHistoricTaskInstanceQuery()
           .processDefinitionKey(processKey)
           .taskCompletedAfter(toDate(from))
           .taskCompletedBefore(toDate(to))
           .list()
           .stream()
           .collect(Collectors.groupingBy(HistoricTaskInstance::getName))
           .entrySet().stream()
           .map(entry -> {
               List<HistoricTaskInstance> tasks = entry.getValue();
               double avgDuration = tasks.stream()
                   .mapToLong(t -> t.getDurationInMillis() != null ? t.getDurationInMillis() : 0)
                   .average().orElse(0);
               return new TaskPerformanceDTO(
                   entry.getKey(),
                   tasks.size(),
                   (long) avgDuration,
                   tasks.stream().mapToLong(HistoricTaskInstance::getDurationInMillis).max().orElse(0)
               );
           })
           .sorted(Comparator.comparingLong(TaskPerformanceDTO::avgDurationMs).reversed())
           .toList();
   }
}

/**
* Delegate tính toán credit score.
*
* Input variables: customerId, loanAmount
* Output variables: creditScore, riskLevel, autoApproved
*
* BPMN reference: activiti:delegateExpression="${creditScoreDelegate}"
*/
@Component("creditScoreDelegate")
@RequiredArgsConstructor
@Slf4j
public class CreditScoreDelegate implements JavaDelegate {

   private final CreditScoringClient scoringClient;  // Gọi external service
   private final MetricsService metrics;

   @Override
   public void execute(DelegateExecution execution) {
       // 1. Read input variables
       String customerId = (String) execution.getVariable("customerId");
       BigDecimal loanAmount = (BigDecimal) execution.getVariable("loanAmount");
       String processId = execution.getProcessInstanceId();

       log.info("[processId={}] Calculating credit score | customerId={} | amount={}",
           processId, customerId, loanAmount);

       // 2. Execute business logic
       long start = System.nanoTime();
       try {
           CreditScoreResult result = scoringClient.calculate(customerId, loanAmount);

           // 3. Set output variables (available for downstream tasks/gateways)
           execution.setVariable("creditScore", result.getScore());
           execution.setVariable("riskLevel", result.getRiskLevel().name());
           execution.setVariable("autoApproved", result.getScore() >= 750);
           execution.setVariable("scoringDetails", result.getDetails());

           long durationMs = (System.nanoTime() - start) / 1_000_000;
           metrics.recordTaskDuration("credit_score_calculation", durationMs);

           log.info("[processId={}] Credit score calculated | score={} | risk={} | autoApproved={} | {}ms",
               processId, result.getScore(), result.getRiskLevel(),
               result.getScore() >= 750, durationMs);

       } catch (ScoringServiceUnavailableException e) {
           // Throw BpmnError → caught by boundary error event trên diagram
           log.error("[processId={}] Scoring service unavailable: {}", processId, e.getMessage());
           throw new BpmnError("SCORING_UNAVAILABLE",
               "Credit scoring service is temporarily unavailable");

       } catch (InvalidCustomerException e) {
           // Business error → route to rejection path
           execution.setVariable("rejectionReason", e.getMessage());
           throw new BpmnError("INVALID_CUSTOMER", e.getMessage());
       }
       // RuntimeException (NPE, etc.) → task fails, engine creates incident
       // → requires manual intervention or job retry
   }
}

@Configuration
public class AsyncExecutorConfig {

   @Bean
   public SpringProcessEngineConfiguration engineConfig(DataSource ds,
           PlatformTransactionManager txManager) {
       SpringProcessEngineConfiguration config = new SpringProcessEngineConfiguration();
       config.setDataSource(ds);
       config.setTransactionManager(txManager);

       // Async executor settings
       config.setAsyncExecutorActivate(true);
       config.setAsyncExecutorCorePoolSize(5);        // Minimum threads
       config.setAsyncExecutorMaxPoolSize(20);       // Maximum threads
       config.setAsyncExecutorDefaultAsyncJobAcquireWaitTime(5000);  // Poll interval (ms)
       config.setAsyncExecutorDefaultTimerJobAcquireWaitTime(5000);
       config.setAsyncFailedJobWaitTime(10);         // Seconds between retries
       config.setAsyncExecutorMaxAsyncJobsDuePerAcquisition(5);     // Jobs per batch

       // Retry configuration
       config.setDefaultFailedJobWaitTime(300);      // 5 minutes between retries
       config.setAsyncExecutorResetExpiredJobsInterval(60000);      // 1 minute

       return config;
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class FailedJobService {

   private final ManagementService managementService;

   /**
    * Lấy jobs đang stuck (retries exhausted).
    * Monitor dashboard nên alert khi có deadletter jobs.
    */
   public List<DeadLetterJobDTO> getDeadLetterJobs() {
       return managementService.createDeadLetterJobQuery()
           .orderByJobCreateTime().desc()
           .list()
           .stream()
           .map(job -> DeadLetterJobDTO.builder()
               .jobId(job.getId())
               .processInstanceId(job.getProcessInstanceId())
               .exceptionMessage(job.getExceptionMessage())
               .createTime(job.getCreateTime())
               .retries(job.getRetries())
               .build())
           .toList();
   }

   /**
    * Retry dead letter job (sau khi fix root cause).
    * Move job từ deadletter → executable queue.
    */
   public void retryDeadLetterJob(String jobId) {
       managementService.moveDeadLetterJobToExecutableJob(jobId, 3); // 3 retries
       log.info("Dead letter job moved to executable | jobId={}", jobId);
   }
}

@Service
@RequiredArgsConstructor
public class TenantAwareProcessService {

   private final RepositoryService repositoryService;
   private final RuntimeService runtimeService;
   private final TaskService taskService;

   // Deploy với tenant isolation
   public String deploy(String bpmnXml, String name, String workspaceId) {
       Deployment deployment = repositoryService.createDeployment()
           .name(name)
           .tenantId(workspaceId)  // ← Tenant isolation
           .addString(name + ".bpmn20.xml", bpmnXml)
           .deploy();
       return deployment.getId();
   }

   // Start instance — tự động inherit tenant từ definition
   public String startProcess(String processKey, String workspaceId, Map<String, Object> vars) {
       ProcessInstance instance = runtimeService.startProcessInstanceByKeyAndTenantId(
           processKey, vars, workspaceId);  // ← Tenant-scoped
       return instance.getId();
   }

   // Query tasks — chỉ trong workspace
   public List<Task> getTasks(String userId, String workspaceId) {
       return taskService.createTaskQuery()
           .taskAssignee(userId)
           .taskTenantId(workspaceId)  // ← Tenant filter
           .list();
   }
}

@SpringBootTest
@ActiveProfiles("test")
class LoanApprovalProcessTest {

   @Autowired private RuntimeService runtimeService;
   @Autowired private TaskService taskService;
   @Autowired private HistoryService historyService;
   @Autowired private RepositoryService repositoryService;

   @MockBean private CreditScoringClient creditScoringClient;
   @MockBean private NotificationService notificationService;

   @BeforeEach
   void deployProcess() {
       repositoryService.createDeployment()
           .addClasspathResource("processes/loan-approval.bpmn20.xml")
           .deploy();
   }

   @Test
   void loanApproval_highCreditScore_autoApproved() {
       // Given: high credit score → auto-approve path
       when(creditScoringClient.calculate(any(), any()))
           .thenReturn(new CreditScoreResult(800, RiskLevel.LOW));

       // When: start process
       Map<String, Object> variables = Map.of(
           "customerId", "CUST-001",
           "loanAmount", new BigDecimal("500000000"),
           "applicantName", "Nguyen Van A"
       );
       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           "loan-approval", "LOAN-001", variables);

       // Then: process should complete automatically (no user task needed)
       HistoricProcessInstance completed = historyService.createHistoricProcessInstanceQuery()
           .processInstanceId(instance.getId())
           .finished()
           .singleResult();

       assertThat(completed).isNotNull();
       assertThat(completed.getEndTime()).isNotNull();

       // Verify notification sent
       verify(notificationService).sendApprovalNotification("CUST-001", "LOAN-001");
   }

   @Test
   void loanApproval_lowCreditScore_requiresManualReview() {
       // Given: low credit score → manual review path
       when(creditScoringClient.calculate(any(), any()))
           .thenReturn(new CreditScoreResult(550, RiskLevel.HIGH));

       // When: start process
       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           "loan-approval", "LOAN-002", Map.of(
               "customerId", "CUST-002",
               "loanAmount", new BigDecimal("2000000000")
           ));

       // Then: should create user task for manual review
       Task reviewTask = taskService.createTaskQuery()
           .processInstanceId(instance.getId())
           .taskDefinitionKey("manualReviewTask")
           .singleResult();

       assertThat(reviewTask).isNotNull();
       assertThat(reviewTask.getName()).isEqualTo("Manual Review");

       // Complete review with approval
       taskService.complete(reviewTask.getId(), Map.of(
           "decision", "approve",
           "reviewComments", "High amount but good collateral"
       ));

       // Verify process completed
       HistoricProcessInstance completed = historyService.createHistoricProcessInstanceQuery()
           .processInstanceId(instance.getId())
           .finished()
           .singleResult();
       assertThat(completed).isNotNull();
   }

   @Test
   void loanApproval_scoringServiceDown_errorPath() {
       // Given: scoring service throws error
       when(creditScoringClient.calculate(any(), any()))
           .thenThrow(new ScoringServiceUnavailableException("Service down"));

       // When: start process
       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           "loan-approval", "LOAN-003", Map.of(
               "customerId", "CUST-003",
               "loanAmount", new BigDecimal("100000000")
           ));

       // Then: should route to error handling path (manual scoring task)
       Task manualScoringTask = taskService.createTaskQuery()
           .processInstanceId(instance.getId())
           .taskDefinitionKey("manualScoringTask")
           .singleResult();

       assertThat(manualScoringTask).isNotNull();
       assertThat(manualScoringTask.getName()).isEqualTo("Manual Credit Assessment");
   }
}

@Component
@RequiredArgsConstructor
public class ProcessMetricsCollector {

   private final RuntimeService runtimeService;
   private final ManagementService managementService;
   private final HistoryService historyService;
   private final MeterRegistry meterRegistry;

   @Scheduled(fixedRate = 30000)  // Every 30s
   public void collectMetrics() {
       // Active instances
       long activeInstances = runtimeService.createProcessInstanceQuery().count();
       meterRegistry.gauge("bpmn.instances.active", activeInstances);

       // Suspended instances (paused, needs attention)
       long suspendedInstances = runtimeService.createProcessInstanceQuery().suspended().count();
       meterRegistry.gauge("bpmn.instances.suspended", suspendedInstances);

       // Pending user tasks (work backlog)
       long pendingTasks = managementService.createJobQuery().count();
       meterRegistry.gauge("bpmn.tasks.pending", pendingTasks);

       // Failed jobs (needs intervention)
       long failedJobs = managementService.createDeadLetterJobQuery().count();
       meterRegistry.gauge("bpmn.jobs.deadletter", failedJobs);

       // Timer jobs waiting (scheduled future work)
       long timerJobs = managementService.createTimerJobQuery().count();
       meterRegistry.gauge("bpmn.jobs.timer", timerJobs);
   }
}

// Ingestion service: pull transactions from core banking, persist to Backbase DB
@Service
@RequiredArgsConstructor
@Slf4j
public class TransactionIngestionService {

   private final CoreBankingClient coreBankingClient;
   private final TransactionRepository backbaseRepository;

   @Scheduled(fixedRate = 300000)  // Every 5 minutes
   public void ingestTransactions() {
       LocalDateTime lastSync = backbaseRepository.getLastSyncTimestamp();

       List<CoreTransaction> newTransactions = coreBankingClient
           .getTransactionsSince(lastSync);

       List<BackbaseTransaction> mapped = newTransactions.stream()
           .map(this::mapToBackbase)
           .toList();

       backbaseRepository.saveAll(mapped);
       log.info("Ingested {} transactions from core banking", mapped.size());
   }
}

// Extending Backbase Payment service behavior
@Configuration
public class CustomPaymentConfig {

   @Bean
   @Primary  // Override default implementation
   public PaymentValidator customPaymentValidator(
           SanctionScreeningClient sanctionClient,
           FraudDetectionClient fraudClient) {
       return new EnhancedPaymentValidator(sanctionClient, fraudClient);
   }
}

// Custom pre-processing hook
@Component
@Order(1)
public class FraudCheckInterceptor implements PaymentPreProcessor {

   @Override
   public void process(PaymentOrder payment) {
       FraudScore score = fraudService.evaluate(payment);
       if (score.isHighRisk()) {
           payment.setStatus(PaymentStatus.PENDING_REVIEW);
           throw new PaymentHeldException("Held for fraud review");
       }
   }
}

@Component("creditScoreDelegate")
@RequiredArgsConstructor
@Slf4j
public class CreditScoreDelegate implements JavaDelegate {

   private final CreditScoringService scoringService;

   @Override
   public void execute(DelegateExecution execution) {
       String customerId = (String) execution.getVariable("customerId");
       BigDecimal loanAmount = (BigDecimal) execution.getVariable("loanAmount");

       log.info("Calculating credit score | customerId={} | loanAmount={}",
           customerId, loanAmount);

       CreditScore score = scoringService.calculate(customerId, loanAmount);

       // Set process variables cho downstream tasks
       execution.setVariable("creditScore", score.getValue());
       execution.setVariable("riskLevel", score.getRiskLevel().name());
       execution.setVariable("autoApproved", score.getValue() >= 750);
   }
}

// Set variable khi start process
Map<String, Object> variables = new HashMap<>();
variables.put("applicantName", "Nguyen Van A");
variables.put("loanAmount", new BigDecimal("500000000"));
variables.put("applicationDate", LocalDate.now());
variables.put("documents", documentList);

ProcessInstance instance = runtimeService.startProcessInstanceByKey(
   "loan-approval", businessKey, variables);

// Read/write trong Java Delegate
@Override
public void execute(DelegateExecution execution) {
   BigDecimal amount = (BigDecimal) execution.getVariable("loanAmount");
   execution.setVariable("interestRate", calculateRate(amount));

   // Transient variable (không persist, chỉ tồn tại trong memory)
   execution.setTransientVariable("tempCalculation", intermediateResult);
}

// Expression trong BPMN XML
// UEL (Unified Expression Language)
${applicantName}                          // Read variable
${loanAmount > 1000000000}                // Condition
${riskLevel == 'HIGH' ? 'manual' : 'auto'} // Ternary
${orderService.calculateTotal(orderId)}    // Call Spring bean method
#{execution.getVariable('status')}         // Alternative syntax

@Component("taskAssignmentListener")
@RequiredArgsConstructor
@Slf4j
public class TaskAssignmentListener implements TaskListener {

   private final NotificationService notificationService;

   @Override
   public void notify(DelegateTask task) {
       String assignee = task.getAssignee();
       String taskName = task.getName();
       String processId = task.getProcessInstanceId();

       log.info("Task assigned | task={} | assignee={} | processId={}",
           taskName, assignee, processId);

       notificationService.sendTaskNotification(assignee,
           "New task assigned: " + taskName);
   }
}

@Component("paymentDelegate")
public class PaymentDelegate implements JavaDelegate {
   @Override
   public void execute(DelegateExecution execution) {
       try {
           paymentService.process(execution.getVariable("paymentId"));
       } catch (PaymentDeclinedException e) {
           // Throw BpmnError → caught by boundary error event
           throw new BpmnError("PAYMENT_FAILED", e.getMessage());
       }
       // Các exceptions KHÔNG phải BpmnError → escalate lên process level
   }
}

@Configuration
public class ActivitiConfig {

   @Bean
   public SpringProcessEngineConfiguration processEngineConfiguration(
           DataSource dataSource,
           PlatformTransactionManager transactionManager) {

       SpringProcessEngineConfiguration config = new SpringProcessEngineConfiguration();
       config.setDataSource(dataSource);
       config.setTransactionManager(transactionManager);
       config.setDatabaseSchemaUpdate("true");
       config.setAsyncExecutorActivate(true);
       config.setHistoryLevel(HistoryLevel.FULL);
       return config;
   }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class ProcessService {

   private final RepositoryService repositoryService;
   private final RuntimeService runtimeService;
   private final TaskService taskService;
   private final HistoryService historyService;

   // Deploy process definition
   public String deploy(String bpmnXml, String processName) {
       Deployment deployment = repositoryService.createDeployment()
           .name(processName)
           .addString(processName + ".bpmn20.xml", bpmnXml)
           .deploy();
       return deployment.getId();
   }

   // Start process instance
   public String startProcess(String processKey, Map<String, Object> variables) {
       ProcessInstance instance = runtimeService.startProcessInstanceByKey(
           processKey, UUID.randomUUID().toString(), variables);
       log.info("Process started | key={} | instanceId={}", processKey, instance.getId());
       return instance.getId();
   }

   // Complete user task
   public void completeTask(String taskId, Map<String, Object> variables) {
       taskService.complete(taskId, variables);
   }

   // Query active tasks for user
   public List<TaskDTO> getMyTasks(String userId) {
       return taskService.createTaskQuery()
           .taskAssignee(userId)
           .orderByTaskCreateTime().desc()
           .list()
           .stream()
           .map(this::toDTO)
           .toList();
   }
}

// Domain Entity — pure Java, NO Spring annotations, NO JPA annotations
public class Order {
   private final OrderId id;
   private final CustomerId customerId;
   private final List<OrderItem> items;
   private OrderStatus status;
   private Money totalAmount;
   private LocalDateTime createdAt;

   // Business rules LIVE HERE
   public void confirm() {
       if (this.status != OrderStatus.PENDING) {
           throw new IllegalOrderStateException(
               "Cannot confirm order in status: " + this.status);
       }
       if (this.items.isEmpty()) {
           throw new EmptyOrderException("Order must have at least 1 item");
       }
       this.status = OrderStatus.CONFIRMED;
   }

   public void cancel(String reason) {
       if (this.status == OrderStatus.SHIPPED) {
           throw new IllegalOrderStateException("Cannot cancel shipped order");
       }
       this.status = OrderStatus.CANCELLED;
   }

   public Money calculateTotal() {
       return items.stream()
           .map(item -> item.getPrice().multiply(item.getQuantity()))
           .reduce(Money.ZERO, Money::add);
   }

   // No setters — state changes only through business methods
}

// Value Object — immutable, equality by value
public record Money(BigDecimal amount, String currency) {
   public static final Money ZERO = new Money(BigDecimal.ZERO, "VND");

   public Money {
       if (amount.compareTo(BigDecimal.ZERO) < 0)
           throw new IllegalArgumentException("Amount cannot be negative");
   }

   public Money add(Money other) {
       if (!this.currency.equals(other.currency))
           throw new CurrencyMismatchException(this.currency, other.currency);
       return new Money(this.amount.add(other.amount), this.currency);
   }

   public Money multiply(int quantity) {
       return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), this.currency);
   }
}

// Inbound Port: Use Case interface
public interface CreateOrderUseCase {
   OrderId execute(CreateOrderCommand command);
}

// Command object (input to use case)
public record CreateOrderCommand(
   CustomerId customerId,
   List<OrderItemCommand> items,
   PaymentMethod paymentMethod
) {}

// Outbound Port: persistence
public interface OrderRepository {
   Order save(Order order);
   Optional<Order> findById(OrderId id);
   List<Order> findByCustomerId(CustomerId customerId);
}

// Outbound Port: external service
public interface PaymentGateway {
   PaymentResult charge(OrderId orderId, Money amount, PaymentMethod method);
   void refund(OrderId orderId);
}

public interface NotificationPort {
   void sendOrderConfirmation(CustomerId customerId, OrderId orderId);
}

// Use Case: orchestrate domain objects + ports
// NO Spring annotations here (optional: can add @Service for convenience)
public class CreateOrderService implements CreateOrderUseCase {

   private final OrderRepository orderRepository;
   private final PaymentGateway paymentGateway;
   private final InventoryGateway inventoryGateway;
   private final NotificationPort notificationPort;

   public CreateOrderService(OrderRepository orderRepository,
                             PaymentGateway paymentGateway,
                             InventoryGateway inventoryGateway,
                             NotificationPort notificationPort) {
       this.orderRepository = orderRepository;
       this.paymentGateway = paymentGateway;
       this.inventoryGateway = inventoryGateway;
       this.notificationPort = notificationPort;
   }

   @Override
   public OrderId execute(CreateOrderCommand command) {
       // 1. Create domain object (business rules validated in constructor)
       Order order = Order.create(command.customerId(), command.items());

       // 2. Check inventory (through port — doesn't know HOW it's checked)
       inventoryGateway.checkAvailability(order.getItems());

       // 3. Charge payment (through port — doesn't know it's Stripe/VnPay)
       PaymentResult payment = paymentGateway.charge(
           order.getId(), order.calculateTotal(), command.paymentMethod());

       if (!payment.isSuccess()) {
           throw new PaymentFailedException(payment.getErrorMessage());
       }

       // 4. Confirm order (domain business rule)
       order.confirm();

       // 5. Persist (through port — doesn't know it's PostgreSQL/MongoDB)
       orderRepository.save(order);

       // 6. Notify (through port — doesn't know it's email/push/SMS)
       notificationPort.sendOrderConfirmation(command.customerId(), order.getId());

       return order.getId();
   }
}

// Inbound Adapter: REST Controller
@RestController
@RequestMapping("/api/v1/orders")
@RequiredArgsConstructor
public class OrderController {

   private final CreateOrderUseCase createOrderUseCase;  // Depend on PORT, not implementation
   private final GetOrderUseCase getOrderUseCase;

   @PostMapping
   @ResponseStatus(HttpStatus.CREATED)
   public OrderResponse create(@Valid @RequestBody CreateOrderRequest request) {
       // Convert web DTO → domain command
       CreateOrderCommand command = new CreateOrderCommand(
           new CustomerId(request.getCustomerId()),
           request.getItems().stream().map(this::toItemCommand).toList(),
           request.getPaymentMethod()
       );

       // Call use case (doesn't know about HTTP, JSON, Spring)
       OrderId orderId = createOrderUseCase.execute(command);

       // Convert domain result → web response
       return new OrderResponse(orderId.value(), "Order created successfully");
   }
}

// Outbound Adapter: JPA persistence
@Component
@RequiredArgsConstructor
public class OrderPersistenceAdapter implements OrderRepository {

   private final OrderJpaRepository jpaRepository;  // Spring Data
   private final OrderMapper mapper;                // Domain ↔ JPA entity

   @Override
   public Order save(Order order) {
       OrderJpaEntity entity = mapper.toJpaEntity(order);
       OrderJpaEntity saved = jpaRepository.save(entity);
       return mapper.toDomain(saved);
   }

   @Override
   public Optional<Order> findById(OrderId id) {
       return jpaRepository.findById(id.value())
           .map(mapper::toDomain);
   }
}

// Outbound Adapter: Payment gateway (Stripe)
@Component
@RequiredArgsConstructor
public class StripePaymentAdapter implements PaymentGateway {

   private final StripeClient stripeClient;

   @Override
   public PaymentResult charge(OrderId orderId, Money amount, PaymentMethod method) {
       StripeChargeRequest stripeRequest = StripeChargeRequest.builder()
           .amount(amount.amount().movePointRight(2).longValue())  // cents
           .currency(amount.currency().toLowerCase())
           .idempotencyKey(orderId.value().toString())
           .build();

       StripeChargeResponse response = stripeClient.createCharge(stripeRequest);
       return new PaymentResult(response.isSucceeded(), response.getErrorMessage());
   }
}

@Configuration
public class OrderBeanConfig {

   @Bean
   public CreateOrderUseCase createOrderUseCase(
           OrderRepository orderRepository,
           PaymentGateway paymentGateway,
           InventoryGateway inventoryGateway,
           NotificationPort notificationPort) {
       return new CreateOrderService(
           orderRepository, paymentGateway, inventoryGateway, notificationPort);
   }
}

// Unit test Use Case — mock ports, test business logic
class CreateOrderServiceTest {

   private final OrderRepository orderRepository = mock(OrderRepository.class);
   private final PaymentGateway paymentGateway = mock(PaymentGateway.class);
   private final InventoryGateway inventoryGateway = mock(InventoryGateway.class);
   private final NotificationPort notificationPort = mock(NotificationPort.class);

   private final CreateOrderUseCase useCase = new CreateOrderService(
       orderRepository, paymentGateway, inventoryGateway, notificationPort);

   @Test
   void createOrder_success() {
       when(paymentGateway.charge(any(), any(), any()))
           .thenReturn(PaymentResult.success());
       when(orderRepository.save(any())).thenAnswer(i -> i.getArgument(0));

       OrderId result = useCase.execute(validCommand());

       assertThat(result).isNotNull();
       verify(orderRepository).save(argThat(order ->
           order.getStatus() == OrderStatus.CONFIRMED));
       verify(notificationPort).sendOrderConfirmation(any(), any());
   }

   @Test
   void createOrder_paymentFailed_throwsException() {
       when(paymentGateway.charge(any(), any(), any()))
           .thenReturn(PaymentResult.failed("Insufficient funds"));

       assertThatThrownBy(() -> useCase.execute(validCommand()))
           .isInstanceOf(PaymentFailedException.class);

       verify(orderRepository, never()).save(any());  // Order NOT persisted
   }
}

// Domain entity unit test — ZERO mocking
class OrderTest {

   @Test
   void confirm_pendingOrder_changesStatusToConfirmed() {
       Order order = Order.create(customerId, List.of(item1, item2));
       order.confirm();
       assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
   }

   @Test
   void confirm_emptyOrder_throwsException() {
       Order order = Order.create(customerId, List.of());
       assertThatThrownBy(order::confirm)
           .isInstanceOf(EmptyOrderException.class);
   }

   @Test
   void cancel_shippedOrder_throwsException() {
       Order order = createShippedOrder();
       assertThatThrownBy(() -> order.cancel("Changed mind"))
           .isInstanceOf(IllegalOrderStateException.class);
   }
}

// Mỗi element → 1 element mới
List<String> names = List.of("john", "jane", "bob");

List<String> upper = names.stream()
   .map(String::toUpperCase)    // "john" → "JOHN"
   .toList();
// ["JOHN", "JANE", "BOB"]

// map với function trả về object khác
List<Order> orders = ...;
List<UUID> customerIds = orders.stream()
   .map(Order::getCustomerId)   // Order → UUID
   .distinct()
   .toList();

// Mỗi order có nhiều items → lấy TẤT CẢ items từ TẤT CẢ orders
List<Order> orders = List.of(order1, order2, order3);

// map → Stream<List<OrderItem>> (nested!)
List<List<OrderItem>> nested = orders.stream()
   .map(Order::getItems)  // Order → List<OrderItem>
   .toList();
// [[item1, item2], [item3], [item4, item5]] — NESTED

// flatMap → Stream<OrderItem> (flat!)
List<OrderItem> allItems = orders.stream()
   .flatMap(order -> order.getItems().stream())  // Order → Stream<OrderItem>
   .toList();
// [item1, item2, item3, item4, item5] — FLAT

// Lấy tất cả tags từ tất cả products
List<String> allTags = products.stream()
   .flatMap(product -> product.getTags().stream())
   .distinct()
   .sorted()
   .toList();

// Lấy tất cả permissions từ tất cả roles của user
Set<String> permissions = user.getRoles().stream()
   .flatMap(role -> role.getPermissions().stream())
   .collect(Collectors.toSet());

// Parse CSV lines → individual fields
List<String> allFields = csvLines.stream()
   .flatMap(line -> Arrays.stream(line.split(",")))
   .map(String::trim)
   .toList();

// Multi-level flatten: workspace → projects → tasks
List<Task> allTasks = workspaces.stream()
   .flatMap(ws -> ws.getProjects().stream())
   .flatMap(project -> project.getTasks().stream())
   .filter(task -> task.getStatus() == TaskStatus.OPEN)
   .toList();

Optional<User> user = userRepository.findById(userId);

// map: User → String (plain value)
Optional<String> email = user.map(User::getEmail);
// Optional<"john@mail.com"> hoặc Optional.empty()

Optional<String> upperName = user
   .map(User::getName)
   .map(String::toUpperCase);

// findById trả Optional → cần flatMap
Optional<User> user = userRepository.findById(userId);

// map → Optional<Optional<Address>>
Optional<Optional<Address>> nested = user.map(User::getAddress);
// Nếu User::getAddress return Optional<Address>

// flatMap → Optional<Address>
Optional<Address> address = user.flatMap(User::getAddress);

// Chain multiple Optional operations
Optional<String> city = userRepository.findById(userId)      // Optional<User>
   .flatMap(User::getAddress)                                // Optional<Address>
   .flatMap(Address::getCity)                                // Optional<String>
   .map(String::toUpperCase);                                // Optional<String>

// Service method returning Optional
public Optional<ProductDTO> getProductWithCategory(UUID productId) {
   return productRepository.findById(productId)           // Optional<Product>
       .flatMap(product ->
           categoryRepository.findById(product.getCategoryId())  // Optional<Category>
               .map(category -> toDTO(product, category)));      // Optional<ProductDTO>
}

// Avoid nested optionals
public Optional<String> getWorkspaceName(UUID userId) {
   return userRepository.findById(userId)                  // Optional<User>
       .flatMap(user -> workspaceRepository.findById(user.getDefaultWorkspaceId()))  // Optional<Workspace>
       .map(Workspace::getName);                           // Optional<String>
}

CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> fetchUser(userId));

// thenApply (= map): User → String
CompletableFuture<String> nameFuture = userFuture
   .thenApply(User::getName);  // plain value

// thenApply khi function trả Future → nested!
CompletableFuture<CompletableFuture<Order>> nested = userFuture
   .thenApply(user -> fetchOrderAsync(user.getId()));  // Returns CF → nested CF<CF<Order>>

// thenCompose (= flatMap): flatten
CompletableFuture<Order> orderFuture = userFuture
   .thenCompose(user -> fetchOrderAsync(user.getId()));  // Returns CF → flat CF<Order>

// Chain
CompletableFuture<String> result = CompletableFuture
   .supplyAsync(() -> fetchUser(userId))               // CF<User>
   .thenCompose(user -> fetchOrdersAsync(user.getId())) // CF<List<Order>>
   .thenApply(orders -> orders.size() + " orders");     // CF<String>

// Các properties quan trọng thường dùng:
MessageProperties properties = MessagePropertiesBuilder.newInstance()
    .setContentType("application/json")       // Định dạng dữ liệu của body
    .setContentEncoding("UTF-8")              // Bảng mã hóa ký tự
    .setDeliveryMode(MessageDeliveryMode.PERSISTENT) // 1=tạm thời, 2=lưu đĩa (survive restart)
    .setPriority(5)                           // Độ ưu tiên của tin nhắn từ 0-9
    .setCorrelationId("abc-123")              // Dùng để định danh request-response (RPC)
    .setReplyTo("response.queue")             // Queue nhận phản hồi
    .setExpiration("60000")                   // TTL thời gian hết hạn (milliseconds)
    .setMessageId(UUID.randomUUID().toString()) // ID duy nhất chống lặp tin
    .setTimestamp(new Date())                 // Thời gian tạo tin nhắn
    .setType("OrderCreatedEvent")             // Tên loại sự kiện
    .setAppId("order-service")                // ID ứng dụng gửi tin
    .build();

// Ba loại xác nhận cơ bản:
channel.basicAck(deliveryTag, false);   // Xử lý thành công, cho phép xóa tin nhắn khỏi queue
channel.basicNack(deliveryTag, false, true);  // Thất bại, yêu cầu đẩy lại vào queue (requeue) để thử lại
channel.basicReject(deliveryTag, false);      // Thất bại, loại bỏ tin nhắn (hoặc chuyển sang DLX) không requeue