package analyzer

import kotlinx.serialization.Serializable
import model.CandleData
import kotlin.math.abs
import kotlin.text.toDouble
import kotlin.text.toInt



data class InvestmentScores(
    val ultraShort: Int, // 초단기 (분봉/에너지)
    val shortTerm: Int,  // 단기 (일봉/뉴스)
    val midTerm: Int,    // 중기 (주봉/재무)
    val longTerm: Int    // 장기 (월봉/펀더멘털)
) {
    override fun toString(): String {
        return """
        평점  : ${avg()} 
        초단  : $ultraShort
        단기  : $shortTerm
        중기  : $midTerm
        장기  : $longTerm
        """.trimIndent()
    }
    fun avg() = listOf(ultraShort, shortTerm, midTerm, longTerm).average()
}

@Serializable
class TechnicalAnalyzer {
    // 주의: min30은 '30분봉'이 아니라 '1분 단위 캔들 30개'를 의미합니다.
    var min30: List<CandleData> = emptyList()
    var daily: List<CandleData> = emptyList()
    var weekly: List<CandleData> = emptyList()
    var monthly: List<CandleData> = emptyList()

    fun isValid() = listOf(min30, monthly, weekly, daily).all { it.isNotEmpty() }

    /**
     * 기술적 지표와 추세, 그리고 초단기(Micro) 흐름을 결합한 종합 신호 생성
     */
    fun generateComprehensiveSignal(): ScalpingSignalModel {
        val scalpingAnalyzer = ScalpingAnalyzer()
        val dailyBullish = isDailyBullish()

        // 1. 기본 스캘핑 신호 생성
        val baseSignal = scalpingAnalyzer.analyze(min30.toScalpingList(), dailyBullish)
        var refinedScore = baseSignal.compositeScore.toDouble()

        // 2. 점수 정교화 (가점/감점 요인)
        // [보완] 추세 동기화 가점: 월/주/일봉이 모두 상승 추세일 때
        if (calculateChange(monthly) > 0 && calculateChange(weekly) > 0 && calculateChange(daily.takeLast(5)) > 0) {
            refinedScore += 10.0
        }

        // [보완] 자금 유입 강도(MFI) 반영
        val mfi = calculateMFI(min30)
        when {
            mfi > 80.0 -> refinedScore -= 15.0 // 과매수 권역 감점
            mfi < 20.0 -> refinedScore -= 5.0  // 자금 유출 감점
            mfi in 45.0..65.0 -> refinedScore += 5.0 // 안정적 수급 구간
        }

        // [보완] 변동성 돌파 확인 (ATR 대비 현재 몸통 크기)
        val atr = calculateATR(min30)
        val lastCandle = min30.last()
        val bodyRange = abs(lastCandle.stck_prpr.toDouble() - lastCandle.stck_oprc.toDouble())
        if (bodyRange > atr * 1.2) refinedScore += 7.0

        // 🚀 [마이크로 분석] 기존 min30 리스트를 재활용하여 최근 5분간의 초단기 흐름 분석
        if (min30.size >= 15) {
            val last5Candles = min30.takeLast(5) // 최근 5분(5개 캔들)

            // ① 초단기 추세 가감점 (최근 5분간 변화율)
            val microChange = calculateChange(last5Candles)
            if (microChange > 1.5) refinedScore += 6.0 // 순간 급등세 (수급 유입)
            else if (microChange < -1.5) refinedScore -= 12.0 // 순간 투매 방어 (강력 감점)

            // ② 초단기 거래량 급증 (V-Spike) 확인
            val recentVolume = last5Candles.map { it.cntg_vol.toDouble() }.average()
            val pastVolume = min30.dropLast(5).takeLast(10).map { it.cntg_vol.toDouble() }.average() // 그 이전 10분 평균

            if (pastVolume > 0 && recentVolume > pastVolume * 2.5) {
                // 평소보다 거래량이 2.5배 터졌을 때, 양봉이면 매수세 폭발, 음봉이면 쏟아내는 투매 물량
                val isBullishMicro = lastCandle.stck_prpr.toDouble() >= lastCandle.stck_oprc.toDouble()
                if (isBullishMicro) refinedScore += 8.0
                else refinedScore -= 10.0
            }

            // ③ 초단기 RSI 과열/과매도 필터링
            val rsiMicro = calculateRSI(last5Candles)
            if (rsiMicro > 75.0) refinedScore -= 8.0 // 초단기 꼭지 (추격매수 방지)
            else if (rsiMicro < 25.0) refinedScore += 5.0 // 초단기 투매 과도 (기술적 반등 타점 노림)
        }

        return baseSignal.copy(
            compositeScore = refinedScore.coerceIn(0.0, 100.0).toInt(),
            successProbPct = (refinedScore * 0.85).coerceAtMost(98.0)
        )
    }

    /**
     * 억울한 HOLD를 막아주는 유연한 과열 판별 로직
     */
    fun isOverheatedStock(): Boolean {
        if (daily.size < 20) return false
        val currentPrice = daily.last().stck_prpr.toDouble()

        // 1. 일봉 20일선 이격도
        val ma20Daily = daily.takeLast(20).map { it.stck_prpr.toDouble() }.average()
        val disparityDaily = (currentPrice / ma20Daily) * 100

        // 2. 일봉 RSI (단순 이격도 외의 과열 여부 확인)
        val rsiDaily = calculateRSI(daily)

        // 3. 초단기(최근 10분) 순간 급등 꼭지 확인 (min30 재활용)
        var isMicroOverheated = false
        if (min30.size >= 10) {
            val ma10Min = min30.takeLast(10).map { it.stck_prpr.toDouble() }.average()
            val disparityMin = (currentPrice / ma10Min) * 100
            isMicroOverheated = disparityMin > 105.0 // 10분 평균가 대비 순간적으로 5% 이상 폭등 시
        }

        // 단순히 이격도 115%라고 막는 것이 아니라 3가지 깐깐한 조건 중 하나라도 충족될 때만 과열 판정
        return disparityDaily > 130.0 ||                                // (A) 역대급 폭등 상태
                (disparityDaily > 115.0 && rsiDaily > 75.0) ||           // (B) 급등 중이면서 일봉 과매수
                (disparityDaily > 115.0 && isMicroOverheated)            // (C) 급등 중이면서 10분 내 순간 펌핑(꼭지)
    }

    fun calculateScores(financialScore100: Int): InvestmentScores {
        val signal = generateComprehensiveSignal() // 이미 100점 만점 기반

        // 모든 지표를 100점 스케일 내에서 조합
        val ultra = signal.compositeScore
        val short = (calculateRSI(daily) * 0.5 + (if(calculateOBV(daily) > 0) 50 else 0)).toInt()
        val mid = (if(calculateChange(weekly) > 0) 60 else 20) + (financialScore100 * 0.4).toInt()
        val long = (if(calculateChange(monthly) > 0) 50 else 10) + (financialScore100 * 0.5).toInt()

        return InvestmentScores(
            ultraShort = ultra.coerceIn(0, 100),
            shortTerm = short.coerceIn(0, 100),
            midTerm = mid.coerceIn(0, 100),
            longTerm = long.coerceIn(0, 100)
        )
    }

    // --- 이하 유틸리티 함수군 (변경 없음) ---
    fun calculateATR(candles: List<CandleData>, period: Int = 14): Double {
        if (candles.size < period + 1) return 0.0
        val sub = candles.takeLast(period + 1)
        val trList = mutableListOf<Double>()
        for (i in 1 until sub.size) {
            val high = sub[i].stck_hgpr.toDouble()
            val low = sub[i].stck_lwpr.toDouble()
            val prevClose = sub[i - 1].stck_prpr.toDouble()
            trList.add(maxOf(high - low, abs(high - prevClose), abs(low - prevClose)))
        }
        return trList.average()
    }

    fun calculateMFI(candles: List<CandleData>, period: Int = 14): Double {
        if (candles.size < period + 1) return 50.0
        val subList = candles.takeLast(period + 1)
        var posFlow = 0.0
        var negFlow = 0.0
        for (i in 1 until subList.size) {
            val prevTyp = (subList[i-1].stck_hgpr.toDouble() + subList[i-1].stck_lwpr.toDouble() + subList[i-1].stck_prpr.toDouble()) / 3
            val currTyp = (subList[i].stck_hgpr.toDouble() + subList[i].stck_lwpr.toDouble() + subList[i].stck_prpr.toDouble()) / 3
            val flow = currTyp * subList[i].cntg_vol.toDouble()
            if (currTyp > prevTyp) posFlow += flow else if (currTyp < prevTyp) negFlow += flow
        }
        return if (negFlow == 0.0) 100.0 else 100 - (100 / (1 + (posFlow / negFlow)))
    }

    fun calculateRSI(list: List<CandleData>): Double {
        if (list.size < 2) return 50.0
        var gains = 0.0
        var losses = 0.0
        for (i in 1 until list.size) {
            val diff = list[i].stck_prpr.toDouble() - list[i-1].stck_prpr.toDouble()
            if (diff > 0) gains += diff else losses -= diff
        }
        return if (gains + losses == 0.0) 50.0 else (gains / (gains + losses)) * 100
    }

    fun calculateOBV(candles: List<CandleData>): Double {
        var obv = 0.0
        for (i in 1 until candles.size) {
            val prevClose = candles[i-1].stck_prpr.toDouble()
            val currClose = candles[i].stck_prpr.toDouble()
            if (currClose > prevClose) obv += candles[i].cntg_vol.toDouble()
            else if (currClose < prevClose) obv -= candles[i].cntg_vol.toDouble()
        }
        return obv
    }

    fun calculateChange(list: List<CandleData>): Double {
        if (list.isEmpty()) return 0.0
        val start = list.first().stck_oprc.toDouble()
        val end = list.last().stck_prpr.toDouble()
        return if (start != 0.0) ((end - start) / start) * 100 else 0.0
    }

    fun isDailyBullish(): Boolean {
        if (daily.size < 20) return true
        val currentPrice = daily.last().stck_prpr.toDouble()
        val ma20 = daily.takeLast(20).map { it.stck_prpr.toDouble() }.average()
        val ma5 = daily.takeLast(5).map { it.stck_prpr.toDouble() }.average()
        val prevMa5 = daily.dropLast(1).takeLast(5).map { it.stck_prpr.toDouble() }.average()
        return currentPrice > ma20 && ma5 > prevMa5
    }

    fun generateComprehensiveReport(finScore100: Int): String {
        val signal = generateComprehensiveSignal()
        val currentPrice = min30.last().stck_prpr.toDouble()

        // [표준화된 분석 점수]
        val standardizedScores = """
    - Financial Health Score: $finScore100 / 100
    - Technical Momentum Score: ${signal.compositeScore} / 100
    - Market Energy (Volume): ${"%.1f".format(signal.volRatio)}x relative to avg
    """.trimIndent()

        // [시계열 가격 흐름]
        val monthlyRange = monthly.takeLast(3).joinToString(" -> ") {
            "[H:${it.stck_hgpr}, L:${it.stck_lwpr}]"
        }
        val weeklyRange = weekly.takeLast(4).joinToString(" -> ") {
            "[H:${it.stck_hgpr}, L:${it.stck_lwpr}]"
        }

        return """
# [Standardized Analysis Summary]
$standardizedScores
# [Historical Price Range]
- Monthly (Last 3M): $monthlyRange
- Weekly (Last 4W): $weeklyRange
- Current Price: $currentPrice
# [Technical Context]
- Base Position: ${"%.1f".format((currentPrice / daily.takeLast(120).map { it.stck_prpr.toDouble() }.average()) * 100)}% (120MA)
- RSI (Daily): ${"%.1f".format(calculateRSI(daily))}
    """.trimIndent()
    }
}