// ModelVersion.kt
@Entity
@Table(name = "model_versions")
data class ModelVersion(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,

    @Column(nullable = false)
    val modelType: String,          // "breed_classifier" | "health_scorer"

    @Column(nullable = false)
    val version: String,            // SemVer: "1.2.0"

    @Column(nullable = false)
    val s3Key: String,              // S3 객체 키

    @Column(nullable = false)
    val checksum: String,           // SHA-256

    @Column(nullable = false)
    val fileSizeBytes: Long,

    @Column(nullable = false)
    val isActive: Boolean = true,   // 현재 배포 버전 여부

    @Column(nullable = false)
    val releaseNote: String = "",

    val createdAt: LocalDateTime = LocalDateTime.now()
)

// ModelController.kt
@RestController
@RequestMapping("/api/v1/models")
class ModelController(
    private val modelService: ModelService
) {
    @GetMapping("/latest")
    fun getLatestVersions(
        @RequestParam breedClassifierVersion: String,
        @RequestParam healthScorerVersion: String,
        @AuthenticationPrincipal user: DevicePrincipal
    ): ResponseEntity<ApiResponse<ModelUpdateResponse>> {
        val response = modelService.checkUpdates(
            installedVersions = mapOf(
                "breed_classifier" to breedClassifierVersion,
                "health_scorer"    to healthScorerVersion
            )
        )
        return ResponseEntity.ok(ApiResponse.success(response))
    }

    @PostMapping("/upload")
    @PreAuthorize("hasRole('ADMIN')")
    fun uploadModel(
        @RequestPart file: MultipartFile,
        @RequestPart metadata: ModelUploadRequest
    ): ResponseEntity<ApiResponse<ModelVersion>> {
        val version = modelService.uploadNewVersion(file, metadata)
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(ApiResponse.success(version))
    }
}

// ModelService.kt
@Service
@Transactional(readOnly = true)
class ModelService(
    private val repository: ModelVersionRepository,
    private val s3Service: S3StorageService,
    private val redis: RedisTemplate<String, String>
) {
    companion object {
        private const val CACHE_KEY_PREFIX = "model:latest:"
        private const val CACHE_TTL_MINUTES = 10L
    }

    fun checkUpdates(installedVersions: Map<String, String>): ModelUpdateResponse {
        return ModelUpdateResponse(
            models = installedVersions.entries.associate { (type, installedVer) ->
                type to getUpdateInfo(type, installedVer)
            }
        )
    }

    private fun getUpdateInfo(modelType: String, installedVersion: String): ModelUpdateInfo {
        // Redis 캐시 우선 조회
        val cacheKey = "$CACHE_KEY_PREFIX$modelType"
        val cached   = redis.opsForValue().get(cacheKey)
        val latest   = cached?.let { objectMapper.readValue<ModelVersion>(it) }
            ?: repository.findTopByModelTypeAndIsActiveTrueOrderByCreatedAtDesc(modelType)
                ?.also { version ->
                    redis.opsForValue().set(
                        cacheKey,
                        objectMapper.writeValueAsString(version),
                        CACHE_TTL_MINUTES, TimeUnit.MINUTES
                    )
                }
            ?: return ModelUpdateInfo(updateAvailable = false)

        val needsUpdate = isNewerVersion(latest.version, installedVersion)

        return ModelUpdateInfo(
            currentVersion  = installedVersion,
            latestVersion   = latest.version,
            updateAvailable = needsUpdate,
            downloadUrl     = if (needsUpdate) s3Service.generatePresignedUrl(latest.s3Key) else null,
            checksum        = if (needsUpdate) latest.checksum else null,
            fileSizeBytes   = if (needsUpdate) latest.fileSizeBytes else null
        )
    }

    // SemVer 비교: "1.2.0" > "1.0.0" → true
    private fun isNewerVersion(latest: String, installed: String): Boolean {
        val l = latest.split(".").map { it.toInt() }
        val i = installed.split(".").map { it.toInt() }
        return (0..2).any { idx -> l[idx] > i[idx] }
                && (0 until (0..2).indexOfFirst { l[it] != i[it] }).all { l[it] == i[it] }
    }
}

// StatsAggregationService.kt
@Service
class StatsAggregationService(
    private val statsRepository: HealthStatsRepository
) {
    // 매일 새벽 2시 기준값 재계산
    @Scheduled(cron = "0 0 2 * * *")
    fun recalculateBaselines() {
        val breeds = statsRepository.findDistinctBreedCodes()
        breeds.forEach { breedCode ->
            val stats = statsRepository.aggregateByBreed(breedCode)
            statsRepository.upsertBaseline(
                BreedBaseline(
                    breedCode       = breedCode,
                    sampleCount     = stats.count,
                    avgHealthScore  = stats.avgScore,
                    avgActivityIdx  = stats.avgActivity,
                    updatedAt       = LocalDate.now()
                )
            )
        }
    }
}

// JwtProvider.kt
@Component
class JwtProvider(
    @Value("\${jwt.secret}") private val secret: String,
    @Value("\${jwt.access-token-expiry-days:7}") private val accessTokenExpiryDays: Long,
    @Value("\${jwt.refresh-token-expiry-days:90}") private val refreshTokenExpiryDays: Long
) {
    private val key: SecretKey by lazy {
        Keys.hmacShaKeyFor(Base64.getDecoder().decode(secret))
    }

    fun generateAccessToken(deviceId: String): String =
        Jwts.builder()
            .subject(deviceId)
            .claim("type", "access")
            .issuedAt(Date())
            .expiration(Date(System.currentTimeMillis()
                + TimeUnit.DAYS.toMillis(accessTokenExpiryDays)))
            .signWith(key)
            .compact()

    fun generateRefreshToken(deviceId: String): String =
        Jwts.builder()
            .subject(deviceId)
            .claim("type", "refresh")
            .issuedAt(Date())
            .expiration(Date(System.currentTimeMillis()
                + TimeUnit.DAYS.toMillis(refreshTokenExpiryDays)))
            .signWith(key)
            .compact()

    fun validateAndExtractDeviceId(token: String): String =
        Jwts.parser()
            .verifyWith(key)
            .build()
            .parseSignedClaims(token)
            .payload
            .subject
}

// FcmTokenService.kt
@Service
class FcmTokenService(
    private val redis: RedisTemplate<String, String>,
    private val firebaseMessaging: FirebaseMessaging
) {
    companion object {
        private const val FCM_KEY_PREFIX = "fcm:token:"
    }

    // 앱에서 FCM 토큰 등록/갱신
    fun registerToken(deviceId: String, fcmToken: String) {
        redis.opsForValue().set(
            "$FCM_KEY_PREFIX$deviceId",
            fcmToken,
            90, TimeUnit.DAYS       // Refresh Token 만료와 동기화
        )
    }

    // 건강 이상 징후 알림 발송
    fun sendHealthAlert(deviceId: String, alert: HealthAlert) {
        val token = redis.opsForValue().get("$FCM_KEY_PREFIX$deviceId")
            ?: return  // 토큰 없으면 알림 불가 — 무시

        val message = Message.builder()
            .setToken(token)
            .setNotification(
                Notification.builder()
                    .setTitle(alert.title)
                    .setBody(alert.body)
                    .build()
            )
            .putData("alert_type", alert.type.name)
            .putData("health_score", alert.score.toString())
            .setAndroidConfig(
                AndroidConfig.builder()
                    .setPriority(AndroidConfig.Priority.HIGH)
                    .build()
            )
            .build()

        try {
            firebaseMessaging.send(message)
        } catch (e: FirebaseMessagingException) {
            if (e.messagingErrorCode == MessagingErrorCode.UNREGISTERED) {
                // 만료 토큰 삭제
                redis.delete("$FCM_KEY_PREFIX$deviceId")
            }
        }
    }
}

// ApiResponse.kt
data class ApiResponse<T>(
    val status: String,
    val data: T? = null,
    val error: ApiError? = null,
    val timestamp: Long = System.currentTimeMillis()
) {
    companion object {
        fun <T> success(data: T) =
            ApiResponse(status = "success", data = data)

        fun error(code: String, message: String) =
            ApiResponse<Nothing>(
                status = "error",
                error  = ApiError(code, message)
            )
    }
}

data class ApiError(val code: String, val message: String)

// GlobalExceptionHandler.kt
@RestControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(ApiException::class)
    fun handleApiException(e: ApiException): ResponseEntity<ApiResponse<Nothing>> =
        ResponseEntity
            .status(e.httpStatus)
            .body(ApiResponse.error(e.errorCode, e.message ?: "Unknown error"))

    @ExceptionHandler(MethodArgumentNotValidException::class)
    fun handleValidation(e: MethodArgumentNotValidException): ResponseEntity<ApiResponse<Nothing>> {
        val message = e.bindingResult.fieldErrors
            .joinToString(", ") { "${it.field}: ${it.defaultMessage}" }
        return ResponseEntity
            .badRequest()
            .body(ApiResponse.error("VALIDATION_ERROR", message))
    }

    @ExceptionHandler(Exception::class)
    fun handleUnexpected(e: Exception): ResponseEntity<ApiResponse<Nothing>> {
        log.error("Unexpected error", e)
        return ResponseEntity
            .internalServerError()
            .body(ApiResponse.error("INTERNAL_ERROR", "Internal server error"))
    }
}