@RestController
@RequestMapping("/ledger")
public class LedgerController {

    @Resource
    private LedgerCommandApplicationService ledgerCommandApplicationService;

    @Resource
    private LedgerQueryApplicationService ledgerQueryApplicationService;

    @PostMapping("/create")
    public Result<String> createLedger(@RequestBody CreateLedgerRequest request) {
        String ledgerNo = ledgerCommandApplicationService.createLedger(request);
        return Result.success(ledgerNo);
    }

    @PostMapping("/update")
    public Result<String> updateLedger(@RequestBody UpdateLedgerRequest request) {
        ledgerCommandApplicationService.updateLedger(request);
        return Result.success();
    }

    @DeleteMapping()
    public Result<String> deleteLedger(@RequestBody DeleteLedgerRequest request) {
        ledgerCommandApplicationService.deleteLedger(request.getLedgerNo());
        return Result.success();
    }

    @GetMapping("/list")
    public Result<PageRes<LedgerListRes>> getLedgerList(QueryLedgerListRequest request) {
        return Result.success(ledgerQueryApplicationService.getLedgerList(request));
    }

    @GetMapping("/detail")
    public Result<LedgerDetailRes> getLedgerDetail(QueryLedgerRequest request) {
        return Result.success(ledgerQueryApplicationService.getLedger(request));
    }

    @PostMapping("/update/budget")
    public Result<String> updateLedgerBudget(@RequestBody UpdateLedgerBudgetRequest request) {
        ledgerCommandApplicationService.updateLedgerBudget(request);
        return Result.success();
    }

    @PostMapping("/join")
    public Result<String> joinLedger(@RequestBody JoinLedgerRequest request) {
        ledgerCommandApplicationService.joinLedger(request);
        return Result.success();
    }

    @GetMapping("/memberList")
    public Result<List<LedgerMemberListRes>> memberList(QueryLedgerMemberListRequest request) {
        List<LedgerMemberListRes> memberList = ledgerQueryApplicationService.getMemberList(request);
        return Result.success(memberList);
    }
}

@Service
@Slf4j
public class LedgerCommandApplicationService {

    @Resource
    private ApplicationEventPublisher eventPublisher;

    @Resource
    private LedgerDomainService ledgerDomainService;

    @Resource
    private LedgerFactory ledgerFactory;

    @Resource
    private InvitationDomainService invitationDomainService;

    public void deleteLedger(String ledgerNo) {
        LedgerAgg ledgerAgg = ledgerDomainService.findByNo(ledgerNo);
        if (ledgerAgg == null) {
            throw new AggNotExistsException(ResultCode.LEDGER_NOT_FOUND);
        }
        ledgerAgg.delete();
        ledgerDomainService.save(ledgerAgg);
    }

    public String createLedger(CreateLedgerRequest request) {
        // 获取用户ID
        String userNo = UserContextHolder.getCurrentUserNo();

        // 查询该账本是否已经存在
        LedgerAgg ledger = ledgerDomainService.findByNameInUser(request.getLedgerName(), userNo);
        if (ledger != null) {
            throw new AggNotExistsException(ResultCode.LEDGER_ALREADY_EXISTS);
        }
        // 账本不存在则创建
        LedgerAgg ledgerAgg = ledgerFactory.createLedgerAgg(request.getLedgerName(), userNo, request.getLedgerDesc(),
                request.getLedgerImage());
        ledgerAgg.create();

        // 插入数据库
        ledgerDomainService.save(ledgerAgg);

        // 获取注册的事件进行发布
        List<DomainEvent> domainEventList = ledgerAgg.getDomainEvents();
        domainEventList.forEach(event -> eventPublisher.publishEvent(event));

        // 返回账本编号
        return ledgerAgg.getLedgerNo();
    }

    public void updateLedger(UpdateLedgerRequest request) {
        // 查询该账本是否已经存在
        LedgerAgg ledgerAgg = ledgerDomainService.findByNo(request.getLedgerNo());
        if (ledgerAgg == null) {
            throw new AggNotExistsException(ResultCode.LEDGER_NOT_FOUND);
        }
        // 账本存在则更新
        ledgerAgg.save(request.getLedgerName(), request.getLedgerDesc(), request.getLedgerImage());
        ledgerDomainService.save(ledgerAgg);

        // 获取注册的事件进行发布
        List<DomainEvent> domainEventList = ledgerAgg.getDomainEvents();
        eventPublisher.publishEvent(domainEventList);
    }

    public void updateLedgerBudget(UpdateLedgerBudgetRequest request) {
        // 查询该账本是否已经存在
        LedgerAgg ledgerAgg = ledgerDomainService.findByNo(request.getLedgerNo());
        if (ledgerAgg == null) {
            throw new AggNotExistsException(ResultCode.LEDGER_NOT_FOUND);
        }
        // 账本存在则更新
        LedgerBudgetVO ledgerBudget = ledgerFactory.createLedgerBudget(request.getLedgerNo(), request.getBudgetAmount(), request.getBudgetDate());
        ledgerAgg.updateBudget(ledgerBudget);
        ledgerDomainService.save(ledgerAgg);

        // 获取注册的事件进行发布
        List<DomainEvent> domainEventList = ledgerAgg.getDomainEvents();
        eventPublisher.publishEvent(domainEventList);
    }

    public void joinLedger(JoinLedgerRequest request) {
        String userNo = UserContextHolder.getCurrentUserNo();
        // 1. 使用邀请码
        invitationDomainService.useInvitationCode(request.getInvitationCode(), userNo);

        // 查询账本信息
        InvitationAgg invitationAgg = invitationDomainService.loadByCode(
                new InvitationCodeVO(request.getInvitationCode()));
        LedgerAgg ledgerAgg = ledgerDomainService.findByNo(invitationAgg.getLedgerNo());

        // 2. 插入成员信息
        LedgerMemberEntity ledgerMember = ledgerFactory.createLedgerMember(
                ledgerAgg.getLedgerNo(), userNo, LedgerMemberRoleVO.MEMBER);
        ledgerAgg.addMember(ledgerMember);

        // 3. 保存账本信息
        ledgerDomainService.save(ledgerAgg);

        // 获取注册的事件进行发布
        List<DomainEvent> domainEventList = ledgerAgg.getDomainEvents();
        eventPublisher.publishEvent(domainEventList);
    }
}

@Service
@Slf4j
public class LedgerQueryApplicationService {

    @Resource
    private LedgerMapper ledgerMapper;

    @Resource
    private LedgerMemberMapper ledgerMemberMapper;

    @Resource
    private LedgerDomainService ledgerDomainService;

    @Resource
    private UserInfoService userInfoService;

    private List<LedgerListRes> convertToLedgerListResList(List<LedgerMemberPO> memberList, Map<String, LedgerPO> ledgerMap) {
        if (CollectionUtils.isEmpty(memberList)) {
            return Collections.emptyList();
        }
        return memberList.stream().map(member -> {return convertToLedgerListRes(member, ledgerMap.get(member.getLedgerNo()));}).filter(Objects::nonNull).collect(Collectors.toList());
    }

    private LedgerListRes convertToLedgerListRes(LedgerMemberPO memberPO, LedgerPO ledgerPO) {
        if (memberPO == null || ledgerPO == null) {
            return null;
        }
        LedgerListRes res = new LedgerListRes();
        res.setLedgerName(ledgerPO.getLedgerName());
        res.setLedgerImage(ledgerPO.getLedgerImage());
        res.setLedgerNo(ledgerPO.getLedgerNo());
        res.setLedgerDesc(ledgerPO.getLedgerDesc());
        res.setLedgerStatus(ledgerPO.getLedgerStatus());
        res.setCreateTime(LocalDateTimeUtil.format(ledgerPO.getCreateTime()));
        res.setUpdateTime(LocalDateTimeUtil.format(ledgerPO.getUpdateTime()));
        res.setRole(LedgerMemberRoleVO.of(memberPO.getRole()).getLabel());
        res.setJoinTime(LocalDateTimeUtil.format(memberPO.getJoinTime()));
        return res;
    }

    public LedgerDetailRes getLedger(QueryLedgerRequest request) {
        // 获取用户ID
        String userNo = UserContextHolder.getCurrentUserNo();
        // 加载账本聚合
        LedgerAgg ledgerAgg = ledgerDomainService.findByNo(request.getLedgerNo());
        if (ledgerAgg == null) {
            return null;
        }
        // 判断这个用户是否有查看权限
        if (!ledgerAgg.hasViewPermission(userNo)) {
            return null;
        }
        // 有查看权限则返回数据
        return convertToLedgerRes(ledgerAgg);
    }

    private LedgerDetailRes convertToLedgerRes(LedgerAgg ledgerAgg) {
        LedgerDetailRes res = new LedgerDetailRes();
        res.setLedgerNo(ledgerAgg.getLedgerNo());
        res.setLedgerName(ledgerAgg.getLedgerName());
        res.setLedgerDesc(ledgerAgg.getLedgerDesc());
        res.setLedgerStatus(ledgerAgg.getLedgerStatus().getLabel());
        res.setLedgerBudget(buildLedgerBudget(ledgerAgg.getLastLedgerBudget()));
        res.setLedgerSummary(buildLedgerSummary(ledgerAgg.getLastLedgerSummary()));
        return res;
    }

    private LedgerSummaryRes buildLedgerSummary(LedgerSummaryVO summaryVO) {
        LedgerSummaryRes res = new LedgerSummaryRes();
        res.setIncome(summaryVO.getIncome());
        res.setExpense(summaryVO.getExpense());
        res.setRemained(summaryVO.getRemained());
        return res;
    }

    private LedgerBudgetRes buildLedgerBudget(LedgerBudgetVO budgetPO) {
        LedgerBudgetRes res = new LedgerBudgetRes();
        res.setAmount(MoneyUtil.fen2Yuan(budgetPO.getBudgetAmount()));
        res.setUsed(MoneyUtil.fen2Yuan(budgetPO.getUsedAmount()));
        res.setRemained(MoneyUtil.fen2Yuan(budgetPO.getRemainedAmount()));
        res.setBudgetDate(LocalDateTimeUtil.format(budgetPO.getBudgetDate()));
        return res;
    }


    public PageRes<LedgerListRes> getLedgerList(QueryLedgerListRequest request) {
        // 获取用户ID
        String userNo = UserContextHolder.getCurrentUserNo();
        // 查询用户有哪些账本
        LambdaQueryWrapper<LedgerMemberPO> wrapper1 = new LambdaQueryWrapper<>();
        wrapper1.eq(LedgerMemberPO::getUserNo, userNo)
                .eq(LedgerMemberPO::getStatus, LedgerMemberStatusVO.NORMAL.getCode())
                .eq(LedgerMemberPO::getIsDeleted, false)
                .orderByDesc(LedgerMemberPO::getJoinTime);
        Page<LedgerMemberPO> pageList = ledgerMemberMapper.selectPage(Page.of(request.getPage(), request.getSize()),
                wrapper1);
        if (pageList.getTotal() == 0) {
            // 组装返回
            PageRes<LedgerListRes> pageRes = new PageRes<>();
            pageRes.setPageNum(pageList.getCurrent());
            pageRes.setPageSize(pageList.getSize());
            pageRes.setTotal(pageList.getTotal());
            pageRes.setList(Collections.emptyList());
            return pageRes;
        }
        // 查询用户账本信息
        List<String> ledgerNoList = pageList.getRecords().stream()
                .map(LedgerMemberPO::getLedgerNo).collect(Collectors.toList());
        LambdaQueryWrapper<LedgerPO> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(LedgerPO::getLedgerNo, ledgerNoList)
                .eq(LedgerPO::getIsDeleted, false);
        List<LedgerPO> ledgerList = ledgerMapper.selectList(wrapper);
        Map<String, LedgerPO> ledgerMap = ledgerList.stream()
                .collect(Collectors.toMap(LedgerPO::getLedgerNo, Function.identity()));

        // 组装返回
        PageRes<LedgerListRes> pageRes = new PageRes<>();
        pageRes.setPageNum(pageList.getCurrent());
        pageRes.setPageSize(pageList.getSize());
        pageRes.setTotal(pageList.getTotal());
        pageRes.setList(convertToLedgerListResList(pageList.getRecords(), ledgerMap));
        return pageRes;
    }

    public List<LedgerMemberListRes> getMemberList(QueryLedgerMemberListRequest request) {
        // 获取成员列表
        LambdaQueryWrapper<LedgerMemberPO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LedgerMemberPO::getLedgerNo, request.getLedgerNo())
                .eq(LedgerMemberPO::getStatus, LedgerMemberStatusVO.NORMAL.getCode())
                .eq(LedgerMemberPO::getIsDeleted, false);
        List<LedgerMemberPO> memberList = ledgerMemberMapper.selectList(wrapper);
        if (CollectionUtils.isEmpty(memberList)) {
            return Collections.emptyList();
        }
        // 判断权限
        String userNo = UserContextHolder.getCurrentUserNo();
        if (memberList.stream().noneMatch(member -> member.getUserNo().equals(userNo))) {
            // 没有权限
            return Collections.emptyList();
        }

        // 使用dubbo查询用户服务的用户信息
        List<String> userNoList = memberList.stream()
                .map(LedgerMemberPO::getUserNo)
                .collect(Collectors.toList());
        List<UserInfoBO> userBOList = userInfoService.batchQueryUserInfo(userNoList);
        Map<String, UserInfoBO> userBOMap = userBOList.stream()
                .collect(Collectors.toMap(UserInfoBO::getUserNo, Function.identity()));

        // 转换返回
        return memberList.stream()
                .map(member -> convertToMemberListRes(member, userBOMap.get(member.getUserNo())))
                .collect(Collectors.toList());
    }

    private LedgerMemberListRes convertToMemberListRes(LedgerMemberPO memberPO, UserInfoBO userBO) {
        LedgerMemberListRes res = new LedgerMemberListRes();
        res.setUserNo(memberPO.getUserNo());
        res.setRole(LedgerMemberRoleVO.of(memberPO.getRole()).getLabel());
        res.setJoinTime(LocalDateTimeUtil.format(memberPO.getJoinTime()));

        if (userBO != null) {
            res.setUsername(userBO.getUserName());
            res.setAvatar(userBO.getUserAvatar());
        }

        return res;
    }
}

@Data
@Builder
public class LedgerAgg extends AbstractAgg {
    private Long id;
    private String ledgerNo;
    private String ledgerName;
    private String ownerNo;
    private LedgerStatusVO ledgerStatus;
    private String ledgerDesc;
    private String ledgerImage;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private Boolean isDeleted;

    // 最新的一个预算信息
    private LedgerBudgetVO lastLedgerBudget;

    // 最新的一个汇总信息
    private LedgerSummaryVO lastLedgerSummary;

    // 账本成员列表
    private Set<LedgerMemberEntity> memberSet;

    // 插入成员列表
    public void addMember(LedgerMemberEntity member) {
        if (memberSet == null) {
            memberSet = new HashSet<>();
        }
        memberSet.add(member);
        // 创建用户加入账本事件
        registerDomainEvent(new UserJoinedLedgerEvent(this));
    }

    public void delete() {
        if (memberSet != null) {
            memberSet.forEach(LedgerMemberEntity::delete);
        }
        if (lastLedgerBudget != null) {
            lastLedgerBudget.delete();
        }
        isDeleted = true;
        // 删除账本事件
        registerDomainEvent(new LedgerDeletedEvent(this));
    }

    public void deleteTransaction(Integer amount) {
        // 增加预算
        lastLedgerBudget.increase(amount);
    }

    public void transaction(Integer amount, TransactionTypeVO transactionType) {
        //判断收入 or 支出
        if (transactionType.isExpenditure()) {
            // 支出，减少预算
            lastLedgerBudget.reduce(amount);
        }
    }

    public void save(String ledgerName, String ledgerDesc, String ledgerImage) {
        updateSelf(ledgerName, ledgerDesc, ledgerImage);

        // 创建账本更新事件
        registerDomainEvent(new LedgerUpdatedEvent(this));
    }
    
    public void updateBudget(LedgerBudgetVO ledgerBudget) {
        lastLedgerBudget = ledgerBudget;
    }

    private void updateSelf(String ledgerName, String ledgerDesc, String ledgerImage) {
        this.ledgerName = ledgerName;
        this.ledgerDesc = ledgerDesc;
        this.ledgerImage = ledgerImage;
    }

    public void create() {
        ledgerStatus = LedgerStatusVO.NORMAL;
        createTime = LocalDateTime.now();
        updateTime = createTime;

        // 注册账本已创建事件
        registerDomainEvent(new LedgerCreatedEvent(this));
    }

    public Boolean checkUserPermission(String userNo) {
        return ownerNo.equals(userNo);
    }

    public Boolean hasViewPermission(String userNo) {
        return memberSet.stream().anyMatch(member -> member.getUserNo().equals(userNo));
    }
}

@Data
@Builder
public class TransactionStatementAgg extends AbstractAgg {
    private Long id;
    private String transactionStatementNo;
    private String ledgerNo;
    private Integer amount;
    private TransactionTypeVO transactionType;
    private LocalDateTime transactionTime;
    private String transactionDesc;
    private Integer transactionStatus;
    // 分类信息快照
    private CategorySnapshotVO categorySnapshot;
    // 分类信息引用
    private CategoryVO category;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;

    private Boolean deleted;

    public void create() {
        LocalDateTime now = LocalDateTime.now();
        this.setCreateTime(now);
        this.setUpdateTime(now);
        this.setTransactionTime(now);

        // 注册交易流水已创建事件
        registerDomainEvent(new TransactionStatementCreatedEvent(this));
    }

    public void delete() {
        deleted = true;
        updateTime = LocalDateTime.now();
        // 注册交易流水已删除事件
        registerDomainEvent(new TransactionStatementCreatedEvent(this));
    }
}

public class Money {

    public static final Money ZERO = new Money(BigDecimal.ZERO);

    private final BigDecimal amount;

    private Money(BigDecimal amount) {
        if (amount == null) {
            throw new IllegalArgumentException("金额不能为空");
        }
        this.amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public static Money of(BigDecimal amount) {
        return new Money(amount);
    }

    public static Money of(double amount) {
        return new Money(BigDecimal.valueOf(amount));
    }

    public Money add(Money other) {
        return new Money(this.amount.add(other.amount));
    }

    public Money subtract(Money other) {
        return new Money(this.amount.subtract(other.amount));
    }

    public boolean lessThanOrEqual(Money other) {
        return this.amount.compareTo(other.amount) <= 0;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money money = (Money) obj;
        return amount.equals(money.amount);
    }

    @Override
    public int hashCode() {
        return amount.hashCode();
    }
}

@Repository
public class LedgerRepositoryImpl implements LedgerRepository {

    @Resource
    private LedgerMapper ledgerMapper;

    @Resource
    private LedgerBudgetMapper ledgerBudgetMapper;

    @Resource
    private LedgerMemberMapper ledgerMemberMapper;

    @Resource
    private TransactionStatementMapper transactionStatementMapper;

    @Resource
    private LedgerFactory ledgerFactory;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insert(LedgerAgg ledgerAgg) {
        // 插入账本信息
        LedgerPO ledgerPO = this.toPO(ledgerAgg);
        ledgerMapper.insert(ledgerPO);

        // 插入账本预算信息
        LedgerBudgetPO ledgerBudgetPO = toLedgerBudgetPO(ledgerAgg.getLastLedgerBudget());
        ledgerBudgetMapper.insert(ledgerBudgetPO);

        // 插入成员信息
        saveMemberSet(ledgerAgg.getMemberSet());
    }

    private void insertMember(Set<LedgerMemberEntity> memberSet) {
        LedgerMemberEntity memberEntity = memberSet.stream().findFirst().orElse(null);
        if (memberEntity == null) {
            return;
        }
        ledgerMemberMapper.insert(toMemberPO(memberEntity));
    }

    private LedgerPO toPO(LedgerAgg userAgg) {
        return LedgerPO.builder()
                .id(userAgg.getId())
                .ledgerName(userAgg.getLedgerName())
                .ledgerNo(userAgg.getLedgerNo())
                .ledgerStatus(userAgg.getLedgerStatus().getCode())
                .ownerNo(userAgg.getOwnerNo())
                .ledgerDesc(userAgg.getLedgerDesc())
                .ledgerImage(userAgg.getLedgerImage())
                .isDeleted(userAgg.getIsDeleted())
                .build();
    }

    private LedgerBudgetPO toLedgerBudgetPO(LedgerBudgetVO ledgerBudgetVO) {
        return LedgerBudgetPO.builder()
                .id(ledgerBudgetVO.getId())
                .ledgerNo(ledgerBudgetVO.getLedgerNo())
                .budgetAmount(ledgerBudgetVO.getBudgetAmount())
                .usedAmount(ledgerBudgetVO.getUsedAmount())
                .remainedAmount(ledgerBudgetVO.getRemainedAmount())
                .budgetDate(ledgerBudgetVO.getBudgetDate())
                .isDeleted(ledgerBudgetVO.getIsDeleted())
                .build();
    }

    private LedgerMemberPO toMemberPO(LedgerMemberEntity memberEntity) {
        return LedgerMemberPO.builder()
                .id(memberEntity.getId())
                .ledgerNo(memberEntity.getLedgerNo())
                .userNo(memberEntity.getUserNo())
                .role(memberEntity.getRole().getCode())
                .joinTime(memberEntity.getJoinTime())
                .status(memberEntity.getStatus().getCode())
                .isDeleted(memberEntity.getIsDeleted())
                .build();
    }

    public LedgerAgg findByNameInUser(String name, String userNo) {
        // 查询账本基本信息
        LambdaQueryWrapper<LedgerPO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LedgerPO::getLedgerName, name)
                .eq(LedgerPO::getOwnerNo, userNo);
        LedgerPO ledgerPO = ledgerMapper.selectOne(wrapper);
        if (ledgerPO == null) {
            return null;
        }
        return toEntity(ledgerPO, null, null, 0L, 0L);
    }

    private LedgerAgg toEntity(LedgerPO ledgerPO, LedgerBudgetPO ledgerBudgetPO, List<LedgerMemberPO> memberList, Long income, Long expense) {
        LedgerAgg ledgerAgg = LedgerAgg.builder()
                .id(ledgerPO.getId())
                .ledgerName(ledgerPO.getLedgerName())
                .ledgerNo(ledgerPO.getLedgerNo())
                .ledgerStatus(LedgerStatusVO.of(ledgerPO.getLedgerStatus()))
                .ownerNo(ledgerPO.getOwnerNo())
                .ledgerDesc(ledgerPO.getLedgerDesc())
                .ledgerImage(ledgerPO.getLedgerImage())
                .createTime(ledgerPO.getCreateTime())
                .updateTime(ledgerPO.getUpdateTime())
                .build();
        // 预算信息
        if (ledgerBudgetPO != null) {
            LedgerBudgetVO ledgerBudgetVO = LedgerBudgetVO.builder()
                    .ledgerNo(ledgerBudgetPO.getLedgerNo())
                    .budgetAmount(ledgerBudgetPO.getBudgetAmount())
                    .usedAmount(ledgerBudgetPO.getUsedAmount())
                    .remainedAmount(ledgerBudgetPO.getRemainedAmount())
                    .budgetDate(ledgerBudgetPO.getBudgetDate())
                    .createTime(ledgerBudgetPO.getCreateTime())
                    .updateTime(ledgerBudgetPO.getUpdateTime())
                    .build();
            ledgerAgg.setLastLedgerBudget(ledgerBudgetVO);
        }
        if (!CollectionUtils.isEmpty(memberList)) {
            Set<LedgerMemberEntity> memberSet = new HashSet<>();
            memberList.forEach(member -> {
                LedgerMemberEntity memberEntity = LedgerMemberEntity.builder()
                        .id(member.getId())
                        .ledgerNo(member.getLedgerNo())
                        .userNo(member.getUserNo())
                        .joinTime(member.getJoinTime())
                        .role(LedgerMemberRoleVO.of(member.getRole()))
                        .status(LedgerMemberStatusVO.of(member.getStatus()))
                        .createTime(member.getCreateTime())
                        .updateTime(member.getUpdateTime())
                        .build();
                memberSet.add(memberEntity);
            });
            ledgerAgg.setMemberSet(memberSet);
        }
        LedgerSummaryVO ledgerSummaryVO = ledgerFactory.createLedgerSummary(income, expense);
        ledgerAgg.setLastLedgerSummary(ledgerSummaryVO);
        return ledgerAgg;
    }

    @Override
    public LedgerAgg load(String ledgerNo) {
        // 查询账本基本信息
        LambdaQueryWrapper<LedgerPO>  wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LedgerPO::getLedgerNo, ledgerNo)
                .last("limit 1");
        LedgerPO ledgerPO = ledgerMapper.selectOne(wrapper);
        if (ledgerPO == null) {
            return null;
        }
        // 查询账本最新的预算信息
        LambdaQueryWrapper<LedgerBudgetPO> wrapperBudget = new LambdaQueryWrapper<>();
        wrapperBudget.eq(LedgerBudgetPO::getLedgerNo, ledgerPO.getLedgerNo())
                .orderByDesc(LedgerBudgetPO::getId)
                .last("limit 1");
        LedgerBudgetPO ledgerBudgetPO = ledgerBudgetMapper.selectOne(wrapperBudget);

        // 加载成员信息
        LambdaQueryWrapper<LedgerMemberPO> wrapperMember = new LambdaQueryWrapper<>();
        wrapperMember.eq(LedgerMemberPO::getLedgerNo, ledgerPO.getLedgerNo())
                .orderByDesc(LedgerMemberPO::getId)
                .last("limit 10");
        List<LedgerMemberPO> memberList = ledgerMemberMapper.selectList(wrapperMember);

        // 加载汇总信息
        Long incomeAmount = transactionStatementMapper.getSummaryAmount(ledgerPO.getLedgerNo(), TransactionTypeVO.INCOME.getCode());
        Long expenditureAmount = transactionStatementMapper.getSummaryAmount(ledgerPO.getLedgerNo(), TransactionTypeVO.EXPENDITURE.getCode());
        return toEntity(ledgerPO, ledgerBudgetPO, memberList, incomeAmount, expenditureAmount);
    }

    @Override
    public void update(LedgerAgg ledgerAgg) {
        // 插入账本信息
        LedgerPO ledgerPO = this.toPO(ledgerAgg);
        ledgerMapper.updateById(ledgerPO);

        // 插入账本预算信息
        LedgerBudgetPO ledgerBudgetPO = toLedgerBudgetPO(ledgerAgg.getLastLedgerBudget());
        // 查询预算是否存在，决定插入还是更新
        LambdaQueryWrapper<LedgerBudgetPO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LedgerBudgetPO::getLedgerNo, ledgerBudgetPO.getLedgerNo())
                .eq(LedgerBudgetPO::getBudgetDate, LocalDateTimeUtil.format(ledgerBudgetPO.getBudgetDate(), LocalDateTimeUtil.DATE_FORMATTER_MONTH_ONE));
        LedgerBudgetPO budget = ledgerBudgetMapper.selectOne(wrapper);
        if (budget == null) {
            ledgerBudgetMapper.insert(ledgerBudgetPO);
        } else {
            ledgerBudgetPO.setId(budget.getId());
            ledgerBudgetPO.setUsedAmount(budget.getUsedAmount());
            ledgerBudgetPO.setRemainedAmount(ledgerBudgetPO.getBudgetAmount() - ledgerBudgetPO.getUsedAmount());
            ledgerBudgetMapper.updateById(ledgerBudgetPO);
        }

        // 更新成员信息
        saveMemberSet(ledgerAgg.getMemberSet());
    }

    private void saveMemberSet(Set<LedgerMemberEntity> memberSet) {
        if (CollectionUtils.isEmpty(memberSet)) {
            return;
        }
        memberSet.forEach(member -> {
            if (member.getId() == null) {
                ledgerMemberMapper.insert(toMemberPO(member));
            } else {
                ledgerMemberMapper.updateById(toMemberPO(member));
            }
        });
    }

    public Boolean exists(String ledgerNo) {
        LambdaQueryWrapper<LedgerPO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(LedgerPO::getLedgerNo, ledgerNo);
        return ledgerMapper.exists(wrapper);
    }

}

public class AuthController{
    @Resource
    private AuthenticationFacade facade;

    public AuthResponse login(AuthRequest req) {
        //1. 参数校验
        validate(req);
        // 2. 调用登陆门面进行登陆
        AuthResponse res = facade.authenticate(req);
        // 3. 返回用户信息
        return res;
    }
}

public class AuthenticationFacade{

    @Resource
    private AuthStrategyFactory factory;

    public AuthResponse authenticate(AuthRequest req) {
        // 1. 通过工厂获取对应的策略
        AuthStrategy strategy = factory.getStrategy(req.getType);
        // 2. 构建请求参数
        AuthContext ctx = new AuthContext();
        // 3. 执行对应的登陆策略
        AuthResult result = strategy.authenticate(ctx);
        // 4. 返回结果
        AuthResponse res = convert(result);
        return res;
    }
}

public class AuthStrategyFactory{
    private Map<AuthType, AuthStrategy> loginStrategyMap;

    @Resource
    private List<AuthStrategy> loginStrategies;

    @PostConstruct
    public void init() {
        // 初始化的时候注册登陆策略
        loginStrategies.forEach(loginStrategy -> register(loginStrategy.supports(), loginStrategy));
    }

    public AuthStrategy getStrategy(AuthType type) {
        // 返回策略
        // 这里还需要判断如果没有实现这个策略怎么处理
        return loginStrategyMap.get(type);
    }

    public void register(AuthType type, AuthStrategy strategy) {
        loginStrategyMap.put(type, strategy);
    }

}

public interface AuthStrategy{
    AuthType supports();
    AuthResult authenticate(AuthContext ctx);
}

// 实现用户名密码登陆策略
public class UsernamePasswordStrategy implements AuthStrategy{
    public AuthType supports() {
        return AuthType.USERNAME_PASSWORD;
    }

    public AuthResult authenticate(AuthContext ctx) {
        // 处理逻辑
    }
}

// 实现手机号验证码登陆逻辑
public class SmsCodeStrategy implements AuthStrategy{
    public AuthType supports() {
        return AuthType.SMS;
    }

    public AuthResult authenticate(AuthContext ctx) {
        // 处理逻辑
    }
}

// 实现微信OpenId登陆逻辑
public class WechatOpenIdStrategy implements AuthStrategy{
    public AuthType supports() {
        return AuthType.WECHAT_OPENID;
    }

    public AuthResult authenticate(AuthContext ctx) {
        // 处理逻辑
    }
}