package kz.konturai.parser.controller;

import kz.konturai.parser.dto.*;
import kz.konturai.parser.model.MarketingAnalysis;
import kz.konturai.parser.model.MarketingAnalysisV2Document;
import kz.konturai.parser.model.MarketingStrategy;
import kz.konturai.parser.model.PostingTask;
import kz.konturai.parser.service.JwtService;
import kz.konturai.parser.service.MarketingAnalysisService;
import kz.konturai.parser.service.MarketingStrategyService;
import kz.konturai.parser.service.MinIOService;
import kz.konturai.parser.service.PostingTaskService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jakarta.validation.Valid;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/api/marketing/analysis")
@RequiredArgsConstructor
public class MarketingController {

        private static final Logger logger = LoggerFactory.getLogger(MarketingController.class);

        private final MarketingAnalysisService marketingAnalysisService;
        private final MarketingStrategyService marketingStrategyService;
        private final MinIOService minIOService;
        private final JwtService jwtService;
        private final PostingTaskService postingTaskService;

        private String extractUserIdFromHeader(String authHeader) {
                if (authHeader == null || authHeader.isEmpty()) {
                        logger.debug("Authorization header is null or empty");
                        return null;
                }
                try {
                        String userId = jwtService.extractUserIdFromHeader(authHeader);
                        logger.debug("Extracted userId from header: {}", userId);
                        return userId;
                } catch (Exception e) {
                        logger.error("Error extracting userId from header: {}", e.getMessage(), e);
                        return null;
                }
        }

        private ResponseEntity<?> unauthorizedResponse() {
                ErrorResponse error = new ErrorResponse(
                                "UNAUTHORIZED",
                                "Требуется аутентификация. Пожалуйста, предоставьте валидный JWT токен.");
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                                .body(ApiResponse.error("Не авторизован", error));
        }

        @PostMapping("/start")
        public ResponseEntity<?> startAnalysis(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @RequestParam(value = "generateV2", defaultValue = "false") boolean generateV2,
                        @Valid @RequestBody MarketingAnalysisRequest request) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                // If caller explicitly requests V2, serve it from this endpoint as well
                // (backward compatible for clients using /start?generateV2=true).
                if (generateV2) {
                        try {
                                String v2Id = marketingAnalysisService.generateAndSaveAnalysisV2(request, userId);
                                MarketingAnalysisResponse response = new MarketingAnalysisResponse(
                                                v2Id,
                                                "completed",
                                                null,
                                                "V2 анализ успешно создан и сохранен. Используйте GET /api/marketing/analysis/v2/{id} для получения данных.");
                                return ResponseEntity.ok(ApiResponse.success("Анализ создан", response));
                        } catch (Exception e) {
                                logger.error("Error creating analysis v2 via /start?generateV2=true: {}",
                                                e.getMessage(),
                                                e);
                                ErrorResponse error = new ErrorResponse(
                                                "INTERNAL_SERVER_ERROR",
                                                "Произошла ошибка при создании анализа V2");
                                return ResponseEntity.status(500)
                                                .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                        }
                }

                // TEMP: We use only V2 generate for now.
                // Disable the legacy (v1) start endpoint to avoid creating duplicate/old-format
                // analyses.
                // NOTE: Keep this behind a non-constant condition to avoid "unreachable code"
                // errors.
                boolean legacyGenerateDisabled = true;
                if (legacyGenerateDisabled) {
                        MarketingAnalysisResponse disabledResponse = new MarketingAnalysisResponse(
                                        null,
                                        "disabled",
                                        null,
                                        "Обычный generate временно отключен. Используйте V2: POST /api/marketing/analysis/start/v2");
                        return ResponseEntity.ok(ApiResponse.success("Обычный generate временно отключен",
                                        disabledResponse));
                }

                // Create unified analysis with all analysis types
                List<MarketingAnalysis> analyses = marketingAnalysisService.startAnalysis(request, userId);
                MarketingAnalysis analysis = analyses.get(0);

                // Опционально создаем v2 анализ и связываем его
                String v2AnalysisId = null;
                if (generateV2) {
                        try {
                                v2AnalysisId = marketingAnalysisService.generateAndSaveAnalysisV2(request, userId);
                                analysis.setV2AnalysisId(v2AnalysisId);
                                marketingAnalysisService.updateAnalysis(analysis);
                                marketingAnalysisService.linkV2AnalysisToAnalysis(v2AnalysisId, analysis.getId());
                                logger.info("Created and linked v2 analysis {} to analysis {}", v2AnalysisId,
                                                analysis.getId());
                        } catch (Exception e) {
                                logger.error("Error creating v2 analysis: {}", e.getMessage(), e);
                        }
                }

                // Start async processing
                marketingAnalysisService.processAnalysis(analysis.getId(), request);

                // Calculate estimated completion time (5-10 minutes)
                LocalDateTime estimatedCompletion = LocalDateTime.now().plusMinutes(8);

                // Build analysis types string for message
                String analysisTypesStr = "неизвестно";
                if (analysis.getAnalysisType() != null && !analysis.getAnalysisType().isEmpty()) {
                        analysisTypesStr = String.join(", ", analysis.getAnalysisType());
                }

                MarketingAnalysisResponse response = new MarketingAnalysisResponse(
                                analysis.getId(),
                                "processing",
                                estimatedCompletion,
                                "Комплексный анализ (" + analysisTypesStr
                                                + ") запущен успешно. Результаты будут готовы в течение 5-10 минут.");

                // Добавляем v2 id в ответ, если он был создан
                if (v2AnalysisId != null) {
                        Map<String, Object> responseData = new HashMap<>();
                        responseData.put("analysisId", response.getAnalysisId());
                        responseData.put("status", response.getStatus());
                        responseData.put("estimatedCompletionTime", response.getEstimatedCompletionTime());
                        responseData.put("message", response.getMessage());
                        responseData.put("v2AnalysisId", v2AnalysisId);
                        return ResponseEntity.ok(ApiResponse.success("Анализ запущен успешно", responseData));
                }

                return ResponseEntity.ok(ApiResponse.success("Анализ запущен успешно", response));
        }

        @PostMapping("/start/v2")
        public ResponseEntity<?> startAnalysisV2(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @Valid @RequestBody MarketingAnalysisRequest request) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                try {
                        String analysisId = marketingAnalysisService.generateAndSaveAnalysisV2(request, userId);
                        Map<String, Object> response = new HashMap<>();
                        response.put("id", analysisId);
                        response.put("message", "Анализ успешно создан и сохранен");
                        return ResponseEntity.ok(ApiResponse.success("Анализ создан", response));
                } catch (Exception e) {
                        logger.error("Error creating analysis v2: {}", e.getMessage(), e);
                        ErrorResponse error = new ErrorResponse(
                                        "INTERNAL_SERVER_ERROR",
                                        "Произошла ошибка при создании анализа");
                        return ResponseEntity.status(500)
                                        .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                }
        }

        @GetMapping("/v2/{id}")
        public ResponseEntity<?> getAnalysisV2(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String id) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingAnalysisV2Document> optAnalysis = marketingAnalysisService
                                .getAnalysisV2ById(id);

                if (optAnalysis.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Анализ с указанным ID не найден");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Анализ не найден", error));
                }

                MarketingAnalysisV2Document analysis = optAnalysis.get();
                if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                return ResponseEntity.ok(ApiResponse.success(analysis.getAnalysisData()));
        }

        @GetMapping("/{analysisId}")
        public ResponseEntity<?> getAnalysis(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String analysisId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingAnalysis> optAnalysis = marketingAnalysisService.getAnalysisById(analysisId);
                if (optAnalysis.isEmpty()) {
                    Optional<MarketingAnalysisV2Document> newOptAnalyz = marketingAnalysisService
                            .getAnalysisV2ById(analysisId);
                    if(newOptAnalyz.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                "NOT_FOUND",
                                "Анализ с указанным ID не найден");
                        return ResponseEntity.status(404)
                                .body(ApiResponse.error("Анализ не найден", error));
                    }
                    MarketingAnalysisV2Document analysis = newOptAnalyz.get();

                    if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                "FORBIDDEN",
                                "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                .body(ApiResponse.error("Доступ запрещен", error));
                    }

                    return ResponseEntity.ok(ApiResponse.success(analysis.getAnalysisData()));
                }

                MarketingAnalysis analysis = optAnalysis.get();
                if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                MarketingAnalysisResult result = marketingAnalysisService.getAnalysisResult(analysisId);
                return ResponseEntity.ok(ApiResponse.success(result));
        }

        @GetMapping("/{analysisId}/download")
        public ResponseEntity<?> downloadPdf(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String analysisId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingAnalysis> optAnalysis = marketingAnalysisService.getAnalysisById(analysisId);
                if (optAnalysis.isEmpty()) {
                        return ResponseEntity.notFound().build();
                }

                MarketingAnalysis analysis = optAnalysis.get();
                if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                if (analysis.getPdfFilePath() == null) {
                        return ResponseEntity.notFound().build();
                }

                try {
                        InputStream inputStream = minIOService.downloadFile(analysis.getPdfFilePath());
                        byte[] bytes = inputStream.readAllBytes();
                        inputStream.close();

                        return ResponseEntity.ok()
                                        .header(HttpHeaders.CONTENT_DISPOSITION,
                                                        "attachment; filename=\"" + analysis.getPdfFilename() + "\"")
                                        .contentType(MediaType.APPLICATION_PDF)
                                        .body(bytes);
                } catch (Exception e) {
                        return ResponseEntity.internalServerError().build();
                }
        }

        /**
         * Получает изображение поста по имени файла
         * 
         * @param authHeader    Authorization header с JWT токеном
         * @param imageFilename Имя файла изображения
         * @return Изображение в формате PNG
         */
        @GetMapping("/images/{imageFilename}")
        public ResponseEntity<byte[]> getPostImage(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String imageFilename) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
                }

                // Проверяем существование файла в MinIO
                try {
                        if (!minIOService.fileExists(imageFilename)) {
                                logger.warn("Image file not found: {}", imageFilename);
                                return ResponseEntity.notFound().build();
                        }

                        // Загружаем изображение из MinIO
                        InputStream inputStream = minIOService.downloadFile(imageFilename);
                        byte[] bytes = inputStream.readAllBytes();
                        inputStream.close();

                        return ResponseEntity.ok()
                                        .header(HttpHeaders.CONTENT_TYPE, MediaType.IMAGE_PNG_VALUE)
                                        .header(HttpHeaders.CACHE_CONTROL, "public, max-age=3600")
                                        .body(bytes);
                } catch (Exception e) {
                        logger.error("Error loading image {}: {}", imageFilename, e.getMessage(), e);
                        return ResponseEntity.internalServerError().build();
                }
        }

    @PostMapping("/strategy/generate")
    public ResponseEntity<?> generateStrategy(
            @RequestHeader(value = "Authorization", required = false) String authHeader,
            @RequestParam String analysisId,
            @Valid @RequestBody(required = false) MarketingStrategyRequest request) {

        String userId = extractUserIdFromHeader(authHeader);
        if (userId == null) {
            return unauthorizedResponse();
        }

        Optional<MarketingAnalysis> optAnalysis = marketingAnalysisService.getAnalysisById(analysisId);

        if (optAnalysis.isEmpty()) {
            Optional<MarketingAnalysisV2Document> optV2 = marketingAnalysisService.getAnalysisV2ById(analysisId);

            if (optV2.isEmpty()) {
                ErrorResponse error = new ErrorResponse("INVALID_ANALYSIS", "Анализ не найден");
                return ResponseEntity.status(404)
                        .body(ApiResponse.error("Анализ не найден", error));
            }

            if (!userId.equals(optV2.get().getUserId())) {
                ErrorResponse error = new ErrorResponse(
                        "FORBIDDEN",
                        "У вас нет доступа к этому анализу");
                return ResponseEntity.status(HttpStatus.FORBIDDEN)
                        .body(ApiResponse.error("Доступ запрещен", error));
            }
        } else {
            if (!userId.equals(optAnalysis.get().getUserId())) {
                ErrorResponse error = new ErrorResponse(
                        "FORBIDDEN",
                        "У вас нет доступа к этому анализу");
                return ResponseEntity.status(HttpStatus.FORBIDDEN)
                        .body(ApiResponse.error("Доступ запрещен", error));
            }
        }

        if (request == null) {
            request = new MarketingStrategyRequest();
        }

        try {
            MarketingStrategy strategy = marketingStrategyService.generateStrategy(analysisId, request,
                    userId);

            MarketingStrategyResponse response = new MarketingStrategyResponse();
            response.setStrategyId(strategy.getId());
            response.setAnalysisId(strategy.getAnalysisId());
            response.setStatus(strategy.getStatus());
            response.setCreatedAt(strategy.getCreatedAt());
            response.setDurationWeeks(strategy.getDurationWeeks());
            response.setPriorityPlatforms(strategy.getPriorityPlatforms());

            return ResponseEntity.ok(ApiResponse.success(
                    "Генерация стратегии запущена успешно. Результаты будут готовы в течение 3-5 минут.",
                    response));
        } catch (IllegalArgumentException e) {
            ErrorResponse error = new ErrorResponse("INVALID_ANALYSIS", e.getMessage());
            return ResponseEntity.status(404)
                    .body(ApiResponse.error("Анализ не найден", error));
        } catch (IllegalStateException e) {
            ErrorResponse error = new ErrorResponse("ANALYSIS_NOT_COMPLETED", e.getMessage());
            return ResponseEntity.status(400)
                    .body(ApiResponse.error("Анализ еще не завершен", error));
        } catch (Exception e) {
            ErrorResponse error = new ErrorResponse(
                    "INTERNAL_SERVER_ERROR",
                    "Произошла ошибка при запуске генерации стратегии");
            return ResponseEntity.status(500)
                    .body(ApiResponse.error("Внутренняя ошибка сервера", error));
        }
    }

        @GetMapping("/strategy/{strategyId}")
        public ResponseEntity<?> getStrategy(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String strategyId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingStrategy> optStrategy = marketingStrategyService.getStrategyById(strategyId);
                if (optStrategy.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Стратегия с указанным ID не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                }

                MarketingStrategy strategy = optStrategy.get();
                if (!userId.equals(strategy.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этой стратегии");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                MarketingStrategyResponse result = marketingStrategyService.getStrategyResult(strategyId);
                return ResponseEntity.ok(ApiResponse.success(result));
        }

        @GetMapping("/{analysisId}/strategy")
        public ResponseEntity<?> getStrategyByAnalysis(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String analysisId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                // Check if user owns the analysis
                Optional<MarketingAnalysis> optAnalysis = marketingAnalysisService.getAnalysisById(analysisId);
                if (optAnalysis.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Анализ с указанным ID не найден");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Анализ не найден", error));
                }

                MarketingAnalysis analysis = optAnalysis.get();
                if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                MarketingStrategyResponse result = marketingStrategyService.getStrategyByAnalysisId(analysisId);

                if (result == null) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Стратегия для указанного анализа не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                }

                return ResponseEntity.ok(ApiResponse.success(result));
        }

        @GetMapping("/my")
        public ResponseEntity<?> getMyAnalyses(
                        @RequestHeader(value = "Authorization", required = false) String authHeader) {

                try {
                        logger.info("Getting analyses for user");
                        String userId = extractUserIdFromHeader(authHeader);
                        if (userId == null) {
                                logger.warn("Unauthorized request to /my endpoint");
                                return unauthorizedResponse();
                        }

                        logger.debug("Fetching analyses for userId: {}", userId);
                        List<MarketingAnalysis> analyses = marketingAnalysisService.getUserAnalyses(userId);
                        logger.debug("Found {} analyses for userId: {}", analyses.size(), userId);

                        List<AnalysisHistoryResponse> responseList = analyses.stream()
                                        .map(analysis -> {
                                                try {
                                                        return convertToHistoryResponse(analysis);
                                                } catch (Exception e) {
                                                        logger.error("Error converting analysis {} to history response: {}",
                                                                        analysis != null ? analysis.getId() : "null",
                                                                        e.getMessage(), e);
                                                        throw e;
                                                }
                                        })
                                        .collect(Collectors.toList());

                        logger.info("Successfully retrieved {} analyses for userId: {}", responseList.size(), userId);
                        return ResponseEntity.ok(ApiResponse.success(responseList));
                } catch (Exception e) {
                        logger.error("Error in getMyAnalyses endpoint: {}", e.getMessage(), e);
                        ErrorResponse error = new ErrorResponse(
                                        "INTERNAL_SERVER_ERROR",
                                        "Произошла внутренняя ошибка сервера. Попробуйте позже.");
                        return ResponseEntity.status(500)
                                        .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                }
        }

        @GetMapping("/strategy/my")
        public ResponseEntity<?> getMyStrategies(
                        @RequestHeader(value = "Authorization", required = false) String authHeader) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                List<MarketingStrategy> strategies = marketingStrategyService.getUserStrategies(userId);
                List<StrategyHistoryResponse> responseList = strategies.stream()
                                .map(this::convertToStrategyHistoryResponse)
                                .collect(Collectors.toList());

                return ResponseEntity.ok(ApiResponse.success(responseList));
        }

        @GetMapping("/{analysisId}/history")
        public ResponseEntity<?> getAnalysisHistory(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String analysisId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingAnalysis> optAnalysis = marketingAnalysisService.getAnalysisById(analysisId);
                if (optAnalysis.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Анализ с указанным ID не найден");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Анализ не найден", error));
                }

                MarketingAnalysis analysis = optAnalysis.get();
                if (!userId.equals(analysis.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этому анализу");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                AnalysisHistoryResponse response = convertToHistoryResponse(analysis);
                return ResponseEntity.ok(ApiResponse.success(response));
        }

        @GetMapping("/strategy/{strategyId}/history")
        public ResponseEntity<?> getStrategyHistory(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String strategyId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                Optional<MarketingStrategy> optStrategy = marketingStrategyService.getStrategyById(strategyId);
                if (optStrategy.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Стратегия с указанным ID не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                }

                MarketingStrategy strategy = optStrategy.get();
                if (!userId.equals(strategy.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этой стратегии");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                StrategyHistoryResponse response = convertToStrategyHistoryResponse(strategy);
                return ResponseEntity.ok(ApiResponse.success(response));
        }

        private AnalysisHistoryResponse convertToHistoryResponse(MarketingAnalysis analysis) {
                if (analysis == null) {
                        logger.error("Attempted to convert null analysis to history response");
                        throw new IllegalArgumentException("Analysis cannot be null");
                }

                AnalysisHistoryResponse response = new AnalysisHistoryResponse();
                response.setAnalysisId(analysis.getId());
                response.setBusinessNiche(analysis.getBusinessNiche());
                response.setProduct(analysis.getProduct());

                // Convert targetAudience Map to String representation
                Map<String, Object> targetAudienceMap = analysis.getTargetAudience();
                if (targetAudienceMap != null) {
                        StringBuilder audienceBuilder = new StringBuilder();
                        if (targetAudienceMap.containsKey("genders")) {
                                @SuppressWarnings("unchecked")
                                List<String> genders = (List<String>) targetAudienceMap.get("genders");
                                if (genders != null && !genders.isEmpty()) {
                                        audienceBuilder.append("Гендер: ").append(String.join(", ", genders))
                                                        .append(". ");
                                }
                        }
                        if (targetAudienceMap.containsKey("ageRanges")) {
                                @SuppressWarnings("unchecked")
                                List<String> ageRanges = (List<String>) targetAudienceMap.get("ageRanges");
                                if (ageRanges != null && !ageRanges.isEmpty()) {
                                        audienceBuilder.append("Возраст: ").append(String.join(", ", ageRanges))
                                                        .append(". ");
                                }
                        }
                        if (targetAudienceMap.containsKey("types")) {
                                @SuppressWarnings("unchecked")
                                List<String> types = (List<String>) targetAudienceMap.get("types");
                                if (types != null && !types.isEmpty()) {
                                        audienceBuilder.append("Тип: ").append(String.join(", ", types)).append(". ");
                                }
                        }
                        response.setTargetAudience(audienceBuilder.toString().trim());
                }

                // Convert region List to String
                List<String> regions = analysis.getRegion();
                if (regions != null && !regions.isEmpty()) {
                        response.setRegion(String.join(", ", regions));
                }

                response.setGoal(analysis.getGoal());
                response.setDetailLevel(analysis.getDetailLevel());
                response.setStrongSide(analysis.getStrongSide());
                response.setWeakSide(analysis.getWeakSide());

                // Convert analysisType List to String
                List<String> analysisTypes = analysis.getAnalysisType();
                if (analysisTypes != null && !analysisTypes.isEmpty()) {
                        response.setAnalysisType(String.join(", ", analysisTypes));
                }

                response.setStatus(analysis.getStatus());
                response.setUserId(analysis.getUserId());
                response.setCreatedAt(analysis.getCreatedAt());
                response.setCompletedAt(analysis.getCompletedAt());
                response.setStatusHistory(analysis.getStatusHistory());

                // Ищем связанный v2 анализ
                String v2AnalysisId = analysis.getV2AnalysisId();
                if (v2AnalysisId == null || v2AnalysisId.isEmpty()) {
                        // Если v2AnalysisId не установлен, пытаемся найти по analysisId
                        Optional<MarketingAnalysisV2Document> optV2 = marketingAnalysisService
                                        .getV2AnalysisByAnalysisId(analysis.getId());
                        if (optV2.isPresent()) {
                                v2AnalysisId = optV2.get().getId();
                                // Обновляем анализ для сохранения связи
                                analysis.setV2AnalysisId(v2AnalysisId);
                                marketingAnalysisService.updateAnalysis(analysis);
                        }
                }
                response.setV2AnalysisId(v2AnalysisId);

                return response;
        }

        private StrategyHistoryResponse convertToStrategyHistoryResponse(MarketingStrategy strategy) {
                StrategyHistoryResponse response = new StrategyHistoryResponse();
                response.setStrategyId(strategy.getId());
                response.setAnalysisId(strategy.getAnalysisId());
                response.setStatus(strategy.getStatus());
                response.setUserId(strategy.getUserId());
                response.setDurationWeeks(strategy.getDurationWeeks());
                response.setPriorityPlatforms(strategy.getPriorityPlatforms());
                response.setCreatedAt(strategy.getCreatedAt());
                response.setCompletedAt(strategy.getCompletedAt());
                response.setStatusHistory(strategy.getStatusHistory());
                return response;
        }

        @PostMapping("/strategy/{strategyId}/start")
        public ResponseEntity<?> startStrategy(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String strategyId,
                        @RequestBody(required = false) StartStrategyRequest request) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                // Проверяем существование стратегии и права доступа
                Optional<MarketingStrategy> optStrategy = marketingStrategyService.getStrategyById(strategyId);
                if (optStrategy.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Стратегия с указанным ID не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                }

                MarketingStrategy strategy = optStrategy.get();
                if (!userId.equals(strategy.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этой стратегии");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                if (!"completed".equals(strategy.getStatus())) {
                        ErrorResponse error = new ErrorResponse(
                                        "INVALID_STATUS",
                                        "Стратегия еще не завершена. Статус: " + strategy.getStatus());
                        return ResponseEntity.status(400)
                                        .body(ApiResponse.error("Стратегия не готова к запуску", error));
                }

                try {
                        // Создаем задачи из стратегии
                        List<PostingTask> tasks = postingTaskService.createTasksFromStrategy(strategyId);

                        // Получаем список платформ
                        List<String> platforms = tasks.stream()
                                        .map(PostingTask::getPlatform)
                                        .distinct()
                                        .collect(Collectors.toList());

                        StartStrategyResponse response = new StartStrategyResponse(
                                        strategyId,
                                        tasks.size(),
                                        platforms,
                                        "Стратегия успешно запущена. Создано задач: " + tasks.size());

                        return ResponseEntity.ok(ApiResponse.success(
                                        "Стратегия успешно запущена",
                                        response));

                } catch (IllegalStateException e) {
                        ErrorResponse error = new ErrorResponse(
                                        "MISSING_CREDENTIALS",
                                        e.getMessage());
                        return ResponseEntity.status(400)
                                        .body(ApiResponse.error("Не удалось запустить стратегию", error));
                } catch (IllegalArgumentException e) {
                        ErrorResponse error = new ErrorResponse(
                                        "INVALID_STRATEGY",
                                        e.getMessage());
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                } catch (Exception e) {
                        ErrorResponse error = new ErrorResponse(
                                        "INTERNAL_SERVER_ERROR",
                                        "Произошла ошибка при запуске стратегии");
                        return ResponseEntity.status(500)
                                        .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                }
        }

        @PostMapping("/tasks/{taskId}/execute")
        public ResponseEntity<?> executeTaskManually(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String taskId) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                // Проверяем существование задачи и права доступа
                Optional<PostingTask> optTask = postingTaskService.getTaskById(taskId);
                if (optTask.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Задача с указанным ID не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Задача не найдена", error));
                }

                PostingTask task = optTask.get();
                if (!userId.equals(task.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этой задаче");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                try {
                        // Запускаем задачу вручную
                        postingTaskService.executeTaskManually(taskId);

                        // Получаем обновленную задачу для ответа
                        Optional<PostingTask> updatedTask = postingTaskService.getTaskById(taskId);
                        if (updatedTask.isPresent()) {
                                PostingTask taskData = updatedTask.get();
                                Map<String, Object> responseData = new HashMap<>();
                                responseData.put("taskId", taskData.getId());
                                responseData.put("status", taskData.getStatus());
                                responseData.put("platform", taskData.getPlatform());
                                responseData.put("publishDate", taskData.getPublishDate());

                                return ResponseEntity.ok(ApiResponse.success(
                                                "Задача успешно запущена",
                                                responseData));
                        } else {
                                // Если задача не найдена после выполнения (маловероятно)
                                Map<String, Object> responseData = new HashMap<>();
                                responseData.put("taskId", taskId);
                                responseData.put("status", "processing");

                                return ResponseEntity.ok(ApiResponse.success(
                                                "Задача успешно запущена",
                                                responseData));
                        }

                } catch (IllegalArgumentException e) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        e.getMessage());
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Задача не найдена", error));
                } catch (IllegalStateException e) {
                        ErrorResponse error = new ErrorResponse(
                                        "INVALID_STATUS",
                                        e.getMessage());
                        return ResponseEntity.status(400)
                                        .body(ApiResponse.error("Задача не может быть запущена", error));
                } catch (Exception e) {
                        logger.error("Error executing task {} manually: {}", taskId, e.getMessage(), e);
                        ErrorResponse error = new ErrorResponse(
                                        "INTERNAL_SERVER_ERROR",
                                        "Произошла ошибка при запуске задачи");
                        return ResponseEntity.status(500)
                                        .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                }
        }

        @ExceptionHandler(MethodArgumentNotValidException.class)
        public ResponseEntity<ApiResponse<ErrorResponse>> handleValidationException(
                        MethodArgumentNotValidException ex) {

                Map<String, String> details = new HashMap<>();
                ex.getBindingResult().getFieldErrors().forEach(error -> {
                        details.put(error.getField(), error.getDefaultMessage());
                });

                ErrorResponse errorResponse = new ErrorResponse(
                                "VALIDATION_ERROR",
                                "Ошибка валидации входных данных",
                                details);

                return ResponseEntity.badRequest()
                                .body(ApiResponse.error("Ошибка валидации", errorResponse));
        }

        @PostMapping("/strategy/{strategyId}/post/{postIndex}/regenerate-image")
        public ResponseEntity<?> regeneratePostImage(
                        @RequestHeader(value = "Authorization", required = false) String authHeader,
                        @PathVariable String strategyId,
                        @PathVariable int postIndex) {

                String userId = extractUserIdFromHeader(authHeader);
                if (userId == null) {
                        return unauthorizedResponse();
                }

                // Проверяем существование стратегии и права доступа
                Optional<MarketingStrategy> optStrategy = marketingStrategyService.getStrategyById(strategyId);
                if (optStrategy.isEmpty()) {
                        ErrorResponse error = new ErrorResponse(
                                        "NOT_FOUND",
                                        "Стратегия с указанным ID не найдена");
                        return ResponseEntity.status(404)
                                        .body(ApiResponse.error("Стратегия не найдена", error));
                }

                MarketingStrategy strategy = optStrategy.get();
                if (!userId.equals(strategy.getUserId())) {
                        ErrorResponse error = new ErrorResponse(
                                        "FORBIDDEN",
                                        "У вас нет доступа к этой стратегии");
                        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                                        .body(ApiResponse.error("Доступ запрещен", error));
                }

                try {
                        // Регенерируем изображение
                        MarketingStrategy.PostCalendarItem updatedItem = marketingStrategyService
                                        .regeneratePostImage(strategyId, postIndex);

                        if (updatedItem == null) {
                                ErrorResponse error = new ErrorResponse(
                                                "INVALID_POST_INDEX",
                                                "Пост с указанным индексом не найден в стратегии");
                                return ResponseEntity.status(404)
                                                .body(ApiResponse.error("Пост не найден", error));
                        }

                        // Формируем ответ с обновленными данными поста
                        Map<String, Object> responseData = new HashMap<>();
                        responseData.put("strategyId", strategyId);
                        responseData.put("postIndex", postIndex);
                        responseData.put("imageUrl", updatedItem.getImageUrl());
                        responseData.put("imageFilename", updatedItem.getImageFilename());
                        responseData.put("theme", updatedItem.getTheme());
                        responseData.put("platform", updatedItem.getPlatform());
                        responseData.put("publishDate", updatedItem.getPublishDate());

                        return ResponseEntity.ok(ApiResponse.success(
                                        "Изображение для поста успешно регенерировано",
                                        responseData));
                } catch (Exception e) {
                        logger.error("Error regenerating post image: {}", e.getMessage(), e);
                        ErrorResponse error = new ErrorResponse(
                                        "INTERNAL_SERVER_ERROR",
                                        "Произошла ошибка при регенерации изображения");
                        return ResponseEntity.status(500)
                                        .body(ApiResponse.error("Внутренняя ошибка сервера", error));
                }
        }

        @ExceptionHandler(Exception.class)
        public ResponseEntity<ApiResponse<ErrorResponse>> handleGenericException(Exception e) {
                logger.error("Unhandled exception in MarketingController: {}", e.getMessage(), e);
                ErrorResponse errorResponse = new ErrorResponse(
                                "INTERNAL_SERVER_ERROR",
                                "Произошла внутренняя ошибка сервера. Попробуйте позже.");

                return ResponseEntity.status(500)
                                .body(ApiResponse.error("Внутренняя ошибка сервера", errorResponse));
        }
}
