// CompleteInvestmentProfileRequest.java
public record CompleteInvestmentProfileRequest(
    @Schema(description = "투자성향 유형", example = "CONSERVATIVE")
    InvestmentProfile.InvestmentProfileType investmentProfile,
    
    @Schema(description = "투자가능 자산", example = "10000000.00")
    BigDecimal availableAssets,
    
    @Schema(description = "투자 목표", example = "EDUCATION")
    InvestmentProfile.InvestmentGoal investmentGoal,
    
    @Schema(description = "감당가능 손실", example = "TEN_PERCENT")
    InvestmentProfile.LossTolerance lossTolerance,
    
    @Schema(description = "금융 이해도", example = "MEDIUM")
    InvestmentProfile.FinancialKnowledge financialKnowledge,
    
    @Schema(description = "기대 이익", example = "TWO_HUNDRED_PERCENT")
    InvestmentProfile.ExpectedProfit expectedProfit,
    
    @Schema(description = "관심섹터명 목록", example = "[\"전기·전자\", \"건설\", \"IT 서비스\"]")
    List<String> interestedSectorNames
) {}

// ChatRequest.java
public record ChatRequest(
    String message,
    String user_id,
    String session_id
) {}

// PortfolioResponse.java
public record PortfolioResponse(
    Long portfolioId,
    String userId,
    List<RecommendedStock> recommendedStocks,
    BigDecimal allocationSavings,
    BigDecimal highestValue,
    BigDecimal lowestValue,
    LocalDateTime createdAt,
    LocalDateTime updatedAt
) {
    public record RecommendedStock(
        String stockId,
        String stockName,
        BigDecimal allocationPct,
        String sectorName,
        String reason
    ) {}
}

// PortfolioRiskAnalysisResponse.java
public record PortfolioRiskAnalysisResponse(
    BigDecimal originalInvestment,
    BigDecimal highestValue,
    BigDecimal lowestValue,
    BigDecimal currentValue,
    BigDecimal highestReturn,
    BigDecimal lowestReturn,
    BigDecimal currentReturn,
    String riskLevel
) {
    public static PortfolioRiskAnalysisResponse getDefault(BigDecimal investment) {
        return new PortfolioRiskAnalysisResponse(
            investment, investment, investment, investment,
            BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, "MEDIUM"
        );
    }
}

// ChatResponse.java
public record ChatResponse(
    String replyText,
    boolean success,
    String errorMessage
) {}

// InvestmentProfile.java
@Entity
@Table(name = "investment_profiles")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class InvestmentProfile extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long profileId;
    
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "userId", nullable = false)
    private User user;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private InvestmentProfileType investmentProfile;
    
    @Column(nullable = false, precision = 15, scale = 2)
    private BigDecimal availableAssets;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private InvestmentGoal investmentGoal;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private LossTolerance lossTolerance;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private FinancialKnowledge financialKnowledge;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private ExpectedProfit expectedProfit;
    
    @OneToMany(mappedBy = "investmentProfile", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<InvestmentProfileSector> investmentProfileSectors = new ArrayList<>();
    
    public enum InvestmentProfileType {
        CONSERVATIVE("안정형"),
        CONSERVATIVE_SEEKING("안정추구형"),
        RISK_NEUTRAL("위험중립형"),
        AGGRESSIVE("적극투자형"),
        VERY_AGGRESSIVE("공격투자형");
    }
    
    public enum InvestmentGoal {
        EDUCATION("학비"),
        LIVING_EXPENSES("생활비"),
        HOUSE_PURCHASE("주택마련"),
        ASSET_GROWTH("자산증식"),
        DEBT_REPAYMENT("채무상환");
    }
    
    public enum LossTolerance {
        NO_LOSS("원금 손실 없음"),
        TEN_PERCENT("원금의 10%"),
        THIRTY_PERCENT("원금의 30%"),
        FIFTY_PERCENT("원금의 50%"),
        SEVENTY_PERCENT("원금의 70%"),
        FULL_AMOUNT("원금 전액");
    }
}

// Portfolio.java
@Entity
@Table(name = "portfolios")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Portfolio extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long portfolioId;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "userId", nullable = false)
    private User user;
    
    @Column(nullable = false, length = 100)
    private String portfolioName;
    
    @Column(precision = 18, scale = 2)
    private BigDecimal highestValue;
    
    @Column(precision = 18, scale = 2)
    private BigDecimal lowestValue;
    
    @OneToMany(mappedBy = "portfolio", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<PortfolioStock> portfolioStocks = new ArrayList<>();
    
    public void updatePortfolio(String portfolioName, BigDecimal highestValue, BigDecimal lowestValue) {
        this.portfolioName = portfolioName;
        this.highestValue = highestValue;
        this.lowestValue = lowestValue;
    }
}

// InvestmentProfileRepository.java
public interface InvestmentProfileRepository extends JpaRepository<InvestmentProfile, Long> {
    Optional<InvestmentProfile> findByUserUserId(String userId);
    boolean existsByUserUserId(String userId);
}

// PortfolioRepository.java
public interface PortfolioRepository extends JpaRepository<Portfolio, Long> {
    List<Portfolio> findByUserUserIdOrderByCreatedAtDesc(String userId);
}

// PortfolioStockRepository.java
public interface PortfolioStockRepository extends JpaRepository<PortfolioStock, Long> {
    List<PortfolioStock> findByPortfolioPortfolioId(Long portfolioId);
}

// InvestmentProfileService.java (발췌)
@Service
@RequiredArgsConstructor
public class InvestmentProfileService {
    private final InvestmentProfileRepository investmentProfileRepository;
    private final UserRepository userRepository;
    
    public InvestmentProfile createInvestmentProfile(String userId, 
                                                   InvestmentProfileType investmentProfile,
                                                   BigDecimal availableAssets,
                                                   InvestmentGoal investmentGoal,
                                                   LossTolerance lossTolerance,
                                                   FinancialKnowledge financialKnowledge,
                                                   ExpectedProfit expectedProfit,
                                                   List<String> interestedSectorNames) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> PortfolioException.userNotFound(userId));
        
        InvestmentProfile profile = InvestmentProfile.builder()
                .user(user)
                .investmentProfile(investmentProfile)
                .availableAssets(availableAssets)
                .investmentGoal(investmentGoal)
                .lossTolerance(lossTolerance)
                .financialKnowledge(financialKnowledge)
                .expectedProfit(expectedProfit)
                .build();
        
        return investmentProfileRepository.save(profile);
    }
    
    public Optional<InvestmentProfile> getInvestmentProfileByUserId(String userId) {
        return investmentProfileRepository.findByUserUserId(userId);
    }
}

// PortfolioService.java (발췌)
@Service
@RequiredArgsConstructor
public class PortfolioService {
    private final PortfolioRepository portfolioRepository;
    private final UserRepository userRepository;
    
    public Portfolio createPortfolio(String userId, String portfolioName,
                                   BigDecimal highestValue, BigDecimal lowestValue) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> PortfolioException.userNotFound(userId));
        
        Portfolio portfolio = Portfolio.builder()
                .user(user)
                .portfolioName(portfolioName)
                .highestValue(highestValue)
                .lowestValue(lowestValue)
                .build();
        return portfolioRepository.save(portfolio);
    }
    
    public List<Portfolio> findPortfoliosByUserId(String userId) {
        return portfolioRepository.findByUserUserIdOrderByCreatedAtDesc(userId);
    }
}

// PortfolioRiskService.java (발췌)
@Service
@RequiredArgsConstructor
public class PortfolioRiskService {
    private final StockCurrentPriceApiClient stockCurrentPriceApiClient;
    
    public PortfolioRiskAnalysisResponse calculatePortfolioRisk(
            List<CompleteInvestmentProfileResponse.RecommendedStock> recommendedStocks, 
            BigDecimal investmentAmount) {
        BigDecimal totalHighValue = BigDecimal.ZERO;
        BigDecimal totalLowValue = BigDecimal.ZERO;
        BigDecimal currentValue = BigDecimal.ZERO;
        
        for (CompleteInvestmentProfileResponse.RecommendedStock stock : recommendedStocks) {
            StockPriceInfoResponse priceInfo = getStockPriceInfo(stock.stockId());
            
            BigDecimal stockInvestment = investmentAmount
                    .multiply(stock.allocationPct())
                    .divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP);
            
            BigDecimal highValue = stockInvestment
                    .multiply(priceInfo.w52HighPrice())
                    .divide(priceInfo.currentPrice(), 2, RoundingMode.HALF_UP);
            
            BigDecimal lowValue = stockInvestment
                    .multiply(priceInfo.w52LowPrice())
                    .divide(priceInfo.currentPrice(), 2, RoundingMode.HALF_UP);
            
            totalHighValue = totalHighValue.add(highValue);
            totalLowValue = totalLowValue.add(lowValue);
            currentValue = currentValue.add(stockInvestment);
        }
        
        BigDecimal highReturn = calculateReturnRate(investmentAmount, totalHighValue);
        BigDecimal lowReturn = calculateReturnRate(investmentAmount, totalLowValue);
        
        return new PortfolioRiskAnalysisResponse(
                investmentAmount, totalHighValue, totalLowValue, currentValue,
                highReturn, lowReturn, BigDecimal.ZERO,
                calculateRiskLevel(highReturn, lowReturn)
        );
    }
    
    private String calculateRiskLevel(BigDecimal highReturn, BigDecimal lowReturn) {
        BigDecimal riskRange = highReturn.subtract(lowReturn);
        if(riskRange.compareTo(BigDecimal.valueOf(50)) > 0) return "HIGH";
        else if (riskRange.compareTo(BigDecimal.valueOf(20)) > 0) return "MEDIUM";
        else return "LOW";
    }
}

// PortfolioUseCase.java (발췌)
@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class PortfolioUseCase {
    private final InvestmentProfileService investmentProfileService;
    private final PortfolioService portfolioService;
    private final PortfolioStockService portfolioStockService;
    private final LLMApiClient llmApiClient;
    private final PortfolioRiskService portfolioRiskCalculator;
    
    @Transactional
    public PortfolioResponse generateAiPortfolioRecommendation(String userId) {
        // 1. 투자 프로필 조회
        InvestmentProfile investmentProfile = investmentProfileService.getInvestmentProfileByUserId(userId)
                .orElseThrow(() -> PortfolioException.investmentProfileNotFound());
        
        // 2. LLM API 호출하여 포트폴리오 추천 받음
        InvestmentProfileResponse profileResponse = investmentProfileService.toInvestmentProfileResponse(investmentProfile);
        Map<String, Object> aiResponse = llmApiClient.requestPortfolioRecommendation(profileResponse);
        CompleteInvestmentProfileResponse llmResponse = convertAiResponseToCompleteInvestmentProfileResponse(aiResponse);
        
        // 3. 위험도 분석 수행
        List<CompleteInvestmentProfileResponse.RecommendedStock> safeStocks =
                Optional.ofNullable(llmResponse.recommendedStocks()).orElse(Collections.emptyList());
        
        PortfolioRiskAnalysisResponse riskAnalysis = portfolioRiskCalculator.calculatePortfolioRisk(
                safeStocks, investmentProfile.getAvailableAssets()
        );
        
        // 4. 포트폴리오 엔티티 생성 및 저장
        Portfolio portfolio = portfolioService.createPortfolio(
                userId, "AI 추천 포트폴리오",
                riskAnalysis.highestValue(), riskAnalysis.lowestValue()
        );
        
        // 5. 포트폴리오에 주식 추가
        for (CompleteInvestmentProfileResponse.RecommendedStock stock : safeStocks) {
            portfolioStockService.addStockToPortfolio(portfolio.getPortfolioId(), 
                    stock.stockId(), stock.allocationPct());
        }
        
        // 6. PortfolioResponse 반환
        return new PortfolioResponse(
                portfolio.getPortfolioId(), userId,
                convertToPortfolioRecommendedStocks(safeStocks),
                llmResponse.allocationSavings(),
                riskAnalysis.highestValue(), riskAnalysis.lowestValue(),
                portfolio.getCreatedAt(), portfolio.getUpdatedAt()
        );
    }
}

// InvestmentProfileUseCase.java (발췌)
@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class InvestmentProfileUseCase {
    private final InvestmentProfileService investmentProfileService;
    private final UserRepository userRepository;
    
    @Transactional
    public InvestmentProfileResponse completeInvestmentProfile(String userId, CompleteInvestmentProfileRequest request) {
        Optional<InvestmentProfile> existingProfile = investmentProfileService.getInvestmentProfileByUserId(userId);
        InvestmentProfile profile;
        
        if (existingProfile.isPresent()) {
            profile = investmentProfileService.updateInvestmentProfile(
                existingProfile.get().getProfileId(), 
                request.investmentProfile(), request.availableAssets(),
                request.investmentGoal(), request.lossTolerance(),
                request.financialKnowledge(), request.expectedProfit(),
                request.interestedSectorNames()
            );
        } else {
            profile = investmentProfileService.createInvestmentProfile(
                userId, request.investmentProfile(), request.availableAssets(),
                request.investmentGoal(), request.lossTolerance(),
                request.financialKnowledge(), request.expectedProfit(),
                request.interestedSectorNames()
            );
        }
        return investmentProfileService.toInvestmentProfileResponse(profile);
    }
}

// ChatUseCase.java (발췌)
@Service
@RequiredArgsConstructor
public class ChatUseCase {
    private final ChatSessionService chatSessionService;
    
    @Transactional
    public ChatResponse processChat(ChatRequest request, String userId) {
        ChatRequest chatRequest = new ChatRequest(
                request.message(), userId, request.session_id()
        );
        return chatSessionService.processChat(chatRequest);
    }
}

// InvestmentProfileController.java (발췌)
@RestController
@RequestMapping("/api/user/investment-profile")
@RequiredArgsConstructor
@Tag(name = "InvestmentProfile", description = "투자성향 프로필 관리 API")
public class InvestmentProfileController implements BaseApi {
    
    private final InvestmentProfileUseCase investmentProfileUseCase;
    private final PortfolioUseCase portfolioRecommendationUseCase;
    
    @PostMapping("/complete")
    @Operation(summary = "투자성향 설문 완료", description = "투자성향 설문을 완료, 새 프로필을 생성 및 저장합니다.")
    public BaseResponse<InvestmentProfileResponse> completeInvestmentProfile(
            @RequestBody CompleteInvestmentProfileRequest request) {
        String userId = SecurityUtils.getCurrentUserId();
        InvestmentProfileResponse profile = investmentProfileUseCase.completeInvestmentProfile(userId, request);
        return BaseResponse.onSuccess(profile);
    }
    
    @PostMapping("/send-to-llm")
    @Operation(summary = "LLM 포트폴리오 추천 요청", description = "투자성향 프로필을 기반으로 포트폴리오를 생성하고 저장합니다.")
    public BaseResponse<PortfolioResponse> sendProfileToLLM() {
        String userId = SecurityUtils.getCurrentUserId();
        PortfolioResponse response = portfolioRecommendationUseCase.generateAiPortfolioRecommendation(userId);
        return BaseResponse.onSuccess(response);
    }
    
    @GetMapping("/exists")
    @Operation(summary = "투자성향 완료 여부 확인", description = "사용자가 투자성향 설문을 완료했는지 확인합니다.")
    public BaseResponse<Boolean> hasCompletedInvestmentProfile() {
        String userId = SecurityUtils.getCurrentUserId();
        boolean exists = investmentProfileUseCase.hasCompletedInvestmentProfile(userId);
        return BaseResponse.onSuccess(exists);
    }
}

// AiChatController.java (발췌)
@RestController
@RequestMapping("/api/ai/chat")
@RequiredArgsConstructor
@Tag(name = "AI 챗봇", description = "AI 챗봇과의 대화 관련 API")
@SecurityRequirement(name = "X-User-Id")
public class AiChatController implements BaseApi {
    
    private final ChatUseCase chatUseCase;
    
    @PostMapping
    @Operation(summary = "AI 챗봇 채팅", description = "AI 챗봇과 대화를 진행합니다.")
    public BaseResponse<ChatResponse> chat(@Valid @RequestBody ChatRequest request) {
        String userId = SecurityUtils.getCurrentUserId();
        ChatResponse response = chatUseCase.processChat(request, userId);
        return BaseResponse.onSuccess(response);
    }
}