package com.assu.study.clean_me.account.domain;

import java.time.LocalDateTime;
import java.util.Optional;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Value;

// 계좌의 현재 스냅샷을 제공
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class Account {
  private final AccountId id;

  // 계좌의 현재 잔고를 계산하기 한 ActivityWindow 의 첫 번째 활동 바로 전의 잔고
  // 과거 특정 시점의 계좌 잔고
  private final Money baselineBalance;

  // 한 계좌에 대한 모든 활동(activity) 들을 항상 메모리에 한꺼번에 올리지 않고,
  // Account 엔티티는 ActivityWindow 값 객체(VO) 에서 포착한 지난 며칠 혹은 특정 범위에 해당하는 활동만 보유
  // 과거 특정 시점 이후의 입출금 내역 (activity)
  private final ActivityWindow activityWindow;

  // ID 가 없는 Account 엔티티 생성
  // 아직 생성되지 않은 새로운 엔티티 생성
  public static Account withoutId(Money baselineBalance, ActivityWindow activityWindow) {
    return new Account(null, baselineBalance, activityWindow);
  }

  // ID 가 있는 Account 엔티티 생성
  // 이미 저장된 엔티티를 재구성할 때 사용
  public static Account withId(
          AccountId accountId, Money baselineBalance, ActivityWindow activityWindow) {
    return new Account(accountId, baselineBalance, activityWindow);
  }

  public Optional<AccountId> getId() {
    return Optional.ofNullable(this.id);
  }

  // 현재 총 잔액은 기준 잔고(baselineBalance) 에 ActivityWindow 의 모든 활동들의 잔고를 합한 값
  public Money calculateBalance() {
    return Money.add(this.baselineBalance, this.activityWindow.calculateBalance(this.id));
  }

  // 계좌에서 일정 금액 인출 시도
  // 성공한다면 새로운 활동 생성
  // 인출에 성공하면 true 리턴, 실패하면 false 리턴
  public boolean withdraw(Money money, AccountId targetAccountId) {
    if (!mayWithdraw(money)) {
      return false;
    }

    Activity withdrawal =
            new Activity(this.id, this.id, targetAccountId, LocalDateTime.now(), money);
    this.activityWindow.addActivity(withdrawal);

    return true;
  }

  // 출금 가능 상태인지 확인 (비즈니스 규칙 검증)
  private boolean mayWithdraw(Money money) {
    return Money.add(this.calculateBalance(), money.negate()).isPositiveOrZero();
  }

  // 계좌에 일정 금액 입금
  // 성공한다면 새로운 활동 생성
  // 입금에 성공하면 true 리턴, 실패하면 false 리턴
  public boolean deposit(Money money, AccountId sourceAccountId) {
    Activity deposit = new Activity(this.id, sourceAccountId, this.id, LocalDateTime.now(), money);
    this.activityWindow.addActivity(deposit);

    return true;
  }

  @Value
  public static class AccountId {
    private Long value;
  }
}

package com.assu.study.clean_me.account.adapter.out.persistence;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "account")
@Data
@AllArgsConstructor
@NoArgsConstructor
class AccountJpaEntity {
  @Id @GeneratedValue private Long id;
}

package com.assu.study.clean_me.account.adapter.out.persistence;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

// 특정 계좌에 대한 모든 활동을 저장하는 엔티티
@Entity
@Table(name = "activity")
@Data
@AllArgsConstructor
@NoArgsConstructor
class ActivityJpaEntity {
  @Id @GeneratedValue private Long id;

  @Column private LocalDateTime timestamp;

  @Column private Long ownerAccountId;

  @Column private Long sourceAccountId;

  @Column private Long targetAccountId;

  @Column private Long amount;
}

package com.assu.study.clean_me.account.adapter.out.persistence;

import org.springframework.data.jpa.repository.JpaRepository;

interface AccountRepository extends JpaRepository<AccountJpaEntity, Long> {}

package com.assu.study.clean_me.account.adapter.out.persistence;

import java.time.LocalDateTime;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

interface ActivityRepository extends JpaRepository<ActivityJpaEntity, Long> {

  @Query(
      "SELECT a FROM ActivityJpaEntity a "
          + "WHERE a.ownerAccountId = :ownerAccountId "
          + "  AND a.timestamp >= :since")
  List<ActivityJpaEntity> findByOwnerSince(
      @Param("ownerAccountId") Long ownerAccountId, @Param("since") LocalDateTime since);

  @Query(
      "SELECT SUM(a.amount) FROM ActivityJpaEntity a "
          + "WHERE a.targetAccountId = :accountId "
          + "  AND a.ownerAccountId = :accountId "
          + "  AND a.timestamp < :until")
  Long getDepositBalanceUntil(
      @Param("accountId") Long accountId, @Param("until") LocalDateTime until);

  @Query(
      "SELECT sum(a.amount) FROM ActivityJpaEntity a "
          + "WHERE a.sourceAccountId = :accountId "
          + "  AND a.ownerAccountId = :accountId "
          + "  AND a.timestamp < :until")
  Long getWithdrawalBalanceUntil(
      @Param("accountId") Long accountId, @Param("until") LocalDateTime until);
}

package com.assu.study.clean_me.account.adapter.out.persistence;

import com.assu.study.clean_me.account.application.port.out.LoadAccountPort;
import com.assu.study.clean_me.account.application.port.out.UpdateAccountStatePort;
import com.assu.study.clean_me.account.domain.Account;
import com.assu.study.clean_me.account.domain.Activity;
import com.assu.study.clean_me.common.PersistenceAdapter;
import jakarta.persistence.EntityExistsException;
import java.time.LocalDateTime;
import java.util.List;
import lombok.RequiredArgsConstructor;

@PersistenceAdapter
@RequiredArgsConstructor
class AccountPersistenceAdapter implements LoadAccountPort, UpdateAccountStatePort {

  private final AccountRepository accountRepository;
  private final ActivityRepository activityRepository;
  private final AccountMapper accountMapper;

  // Account 도메인 엔티티를 DB 로부터 가져와서 반환
  @Override
  public Account loadAccount(Account.AccountId accountId, LocalDateTime baselineDate) {
    // 계좌 정보 조회
    AccountJpaEntity account =
        accountRepository.findById(accountId.getValue()).orElseThrow(EntityExistsException::new);

    // 해당 계좌의 특정 시간까지의 활동 조회
    List<ActivityJpaEntity> activityJpaEntities =
        activityRepository.findByOwnerSince(accountId.getValue(), baselineDate);

    // 특정 시간까지의 모든 출금 정보 조회
    Long withdrawalBalance =
        orZero(activityRepository.getWithdrawalBalanceUntil(account.getId(), baselineDate));

    // 특정 시간까지의 모든 입금 정보 조회
    Long depositBalance =
        orZero(activityRepository.getDepositBalanceUntil(accountId.getValue(), baselineDate));

    return accountMapper.mapToDomainEntity(
        account, activityJpaEntities, withdrawalBalance, depositBalance);
  }

  private Long orZero(Long value) {
    return value == null ? 0L : value;
  }

  // 계좌 상태 업데이트
  // 새로운 계좌 활동을 DB 에 저장
  @Override
  public void updateActivities(Account account) {
    // Account 엔티티의 모든 활동을 순회하여 id 가 있는지 확인 후 없다면 새로운 활동 저장
    for (Activity activity : account.getActivityWindow().getActivities()) {
      if (activity.getId() == null) {
        activityRepository.save(accountMapper.mapToJpaEntity(activity));
      }
    }
  }
}

package com.assu.study.clean_me.account.adapter.out.persistence;

import com.assu.study.clean_me.account.domain.Account;
import com.assu.study.clean_me.account.domain.Activity;
import com.assu.study.clean_me.account.domain.ActivityWindow;
import com.assu.study.clean_me.account.domain.Money;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Component;

@Component
class AccountMapper {
  Account mapToDomainEntity(
      AccountJpaEntity account,
      List<ActivityJpaEntity> activityJpaEntities,
      Long withdrawalBalance,
      Long depositBalance) {

    // 특정 시간(= ActivityWindow) 직전의 계좌 잔고 계산
    Money baselineBalance = Money.subtract(Money.of(depositBalance), Money.of(withdrawalBalance));

    // 도메인 엔티티 반환
    return Account.withId(
        new Account.AccountId(account.getId()),
        baselineBalance,
        mapToActivityWindow(activityJpaEntities));
  }

  // ActivityJpaEntity List 를 ActivityWindow 로 mapping
  ActivityWindow mapToActivityWindow(List<ActivityJpaEntity> activityJpaEntities) {
    List<Activity> mappedActivities = new ArrayList<>();

    for (ActivityJpaEntity activityJpa : activityJpaEntities) {
      mappedActivities.add(
          new Activity(
              new Activity.ActivityId(activityJpa.getId()),
              new Account.AccountId(activityJpa.getOwnerAccountId()),
              new Account.AccountId(activityJpa.getSourceAccountId()),
              new Account.AccountId(activityJpa.getTargetAccountId()),
              activityJpa.getTimestamp(),
              Money.of(activityJpa.getAmount())));
    }

    return new ActivityWindow(mappedActivities);
  }

  // Activity 를 ActivityJpaEntity 로 mapping
  ActivityJpaEntity mapToJpaEntity(Activity activity) {
    return new ActivityJpaEntity(
        activity.getId() == null ? null : activity.getId().getValue(),
        activity.getTimestamp(),
        activity.getOwnerAccountId().getValue(),
        activity.getSourceAccountId().getValue(),
        activity.getTargetAccountId().getValue(),
        activity.getMoney().getAmount().longValue());
  }
}

package com.assu.study.clean_me.account.application.service;

import com.assu.study.clean_me.account.application.port.in.SendMoneyCommand;
import com.assu.study.clean_me.account.application.port.in.SendMoneyUseCase;
import com.assu.study.clean_me.account.application.port.out.AccountLock;
import com.assu.study.clean_me.account.application.port.out.LoadAccountPort;
import com.assu.study.clean_me.account.application.port.out.UpdateAccountStatePort;
import com.assu.study.clean_me.common.UseCase;
import lombok.RequiredArgsConstructor;
import org.springframework.transaction.annotation.Transactional;

// 인커밍 포트 인터페이스인 SendMoneyUseCase 구현
@UseCase
@RequiredArgsConstructor
@Transactional
class SendMoneyService implements SendMoneyUseCase {

    // ...
}