package kz.konturai.parser.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import kz.konturai.parser.dto.MarketingAnalysisResult;
import kz.konturai.parser.dto.MarketingStrategyRequest;
import kz.konturai.parser.dto.MarketingStrategyResponse;
import kz.konturai.parser.dto.StatusHistoryEntry;
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.repository.MarketingAnalysisRepository;
import kz.konturai.parser.repository.MarketingAnalysisV2Repository;
import kz.konturai.parser.repository.MarketingStrategyRepository;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class MarketingStrategyService {

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

    private final MarketingStrategyRepository repository;
    private final MarketingAnalysisService marketingAnalysisService;
    private final MarketingAnalysisRepository analysisRepository;
    private final MarketingAnalysisV2Repository v2Repository;
    private final OpenAIAnalyticsService openAIAnalyticsService;
    private final ImageGenerationService imageGenerationService;
    private final MinIOService minIOService;
    private final PostingTaskService postingTaskService;
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Value("${image.generation.delayBetweenRequestsMs:3000}")
    private long delayBetweenRequestsMs;


    public MarketingStrategy generateStrategy(String analysisId, MarketingStrategyRequest request, String userId) {
        MarketingAnalysisResult analysisResult = marketingAnalysisService.getAnalysisResult(analysisId);

        if (analysisResult == null) {
            Optional<MarketingAnalysisV2Document> v2Opt = v2Repository.findById(analysisId);
            if (v2Opt.isPresent()) {
                analysisResult = convertV2ToResult(v2Opt.get());
            }
        }

        if (analysisResult == null) {
            throw new IllegalArgumentException("Анализ с ID " + analysisId + " не найден");
        }

        if (!"completed".equals(analysisResult.getStatus())) {
            throw new IllegalStateException("Анализ еще не завершен. Статус: " + analysisResult.getStatus());
        }

        Optional<MarketingStrategy> existingStrategy = repository.findFirstByAnalysisIdOrderByCreatedAtDesc(analysisId);
        if (existingStrategy.isPresent()) {
            logger.info("Стратегия для анализа {} уже существует: {}", analysisId, existingStrategy.get().getId());
            return existingStrategy.get();
        }

        MarketingStrategy strategy = new MarketingStrategy(analysisId);
        strategy.setUserId(userId);
        strategy.setDurationWeeks(request.getDurationWeeks() != null ? request.getDurationWeeks() : 4);
        strategy.setPriorityPlatforms(request.getPriorityPlatforms());
        strategy.setStatus("queued");
        addStatusHistoryEntry(strategy, "queued", "Стратегия создана и добавлена в очередь");
        strategy = repository.save(strategy);

        logger.info("Marketing strategy created with ID: {} for user: {}", strategy.getId(), userId);

        processStrategyGeneration(strategy.getId(), analysisId, analysisResult);

        return strategy;
    }

    private MarketingAnalysisResult convertV2ToResult(MarketingAnalysisV2Document v2Doc) {
        MarketingAnalysisResult result = new MarketingAnalysisResult();
        result.setAnalysisId(v2Doc.getId());
        result.setStatus("completed");

        MarketingAnalysisResult.MarketingReport report = new MarketingAnalysisResult.MarketingReport();

        StringBuilder fullAnalysisBuilder = new StringBuilder();
        fullAnalysisBuilder.append("# Маркетинговый анализ (V2)\n\n");

        if (v2Doc.getProduct() != null) fullAnalysisBuilder.append("**Продукт:** ").append(v2Doc.getProduct()).append("\n");
        if (v2Doc.getBusinessNiche() != null) fullAnalysisBuilder.append("**Ниша:** ").append(v2Doc.getBusinessNiche()).append("\n");
        if (v2Doc.getGoal() != null) fullAnalysisBuilder.append("**Цель:** ").append(v2Doc.getGoal()).append("\n\n");

        if (v2Doc.getAnalysisData() != null) {
            try {
                String jsonData = objectMapper.writeValueAsString(v2Doc.getAnalysisData());
                fullAnalysisBuilder.append("**Детальные данные анализа:**\n").append(jsonData);
            } catch (Exception e) {
                fullAnalysisBuilder.append("Ошибка обработки данных анализа V2.");
            }
        } else {
            fullAnalysisBuilder.append("Детальный анализ недоступен.");
        }

        report.setFullAnalysis(fullAnalysisBuilder.toString());
        report.setSummary("Анализ V2 для продукта: " + v2Doc.getProduct());

        result.setReport(report);
        return result;
    }

    private void addStatusHistoryEntry(MarketingStrategy strategy, String status, String message) {
        if (strategy.getStatusHistory() == null) {
            strategy.setStatusHistory(new ArrayList<>());
        }
        StatusHistoryEntry entry = new StatusHistoryEntry(status, LocalDateTime.now(), message);
        strategy.getStatusHistory().add(entry);
    }

    @Async("reportGenerationExecutor")
    public void processStrategyGeneration(String strategyId, String analysisId,
                                          MarketingAnalysisResult analysisResult) {
        try {
            Optional<MarketingStrategy> optStrategy = repository.findById(strategyId);
            if (optStrategy.isEmpty()) {
                logger.error("Marketing strategy not found: {}", strategyId);
                return;
            }

            MarketingStrategy strategy = optStrategy.get();
            strategy.setStatus("processing");
            addStatusHistoryEntry(strategy, "processing", "Начата генерация стратегии");
            repository.save(strategy);

            logger.info("Starting marketing strategy generation for ID: {}", strategyId);

            String context = buildContextFromAnalysis(analysisResult);

            String businessContext = getBusinessContextFromAnalysis(analysisId);

            List<MarketingStrategy.WeeklyPlan> weeklyPlans = generateWeeklyPlans(
                    context, strategy.getDurationWeeks(), strategy.getPriorityPlatforms());

            List<MarketingStrategy.PostCalendarItem> postCalendar = generatePostCalendar(
                    context, strategy.getDurationWeeks(), strategy.getPriorityPlatforms(), weeklyPlans,
                    businessContext);

            strategy.setStatus("completed");
            strategy.setCompletedAt(LocalDateTime.now());
            strategy.setWeeklyPlans(weeklyPlans);
            strategy.setPostCalendar(postCalendar);

            Map<String, Object> strategyData = new HashMap<>();
            strategyData.put("weeklyPlans", weeklyPlans);
            strategyData.put("postCalendar", postCalendar);
            strategy.setStrategyData(strategyData);

            addStatusHistoryEntry(strategy, "completed", "Стратегия успешно сгенерирована");
            repository.save(strategy);

            logger.info("Marketing strategy generation completed successfully for ID: {}", strategyId);

        } catch (Exception e) {
            logger.error("Error processing marketing strategy {}: {}", strategyId, e.getMessage(), e);
            try {
                Optional<MarketingStrategy> optStrategy = repository.findById(strategyId);
                if (optStrategy.isPresent()) {
                    MarketingStrategy strategy = optStrategy.get();
                    strategy.setStatus("failed");
                    addStatusHistoryEntry(strategy, "failed", "Ошибка при генерации стратегии: " + e.getMessage());
                    repository.save(strategy);
                }
            } catch (Exception saveError) {
                logger.error("Failed to update strategy status to failed: {}", saveError.getMessage());
            }
        }
    }

    private String buildContextFromAnalysis(MarketingAnalysisResult analysisResult) {
        StringBuilder context = new StringBuilder();

        if (analysisResult.getReport() != null) {
            MarketingAnalysisResult.MarketingReport report = analysisResult.getReport();

            if (report.getSummary() != null) {
                context.append("Резюме анализа: ").append(report.getSummary()).append("\n\n");
            }

            if (report.getFullAnalysis() != null && !report.getFullAnalysis().isBlank()) {
                String full = report.getFullAnalysis().trim();
                int maxChars = 12000;
                if (full.length() > maxChars) {
                    full = full.substring(0, maxChars) + "\n\n(…обрезано для лимита контекста…)";
                }
                context.append("Полный анализ (Markdown):\n").append(full).append("\n\n");
            }
        }

        return context.toString();
    }

    private List<MarketingStrategy.WeeklyPlan> generateWeeklyPlans(
            String context, Integer durationWeeks, List<String> priorityPlatforms) {
        try {
            String platformsStr = priorityPlatforms != null && !priorityPlatforms.isEmpty()
                    ? String.join(", ", priorityPlatforms)
                    : "Instagram, Facebook, LinkedIn, Telegram, TikTok, YouTube";

            String prompt = String.format(
                    "На основе следующего маркетингового анализа создай детальный недельный план продвижения на %d недель.\n\n"
                            +
                            "Требования:\n" +
                            "1. Создай план для каждой недели отдельно\n" +
                            "2. Для каждой недели укажи:\n" +
                            "   - Основные темы недели (3-5 тем)\n" +
                            "   - Рекомендации по контенту (1-2 абзаца)\n" +
                            "   - Приоритетные платформы для этой недели\n" +
                            "3. Платформы для использования (СТРОГО ТОЛЬКО ЭТИ ПЛАТФОРМЫ, НЕ ДОБАВЛЯЙ ДРУГИЕ): %s\n" +
                            "   ВАЖНО: Используй ТОЛЬКО указанные платформы. Если указан Facebook, используй ТОЛЬКО Facebook (НЕ добавляй Instagram).\n"
                            +
                            "   Если указан Instagram, используй ТОЛЬКО Instagram (НЕ добавляй Facebook).\n" +
                            "   Каждая платформа независима - не предполагай связи между платформами.\n" +
                            "4. Ответ должен быть структурированным и применимым на практике\n" +
                            "5. Ответ должен быть на русском языке\n\n" +
                            "Верни ответ в формате JSON со следующей структурой:\n" +
                            "{\n" +
                            "  \"weeklyPlans\": [\n" +
                            "    {\n" +
                            "      \"weekNumber\": 1,\n" +
                            "      \"mainThemes\": [\"тема1\", \"тема2\", \"тема3\"],\n" +
                            "      \"contentRecommendations\": \"рекомендации по контенту\",\n" +
                            "      \"priorityPlatforms\": [\"Instagram\", \"Facebook\"]\n" +
                            "    }\n" +
                            "  ]\n" +
                            "}\n\n" +
                            "Маркетинговый анализ:\n%s",
                    durationWeeks, platformsStr, context);

            String response = openAIAnalyticsService.generateWithInstruction(context, prompt, "ru");
            if (response == null || response.trim().isEmpty()) {
                logger.warn("Failed to generate weekly plans, using default");
                return generateDefaultWeeklyPlans(durationWeeks, priorityPlatforms);
            }

            String jsonStr = extractJsonFromResponse(response);
            if (jsonStr == null) {
                logger.warn("Could not extract JSON from weekly plans response, using default");
                return generateDefaultWeeklyPlans(durationWeeks, priorityPlatforms);
            }

            Map<String, Object> jsonMap = objectMapper.readValue(jsonStr, new TypeReference<Map<String, Object>>() {
            });
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> weeklyPlansList = (List<Map<String, Object>>) jsonMap.get("weeklyPlans");

            if (weeklyPlansList == null || weeklyPlansList.isEmpty()) {
                logger.warn("Weekly plans list is empty, using default");
                return generateDefaultWeeklyPlans(durationWeeks, priorityPlatforms);
            }

            List<MarketingStrategy.WeeklyPlan> plans = new ArrayList<>();
            for (Map<String, Object> planMap : weeklyPlansList) {
                MarketingStrategy.WeeklyPlan plan = new MarketingStrategy.WeeklyPlan();
                plan.setWeekNumber(((Number) planMap.get("weekNumber")).intValue());

                @SuppressWarnings("unchecked")
                List<String> themes = (List<String>) planMap.get("mainThemes");
                plan.setMainThemes(themes != null ? themes : new ArrayList<>());

                plan.setContentRecommendations((String) planMap.get("contentRecommendations"));

                @SuppressWarnings("unchecked")
                List<String> platforms = (List<String>) planMap.get("priorityPlatforms");
                if (platforms != null && priorityPlatforms != null && !priorityPlatforms.isEmpty()) {
                    platforms = platforms.stream()
                            .filter(p -> priorityPlatforms.stream()
                                    .anyMatch(pp -> pp.equalsIgnoreCase(p)))
                            .collect(Collectors.toList());
                }
                plan.setPriorityPlatforms(platforms != null ? platforms : new ArrayList<>());

                plans.add(plan);
            }

            return plans;

        } catch (Exception e) {
            logger.error("Error generating weekly plans: {}", e.getMessage(), e);
            return generateDefaultWeeklyPlans(durationWeeks, priorityPlatforms);
        }
    }

    private String getBusinessContextFromAnalysis(String analysisId) {
        try {
            Optional<MarketingAnalysis> optAnalysis = analysisRepository.findById(analysisId);
            if (optAnalysis.isPresent()) {
                return extractContextFromV1(optAnalysis.get());
            }

            Optional<MarketingAnalysisV2Document> optV2 = v2Repository.findById(analysisId);
            if (optV2.isPresent()) {
                return extractContextFromV2(optV2.get());
            }

        } catch (Exception e) {
            logger.warn("Failed to get business context from analysis: {}", e.getMessage());
        }
        return "";
    }

    private String extractContextFromV1(MarketingAnalysis analysis) {
        StringBuilder businessContext = new StringBuilder();
        if (analysis.getProduct() != null && !analysis.getProduct().isEmpty()) {
            businessContext.append("Главный объект изображения (продукт): ").append(analysis.getProduct()).append(". ");
        }
        if (analysis.getBusinessNiche() != null && !analysis.getBusinessNiche().isEmpty()) {
            businessContext.append("Ниша: ").append(analysis.getBusinessNiche()).append(". ");
        }
        if (analysis.getTargetAudience() != null) {
            Map<String, Object> ta = analysis.getTargetAudience();
            appendTargetAudience(businessContext, ta);
        }
        return businessContext.toString();
    }

    private String extractContextFromV2(MarketingAnalysisV2Document v2) {
        StringBuilder businessContext = new StringBuilder();
        if (v2.getProduct() != null && !v2.getProduct().isEmpty()) {
            businessContext.append("Главный объект изображения (продукт): ").append(v2.getProduct()).append(". ");
        }
        if (v2.getBusinessNiche() != null && !v2.getBusinessNiche().isEmpty()) {
            businessContext.append("Ниша: ").append(v2.getBusinessNiche()).append(". ");
        }
        if (v2.getTargetAudience() != null) {
            if (v2.getTargetAudience() instanceof Map) {
                @SuppressWarnings("unchecked")
                Map<String, Object> ta = (Map<String, Object>) v2.getTargetAudience();
                appendTargetAudience(businessContext, ta);
            } else if (v2.getTargetAudience() != null) {
                businessContext.append("Целевая аудитория: ").append(v2.getTargetAudience().toString()).append(". ");
            }
        }
        return businessContext.toString();
    }

    private void appendTargetAudience(StringBuilder sb, Map<String, Object> ta) {
        if (ta.containsKey("ageRanges") || ta.containsKey("types")) {
            sb.append("Целевая аудитория (люди на фото): ");
            if (ta.containsKey("types")) {
                sb.append(ta.get("types")).append(" ");
            }
            if (ta.containsKey("ageRanges")) {
                sb.append("возраст ").append(ta.get("ageRanges"));
            }
            sb.append(". ");
        }
    }

    private List<MarketingStrategy.PostCalendarItem> generatePostCalendar(
            String context, Integer durationWeeks, List<String> priorityPlatforms,
            List<MarketingStrategy.WeeklyPlan> weeklyPlans, String businessContext) {
        try {
            String platformsStr = priorityPlatforms != null && !priorityPlatforms.isEmpty()
                    ? String.join(", ", priorityPlatforms)
                    : "Instagram, Facebook, LinkedIn, Telegram, TikTok, YouTube";

            String weeklyPlansSummary = "";
            if (weeklyPlans != null && !weeklyPlans.isEmpty()) {
                weeklyPlansSummary = weeklyPlans.stream()
                        .map(plan -> String.format("Неделя %d: %s", plan.getWeekNumber(),
                                plan.getMainThemes() != null ? String.join(", ", plan.getMainThemes()) : ""))
                        .collect(Collectors.joining("\n"));
            }

            LocalDateTime startDate = LocalDateTime.now().plusDays(1);

            String prompt = String.format(
                    "На основе следующего маркетингового анализа и недельного плана создай детальный календарь постов на %d недель.\n\n"
                            +
                            "Требования:\n" +
                            "1. Создай конкретные посты для публикации\n" +
                            "2. Для каждого поста укажи:\n" +
                            "   - Дату публикации (в формате YYYY-MM-DD)\n" +
                            "   - Время публикации (в формате HH:mm, например 10:00, 14:00, 18:00)\n" +
                            "   - Платформу (СТРОГО ОДНУ ИЗ: %s)\n" +
                            "   - Тип контента (пост, сторис, видео, баннер)\n" +
                            "   - Тему поста\n" +
                            "   - Полный текст поста (готовый к публикации, 100-300 символов)\n" +
                            "   - Хештеги (5-10 релевантных хештегов)\n" +
                            "3. Распредели посты равномерно по неделям\n" +
                            "4. Рекомендуемое количество постов: 3-5 постов в неделю\n" +
                            "5. Чередуй платформы и типы контента\n" +
                            "6. ВАЖНО: Используй ТОЛЬКО указанные платформы. Если указан Facebook, используй ТОЛЬКО Facebook (НЕ добавляй Instagram).\n"
                            +
                            "   Если указан Instagram, используй ТОЛЬКО Instagram (НЕ добавляй Facebook).\n" +
                            "   Каждая платформа независима - не предполагай связи между платформами.\n" +
                            "7. Ответ должен быть на русском языке\n\n" +
                            "Верни ответ в формате JSON со следующей структурой:\n" +
                            "{\n" +
                            "  \"postCalendar\": [\n" +
                            "    {\n" +
                            "      \"publishDate\": \"2024-01-15T10:00:00\",\n" +
                            "      \"platform\": \"Instagram\",\n" +
                            "      \"contentType\": \"пост\",\n" +
                            "      \"theme\": \"тема поста\",\n" +
                            "      \"postText\": \"полный текст поста\",\n" +
                            "      \"hashtags\": [\"#хештег1\", \"#хештег2\"],\n" +
                            "      \"publishTime\": \"10:00\"\n" +
                            "    }\n" +
                            "  ]\n" +
                            "}\n\n" +
                            "Начальная дата: %s\n\n" +
                            "Недельный план:\n%s\n\n" +
                            "Маркетинговый анализ:\n%s",
                    durationWeeks, platformsStr, startDate.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME),
                    weeklyPlansSummary, context);

            String response = openAIAnalyticsService.generateWithInstruction(context, prompt, "ru");
            if (response == null || response.trim().isEmpty()) {
                logger.warn("Failed to generate post calendar, using default");
                return generateDefaultPostCalendar(durationWeeks, priorityPlatforms, startDate);
            }

            String jsonStr = extractJsonFromResponse(response);
            if (jsonStr == null) {
                logger.warn("Could not extract JSON from post calendar response, using default");
                return generateDefaultPostCalendar(durationWeeks, priorityPlatforms, startDate);
            }

            Map<String, Object> jsonMap = objectMapper.readValue(jsonStr, new TypeReference<Map<String, Object>>() {
            });
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> postCalendarList = (List<Map<String, Object>>) jsonMap.get("postCalendar");

            if (postCalendarList == null || postCalendarList.isEmpty()) {
                logger.warn("Post calendar list is empty, using default");
                return generateDefaultPostCalendar(durationWeeks, priorityPlatforms, startDate);
            }

            List<MarketingStrategy.PostCalendarItem> calendar = new ArrayList<>();
            for (Map<String, Object> postMap : postCalendarList) {
                MarketingStrategy.PostCalendarItem item = new MarketingStrategy.PostCalendarItem();

                String dateStr = (String) postMap.get("publishDate");
                if (dateStr != null) {
                    try {
                        LocalDateTime publishDate = LocalDateTime.parse(dateStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
                        item.setPublishDate(publishDate);
                    } catch (Exception e) {
                        logger.warn("Failed to parse date: {}", dateStr);
                        item.setPublishDate(startDate.plusDays(calendar.size()));
                    }
                } else {
                    item.setPublishDate(startDate.plusDays(calendar.size()));
                }

                String platformRaw = (String) postMap.get("platform");
                final String platform;
                if (platformRaw != null && priorityPlatforms != null && !priorityPlatforms.isEmpty()) {
                    boolean isValidPlatform = priorityPlatforms.stream()
                            .anyMatch(pp -> pp.equalsIgnoreCase(platformRaw));
                    if (!isValidPlatform) {
                        logger.warn("Platform '{}' not in requested platforms {}, using '{}' instead",
                                platformRaw, priorityPlatforms, priorityPlatforms.get(0));
                        platform = priorityPlatforms.get(0);
                    } else {
                        platform = platformRaw;
                    }
                } else {
                    platform = platformRaw;
                }
                item.setPlatform(platform);
                item.setContentType((String) postMap.get("contentType"));
                item.setTheme((String) postMap.get("theme"));
                item.setPostText((String) postMap.get("postText"));

                @SuppressWarnings("unchecked")
                List<String> hashtags = (List<String>) postMap.get("hashtags");
                item.setHashtags(hashtags != null ? hashtags : new ArrayList<>());

                item.setPublishTime((String) postMap.get("publishTime"));

                generateAndSaveImageForPost(item, businessContext);

                if (delayBetweenRequestsMs > 0) {
                    try {
                        Thread.sleep(delayBetweenRequestsMs);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        logger.warn("Image generation delay interrupted");
                    }
                }

                calendar.add(item);
            }

            return calendar;

        } catch (Exception e) {
            logger.error("Error generating post calendar: {}", e.getMessage(), e);
            return generateDefaultPostCalendar(durationWeeks, priorityPlatforms, LocalDateTime.now().plusDays(1));
        }
    }

    private String extractJsonFromResponse(String response) {
        if (response == null) {
            return null;
        }

        int startIdx = response.indexOf("{");
        int endIdx = response.lastIndexOf("}");

        if (startIdx >= 0 && endIdx > startIdx) {
            return response.substring(startIdx, endIdx + 1);
        }

        startIdx = response.indexOf("[");
        endIdx = response.lastIndexOf("]");

        if (startIdx >= 0 && endIdx > startIdx) {
            return "{\"data\":" + response.substring(startIdx, endIdx + 1) + "}";
        }

        return null;
    }

    private List<MarketingStrategy.WeeklyPlan> generateDefaultWeeklyPlans(
            Integer durationWeeks, List<String> priorityPlatforms) {
        List<MarketingStrategy.WeeklyPlan> plans = new ArrayList<>();
        List<String> platforms = priorityPlatforms != null && !priorityPlatforms.isEmpty()
                ? priorityPlatforms
                : Arrays.asList("Instagram", "Facebook", "LinkedIn");

        for (int i = 1; i <= durationWeeks; i++) {
            MarketingStrategy.WeeklyPlan plan = new MarketingStrategy.WeeklyPlan();
            plan.setWeekNumber(i);
            plan.setMainThemes(Arrays.asList("Презентация продукта", "Преимущества", "Отзывы клиентов"));
            plan.setContentRecommendations(
                    "Создавайте контент, который демонстрирует ценность продукта для целевой аудитории.");
            plan.setPriorityPlatforms(platforms);
            plans.add(plan);
        }

        return plans;
    }

    private void generateAndSaveImageForPost(MarketingStrategy.PostCalendarItem item, String businessContext) {
        try {
            String imagePrompt = buildImagePrompt(item, businessContext);

            logger.info("Generating image with prompt: {}", imagePrompt);

            byte[] imageBytes = imageGenerationService.generateImage(imagePrompt);

            if (imageBytes != null && imageBytes.length > 0) {
                String filename = "post_image_" + System.currentTimeMillis() + "_" + item.hashCode() + ".png";
                minIOService.uploadFile(filename, imageBytes, MediaType.IMAGE_PNG.toString());

                item.setImageFilename(filename);
                item.setImageUrl(filename);

                logger.info("Successfully generated and saved image for post: {}", filename);
            } else {
                logger.warn("Failed to generate image for post with theme: {}", item.getTheme());
            }
        } catch (Exception e) {
            logger.error("Error generating image for post: {}", e.getMessage(), e);
        }
    }

    private String buildImagePrompt(MarketingStrategy.PostCalendarItem item, String businessContext) {
        StringBuilder prompt = new StringBuilder();

        String style = "высококачественная фотография, реалистичное освещение, 8k, высокая детализация";
        if (item.getPlatform() != null) {
            String platform = item.getPlatform().toLowerCase();
            if (platform.contains("linkedin")) {
                style += ", корпоративный стиль, профессионально, минимализм, чисто";
            } else if (platform.contains("instagram") || platform.contains("tiktok")) {
                style += ", лайфстайл, эстетика, яркие цвета, привлекательно, инстаграм-стиль";
            } else if (platform.contains("facebook")) {
                style += ", уютно, дружелюбно, для сообщества";
            }
        }

        prompt.append("Фотореалистичное изображение. ");

        if (businessContext != null && !businessContext.isEmpty()) {
            prompt.append(businessContext).append(" ");
        }

        if (item.getTheme() != null && !item.getTheme().isEmpty()) {
            prompt.append("Сюжет изображения: ").append(item.getTheme()).append(". ");
        }

        prompt.append("Композиция: продукт или услуга в центре внимания. ");
        prompt.append("Если на фото есть люди, они должны взаимодействовать с продуктом естественно. ");
        prompt.append("Избегать: абстрактных концепций, людей с планшетами смотрящих в камеру, искусственных поз, текста на изображении, размытия, искажений. ");

        prompt.append("Визуальный стиль: ").append(style).append(".");

        return prompt.toString();
    }

    private List<MarketingStrategy.PostCalendarItem> generateDefaultPostCalendar(
            Integer durationWeeks, List<String> priorityPlatforms, LocalDateTime startDate) {
        List<MarketingStrategy.PostCalendarItem> calendar = new ArrayList<>();
        List<String> platforms = priorityPlatforms != null && !priorityPlatforms.isEmpty()
                ? priorityPlatforms
                : Arrays.asList("Instagram", "Facebook", "LinkedIn");
        List<String> contentTypes = Arrays.asList("пост", "сторис", "видео");
        List<String> times = Arrays.asList("10:00", "14:00", "18:00");

        int postCount = durationWeeks * 3;
        for (int i = 0; i < postCount; i++) {
            MarketingStrategy.PostCalendarItem item = new MarketingStrategy.PostCalendarItem();
            item.setPublishDate(startDate.plusDays(i * 2));
            item.setPlatform(platforms.get(i % platforms.size()));
            item.setContentType(contentTypes.get(i % contentTypes.size()));
            item.setTheme("Тема поста " + (i + 1));
            item.setPostText("Текст поста для публикации на платформе " + item.getPlatform());
            item.setHashtags(Arrays.asList("#маркетинг", "#бизнес", "#продвижение"));
            item.setPublishTime(times.get(i % times.size()));
            calendar.add(item);
        }

        return calendar;
    }

    public MarketingStrategyResponse getStrategyResult(String strategyId) {
        Optional<MarketingStrategy> optStrategy = repository.findById(strategyId);
        if (optStrategy.isEmpty()) {
            return null;
        }

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

        if (strategy.getWeeklyPlans() != null && strategy.getPostCalendar() != null
                && "completed".equals(strategy.getStatus())) {
            MarketingStrategyResponse.StrategyContent strategyContent = new MarketingStrategyResponse.StrategyContent();

            List<MarketingStrategyResponse.WeeklyPlan> weeklyPlans = new ArrayList<>();
            for (MarketingStrategy.WeeklyPlan plan : strategy.getWeeklyPlans()) {
                MarketingStrategyResponse.WeeklyPlan dtoPlan = new MarketingStrategyResponse.WeeklyPlan();
                dtoPlan.setWeekNumber(plan.getWeekNumber());
                dtoPlan.setMainThemes(plan.getMainThemes());
                dtoPlan.setContentRecommendations(plan.getContentRecommendations());
                dtoPlan.setPriorityPlatforms(plan.getPriorityPlatforms());
                weeklyPlans.add(dtoPlan);
            }
            strategyContent.setWeeklyPlans(weeklyPlans);

            List<MarketingStrategyResponse.PostCalendarItem> postCalendar = new ArrayList<>();
            List<PostingTask> tasks = postingTaskService.getStrategyTasks(strategyId);

            for (MarketingStrategy.PostCalendarItem item : strategy.getPostCalendar()) {
                MarketingStrategyResponse.PostCalendarItem dtoItem = new MarketingStrategyResponse.PostCalendarItem();
                dtoItem.setPublishDate(item.getPublishDate());
                dtoItem.setPlatform(item.getPlatform());
                dtoItem.setContentType(item.getContentType());
                dtoItem.setTheme(item.getTheme());
                dtoItem.setPostText(item.getPostText());
                dtoItem.setHashtags(item.getHashtags());
                dtoItem.setPublishTime(item.getPublishTime());
                dtoItem.setImageUrl(item.getImageUrl());
                dtoItem.setImageFilename(item.getImageFilename());

                Optional<PostingTask> matchingTask = tasks.stream()
                        .filter(task -> task.getPublishDate() != null && item.getPublishDate() != null
                                && task.getPublishDate().equals(item.getPublishDate())
                                && task.getPlatform() != null && item.getPlatform() != null
                                && task.getPlatform().equalsIgnoreCase(item.getPlatform())
                                && task.getPostText() != null && item.getPostText() != null
                                && task.getPostText().equals(item.getPostText()))
                        .findFirst();

                if (matchingTask.isPresent()) {
                    PostingTask task = matchingTask.get();
                    dtoItem.setTaskId(task.getId());
                    dtoItem.setTaskStatus(task.getStatus());
                } else {
                    // Если задача еще не создана, статус null
                    dtoItem.setTaskStatus(null);
                }

                postCalendar.add(dtoItem);
            }
            strategyContent.setPostCalendar(postCalendar);

            response.setStrategy(strategyContent);
        }

        return response;
    }

    public MarketingStrategyResponse getStrategyByAnalysisId(String analysisId) {
        Optional<MarketingStrategy> optStrategy = repository.findFirstByAnalysisIdOrderByCreatedAtDesc(analysisId);
        if (optStrategy.isEmpty()) {
            return null;
        }

        return getStrategyResult(optStrategy.get().getId());
    }

    public List<MarketingStrategy> getUserStrategies(String userId) {
        return repository.findByUserIdOrderByCreatedAtDesc(userId);
    }

    public Optional<MarketingStrategy> getStrategyById(String strategyId) {
        return repository.findById(strategyId);
    }

    public MarketingStrategy.PostCalendarItem regeneratePostImage(String strategyId, int postIndex) {
        Optional<MarketingStrategy> optStrategy = repository.findById(strategyId);
        if (optStrategy.isEmpty()) {
            logger.error("Strategy not found: {}", strategyId);
            return null;
        }

        MarketingStrategy strategy = optStrategy.get();
        List<MarketingStrategy.PostCalendarItem> postCalendar = strategy.getPostCalendar();

        if (postCalendar == null || postIndex < 0 || postIndex >= postCalendar.size()) {
            logger.error("Invalid post index {} for strategy {}. Calendar size: {}",
                    postIndex, strategyId, postCalendar != null ? postCalendar.size() : 0);
            return null;
        }

        MarketingStrategy.PostCalendarItem item = postCalendar.get(postIndex);

        String businessContext = getBusinessContextFromAnalysis(strategy.getAnalysisId());

        generateAndSaveImageForPost(item, businessContext);

        repository.save(strategy);

        logger.info("Successfully regenerated image for post at index {} in strategy {}", postIndex, strategyId);
        return item;
    }
}