package com.xuqm.update.controller;

import com.xuqm.common.model.ApiResponse;
import com.xuqm.update.entity.AppVersionEntity;
import com.xuqm.update.repository.AppVersionRepository;
import com.xuqm.update.model.AppPackageInspectResult;
import com.xuqm.update.service.UpdateOperationLogService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import com.xuqm.update.service.UpdateAssetService;
import com.xuqm.update.service.PublishConfigService;
import com.xuqm.update.service.AppStoreService;

@RestController
@RequestMapping("/api/v1/updates")
public class AppVersionController {

    private static final Logger log = LoggerFactory.getLogger(AppVersionController.class);

    private final AppVersionRepository versionRepository;
    private final UpdateAssetService updateAssetService;
    private final PublishConfigService publishConfigService;
    private final AppStoreService appStoreService;
    private final UpdateOperationLogService operationLogService;

    public AppVersionController(AppVersionRepository versionRepository,
                                UpdateAssetService updateAssetService,
                                PublishConfigService publishConfigService,
                                AppStoreService appStoreService,
                                UpdateOperationLogService operationLogService) {
        this.versionRepository = versionRepository;
        this.updateAssetService = updateAssetService;
        this.publishConfigService = publishConfigService;
        this.appStoreService = appStoreService;
        this.operationLogService = operationLogService;
    }

    @GetMapping("/app/check")
    public ResponseEntity<ApiResponse<Map<String, Object>>> checkUpdate(
            @RequestParam String appId,
            @RequestParam AppVersionEntity.Platform platform,
            @RequestParam int currentVersionCode) {

        Optional<AppVersionEntity> latest = versionRepository
                .findTopByAppIdAndPlatformAndPublishStatusAndVersionCodeGreaterThanOrderByVersionCodeDesc(
                        appId, platform, AppVersionEntity.PublishStatus.PUBLISHED, currentVersionCode);
        Optional<AppVersionEntity> forcedHigher = versionRepository
                .findTopByAppIdAndPlatformAndPublishStatusAndVersionCodeGreaterThanAndForceUpdateTrueOrderByVersionCodeDesc(
                        appId, platform, AppVersionEntity.PublishStatus.PUBLISHED, currentVersionCode);

        if (latest.isEmpty()) {
            return ResponseEntity.ok(ApiResponse.success(Map.of("needsUpdate", false)));
        }

        AppVersionEntity v = latest.get();
        String appStoreJumpUrl = hasText(v.getAppStoreUrl())
                ? v.getAppStoreUrl()
                : appStoreService.getStoreJumpUrl(appId, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.APP_STORE);
        String harmonyJumpUrl = hasText(v.getMarketUrl())
                ? v.getMarketUrl()
                : appStoreService.getStoreJumpUrl(appId, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.HARMONY_APP);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "needsUpdate", true,
                "versionName", v.getVersionName(),
                "versionCode", v.getVersionCode(),
                "downloadUrl", v.getDownloadUrl() != null ? v.getDownloadUrl() : "",
                "changeLog", v.getChangeLog() != null ? v.getChangeLog() : "",
                "forceUpdate", forcedHigher.isPresent(),
                "appStoreUrl", appStoreJumpUrl,
                "marketUrl", harmonyJumpUrl
        )));
    }

    @PostMapping("/app/upload")
    public ResponseEntity<ApiResponse<AppVersionEntity>> upload(
            @RequestParam String appId,
            @RequestParam AppVersionEntity.Platform platform,
            @RequestParam(required = false) String versionName,
            @RequestParam(required = false) Integer versionCode,
            @RequestParam(required = false) String changeLog,
            @RequestParam(defaultValue = "false") boolean forceUpdate,
            @RequestParam(required = false) String apkUrl,
            @RequestParam(required = false) MultipartFile apkFile,
            @RequestParam(required = false) String scheduledPublishAt,
            @RequestParam(required = false) String webhookUrl,
            @RequestParam(required = false) String storeSubmitTargets,
            @RequestParam(defaultValue = "false") boolean autoPublishAfterReview,
            @RequestParam(defaultValue = "false") boolean publishImmediately,
            @RequestParam(required = false) String packageName,
            @RequestParam(required = false) String expectedPackageName,
            @RequestParam(required = false) String appStoreUrl,
            @RequestParam(required = false) String marketUrl) throws Exception {

        AppPackageInspectResult inspected = null;
        try {
            inspected = hasText(apkUrl)
                    ? updateAssetService.inspectAppPackage(apkUrl)
                    : (apkFile != null && !apkFile.isEmpty() ? updateAssetService.inspectAppPackage(apkFile) : null);
        } catch (Exception ex) {
            log.warn("Unable to inspect upload package for appId={}, platform={}, source={}, fallback to manual version fields: {}",
                    appId, platform, hasText(apkUrl) ? apkUrl : (apkFile != null ? apkFile.getOriginalFilename() : null), ex.getMessage());
        }
        String resolvedVersionName = hasText(versionName) ? versionName : (inspected != null ? inspected.versionName() : null);
        Integer resolvedVersionCode = versionCode != null ? versionCode : (inspected != null ? inspected.versionCode() : null);
        String resolvedPackageName = hasText(packageName) ? packageName : (inspected != null ? inspected.packageName() : null);
        if (!hasText(resolvedVersionName) || resolvedVersionCode == null) {
            throw new IllegalArgumentException("versionName and versionCode are required or must be readable from the uploaded package");
        }
        if (hasText(expectedPackageName) && hasText(resolvedPackageName) && !expectedPackageName.equals(resolvedPackageName)) {
            throw new IllegalArgumentException("packageName does not match current app packageName");
        }
        if (platform == AppVersionEntity.Platform.ANDROID && !hasText(apkUrl) && (apkFile == null || apkFile.isEmpty())) {
            throw new IllegalArgumentException("apkUrl or apkFile is required for ANDROID releases");
        }
        AppVersionEntity entity = new AppVersionEntity();
        entity.setId(UUID.randomUUID().toString());
        entity.setAppId(appId);
        entity.setPlatform(platform);
        entity.setVersionName(resolvedVersionName);
        entity.setVersionCode(resolvedVersionCode);
        entity.setDownloadUrl(platform == AppVersionEntity.Platform.ANDROID
                ? (hasText(apkUrl) ? apkUrl : updateAssetService.storeAppPackage(apkFile))
                : null);
        entity.setChangeLog(changeLog);
        entity.setForceUpdate(forceUpdate);
        entity.setPublishStatus(AppVersionEntity.PublishStatus.DRAFT);
        entity.setCreatedAt(LocalDateTime.now());
        entity.setStoreSubmitMode("MANUAL");
        entity.setStoreSubmitScheduledAt(null);
        entity.setGrayMode("PERCENT");
        entity.setGrayMemberIds(null);
        if (scheduledPublishAt != null && !scheduledPublishAt.isBlank()) {
            entity.setScheduledPublishAt(LocalDateTime.parse(scheduledPublishAt));
        }
        entity.setWebhookUrl(webhookUrl);
        entity.setStoreSubmitTargets(storeSubmitTargets);
        entity.setAutoPublishAfterReview(autoPublishAfterReview);
        entity.setPackageName(resolvedPackageName);
        entity.setAppStoreUrl(hasText(appStoreUrl)
                ? appStoreUrl
                : (platform == AppVersionEntity.Platform.IOS
                        ? appStoreService.getStoreJumpUrl(appId, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.APP_STORE)
                        : null));
        entity.setMarketUrl(hasText(marketUrl)
                ? marketUrl
                : (platform == AppVersionEntity.Platform.HARMONY
                        ? appStoreService.getStoreJumpUrl(appId, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.HARMONY_APP)
                        : null));
        if (publishImmediately) {
            entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
            entity.setGrayEnabled(false);
            entity.setGrayPercent(0);
        }
        AppVersionEntity saved = versionRepository.save(entity);
        operationLogService.record(
                saved.getAppId(),
                "APP_VERSION",
                saved.getId(),
                "UPLOAD",
                null,
                Map.of(
                        "platform", saved.getPlatform().name(),
                        "versionName", saved.getVersionName(),
                        "versionCode", saved.getVersionCode(),
                        "publishImmediately", publishImmediately,
                        "forceUpdate", saved.isForceUpdate(),
                        "packageName", saved.getPackageName() == null ? "" : saved.getPackageName()
                ));
        return ResponseEntity.ok(ApiResponse.success(saved));
    }

    @RequestMapping(value = "/app/inspect", method = {RequestMethod.GET, RequestMethod.POST})
    public ResponseEntity<ApiResponse<AppPackageInspectResult>> inspect(
            @RequestParam(required = false) String apkUrl,
            @RequestParam(required = false) MultipartFile apkFile) throws Exception {
        if (hasText(apkUrl)) {
            return ResponseEntity.ok(ApiResponse.success(updateAssetService.inspectAppPackage(apkUrl)));
        }
        return ResponseEntity.ok(ApiResponse.success(updateAssetService.inspectAppPackage(apkFile)));
    }

    @PostMapping("/app/{id}/publish")
    public ResponseEntity<ApiResponse<AppVersionEntity>> publish(
            @PathVariable String id,
            @RequestBody(required = false) Map<String, Object> body) {
        AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
        boolean publishImmediately = body == null || !Boolean.FALSE.equals(body.get("publishImmediately"));
        String scheduledPublishAt = body != null && body.get("scheduledPublishAt") != null
                ? body.get("scheduledPublishAt").toString() : null;
        boolean forceUpdate = body != null && body.get("forceUpdate") != null
                ? Boolean.parseBoolean(body.get("forceUpdate").toString()) : entity.isForceUpdate();
        AppVersionEntity.PublishStatus previousStatus = entity.getPublishStatus();
        entity.setForceUpdate(forceUpdate);
        if (publishImmediately && (scheduledPublishAt == null || scheduledPublishAt.isBlank())) {
            entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
            entity.setScheduledPublishAt(null);
        } else {
            entity.setPublishStatus(AppVersionEntity.PublishStatus.DRAFT);
            if (scheduledPublishAt != null && !scheduledPublishAt.isBlank()) {
                entity.setScheduledPublishAt(LocalDateTime.parse(scheduledPublishAt));
            }
        }
        entity.setGrayEnabled(false);
        entity.setGrayPercent(0);
        entity.setGrayMode("PERCENT");
        entity.setGrayMemberIds(null);
        AppVersionEntity saved = versionRepository.save(entity);
        operationLogService.record(
                saved.getAppId(),
                "APP_VERSION",
                saved.getId(),
                publishAction(previousStatus, saved.getPublishStatus(), publishImmediately),
                null,
                Map.of(
                        "versionName", saved.getVersionName(),
                        "versionCode", saved.getVersionCode(),
                        "publishImmediately", publishImmediately,
                        "scheduledPublishAt", saved.getScheduledPublishAt() == null ? "" : saved.getScheduledPublishAt().toString(),
                        "forceUpdate", saved.isForceUpdate()
                ));
        return ResponseEntity.ok(ApiResponse.success(saved));
    }

    @PostMapping("/app/{id}/unpublish")
    public ResponseEntity<ApiResponse<AppVersionEntity>> unpublish(
            @PathVariable String id,
            @RequestBody(required = false) Map<String, Object> body) {
        AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
        String reason = body != null && body.get("reason") != null ? body.get("reason").toString().trim() : "";
        if (reason.isBlank()) {
            throw new IllegalArgumentException("unpublish reason is required");
        }
        entity.setPublishStatus(AppVersionEntity.PublishStatus.DEPRECATED);
        AppVersionEntity saved = versionRepository.save(entity);
        operationLogService.record(
                saved.getAppId(),
                "APP_VERSION",
                saved.getId(),
                "UNPUBLISH",
                reason,
                Map.of(
                        "versionName", saved.getVersionName(),
                        "versionCode", saved.getVersionCode()
                ));
        return ResponseEntity.ok(ApiResponse.success(saved));
    }

    @PostMapping("/app/{id}/gray")
    public ResponseEntity<ApiResponse<AppVersionEntity>> gray(
            @PathVariable String id,
            @RequestBody Map<String, Object> body) throws Exception {
        AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
        boolean enabled = Boolean.TRUE.equals(body.get("enabled"));
        String grayMode = body.get("grayMode") == null ? "PERCENT" : body.get("grayMode").toString().trim().toUpperCase();
        entity.setGrayEnabled(enabled);
        if (!enabled) {
            entity.setGrayPercent(0);
            entity.setGrayMode("PERCENT");
            entity.setGrayMemberIds(null);
        } else if ("MEMBERS".equals(grayMode)) {
            List<String> memberIds = extractMemberIds(body.get("memberIds"));
            String selectionSource = body.get("selectionSource") == null ? "LOCAL"
                    : body.get("selectionSource").toString().trim().toUpperCase();
            if (memberIds.isEmpty() && "CALLBACK".equals(selectionSource)) {
                memberIds = publishConfigService.resolveGrayMembers(entity.getAppId(), body);
            }
            entity.setGrayMode("MEMBERS");
            entity.setGrayMemberIds(toJson(memberIds));
            entity.setGrayPercent(0);
        } else {
            entity.setGrayMode("PERCENT");
            entity.setGrayPercent(body.get("percent") instanceof Number n ? n.intValue() : 0);
            entity.setGrayMemberIds(null);
        }
        entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
        AppVersionEntity saved = versionRepository.save(entity);
        operationLogService.record(
                saved.getAppId(),
                "APP_VERSION",
                saved.getId(),
                "GRAY_UPDATE",
                null,
                Map.of(
                        "enabled", enabled,
                        "grayMode", saved.getGrayMode(),
                        "grayPercent", saved.getGrayPercent(),
                        "memberCount", saved.getGrayMemberIds() == null ? 0 : extractMemberIds(saved.getGrayMemberIds()).size()
                ));
        return ResponseEntity.ok(ApiResponse.success(saved));
    }

    @GetMapping("/app/list")
    public ResponseEntity<ApiResponse<List<AppVersionEntity>>> list(
            @RequestParam String appId, @RequestParam AppVersionEntity.Platform platform) {
        return ResponseEntity.ok(ApiResponse.success(
                versionRepository.findByAppIdAndPlatformOrderByVersionCodeDesc(appId, platform)));
    }

    private String publishAction(AppVersionEntity.PublishStatus previousStatus,
                                 AppVersionEntity.PublishStatus currentStatus,
                                 boolean publishImmediately) {
        if (!publishImmediately) {
            return "SCHEDULE_PUBLISH";
        }
        if (previousStatus == AppVersionEntity.PublishStatus.PUBLISHED) {
            return "UPDATE_FORCE";
        }
        if (previousStatus == AppVersionEntity.PublishStatus.DEPRECATED) {
            return "REPUBLISH";
        }
        return currentStatus == AppVersionEntity.PublishStatus.PUBLISHED ? "PUBLISH" : "SAVE_DRAFT";
    }

    private boolean hasText(String value) {
        return value != null && !value.isBlank();
    }

    private List<String> extractMemberIds(Object raw) {
        if (raw == null) {
            return List.of();
        }
        if (raw instanceof List<?> list) {
            return list.stream()
                    .map(String::valueOf)
                    .filter(this::hasText)
                    .map(String::trim)
                    .toList();
        }
        if (raw instanceof String s) {
            if (!hasText(s)) {
                return List.of();
            }
            try {
                return java.util.Arrays.stream(s.split(","))
                        .map(String::trim)
                        .filter(this::hasText)
                        .toList();
            } catch (Exception ignored) {
                return List.of();
            }
        }
        return List.of();
    }

    private String toJson(List<String> values) {
        try {
            return new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(values == null ? List.of() : values);
        } catch (Exception e) {
            return "[]";
        }
    }
}