package kz.konturai.parser.controller;

import kz.konturai.parser.dto.ApiResponse;
import kz.konturai.parser.dto.HealthCheckDto;
import kz.konturai.parser.service.MarketItemService;
import kz.konturai.parser.service.ParserManagerService;
import kz.konturai.parser.util.RssUrlValidator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * Контроллер для мониторинга и проверки состояния системы.
 * Содержит все health check и информационные эндпоинты.
 */
@RestController
@RequestMapping("/api/parser/health")
public class HealthCheckController {

    @Autowired
    private MarketItemService marketItemService;

    @Autowired
    private ParserManagerService parserManagerService;

    @Autowired
    private RssUrlValidator rssUrlValidator;

    /**
     * Проверка состояния парсера
     */
    @GetMapping
    public ResponseEntity<ApiResponse<HealthCheckDto>> healthCheck() {
        HealthCheckDto health = new HealthCheckDto(
                "UP",
                "RSS Parser System",
                System.currentTimeMillis(),
                "Enabled - runs every 30 minutes");

        return ResponseEntity.ok(ApiResponse.success("Сервис работает", health));
    }

    /**
     * Проверка подключения к MongoDB
     */
    @GetMapping("/mongodb")
    public ResponseEntity<ApiResponse<HealthCheckDto>> checkMongoConnection() {
        try {
            long count = marketItemService.getTotalItemsCount();
            HealthCheckDto health = new HealthCheckDto(
                    "UP",
                    "MongoDB подключение успешно",
                    System.currentTimeMillis(),
                    "Всего записей: " + count);

            return ResponseEntity.ok(ApiResponse.success("MongoDB подключение успешно", health));

        } catch (Exception e) {
            HealthCheckDto health = new HealthCheckDto(
                    "DOWN",
                    "Ошибка подключения к MongoDB: " + e.getMessage(),
                    System.currentTimeMillis(),
                    null);

            if (e.getMessage().contains("Unauthorized") || e.getMessage().contains("authentication")) {
                health.setSuggestion("Проверьте учетные данные в application.properties");
            }

            return ResponseEntity.status(503).body(ApiResponse.error("Ошибка подключения к MongoDB", health));
        }
    }

    /**
     * Получение информации о планировщике
     */
    @GetMapping("/scheduler")
    public ResponseEntity<ApiResponse<java.util.Map<String, Object>>> getSchedulerInfo() {
        try {
            java.util.Map<String, Object> schedulerInfo = new java.util.HashMap<>();

            schedulerInfo.put("schedulerEnabled", true);
            schedulerInfo.put("cronExpression", "0 0/30 * * * ?");
            schedulerInfo.put("description", "Запуск каждые 30 минут (в 0 и 30 минут каждого часа)");
            schedulerInfo.put("nextRun", "Следующий запуск будет в ближайшие 0 или 30 минут часа");
            schedulerInfo.put("activeParsers", parserManagerService.getAvailableParsers());
            schedulerInfo.put("totalParsers", parserManagerService.getParserCount());
            schedulerInfo.put("sources", List.of("Kursiv Media", "Kapital.kz", "LSM.kz", "РБК", "Ведомости"));

            return ResponseEntity.ok(ApiResponse.success("Информация о планировщике получена", schedulerInfo));

        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                    .body(ApiResponse.error("Ошибка при получении информации о планировщике: " + e.getMessage()));
        }
    }

    /**
     * Получение общей информации о системе
     */
    @GetMapping("/system")
    public ResponseEntity<ApiResponse<java.util.Map<String, Object>>> getSystemInfo() {
        try {
            java.util.Map<String, Object> systemInfo = new java.util.HashMap<>();

            // Информация о парсерах
            systemInfo.put("parsers", java.util.Map.of(
                    "total", parserManagerService.getParserCount(),
                    "available", parserManagerService.getAvailableParsers()));

            // Информация о данных
            long totalItems = marketItemService.getTotalItemsCount();
            var sourceStatistics = marketItemService.getSourceStatistics();
            systemInfo.put("data", java.util.Map.of(
                    "totalItems", totalItems,
                    "sourceStatistics", sourceStatistics));

            // Информация о системе
            systemInfo.put("system", java.util.Map.of(
                    "javaVersion", System.getProperty("java.version"),
                    "osName", System.getProperty("os.name"),
                    "osVersion", System.getProperty("os.version"),
                    "uptime", System.currentTimeMillis()));

            return ResponseEntity.ok(ApiResponse.success("Информация о системе получена", systemInfo));

        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                    .body(ApiResponse.error("Ошибка при получении информации о системе: " + e.getMessage()));
        }
    }

    /**
     * Проверка состояния всех парсеров
     */
    @GetMapping("/parsers")
    public ResponseEntity<ApiResponse<java.util.Map<String, Object>>> checkParsersHealth() {
        try {
            java.util.Map<String, Object> parsersHealth = new java.util.HashMap<>();

            List<String> availableParsers = parserManagerService.getAvailableParsers();
            parsersHealth.put("totalParsers", availableParsers.size());
            parsersHealth.put("availableParsers", availableParsers);
            parsersHealth.put("status", "UP");
            parsersHealth.put("message", "Все парсеры доступны");

            return ResponseEntity.ok(ApiResponse.success("Проверка парсеров завершена", parsersHealth));

        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                    .body(ApiResponse.error("Ошибка при проверке парсеров: " + e.getMessage()));
        }
    }

    /**
     * Проверка доступности RSS-лент
     */
    @GetMapping("/rss")
    public ResponseEntity<ApiResponse<java.util.Map<String, Object>>> checkRssFeeds() {
        try {
            // Получаем текущие URL из конфигурации
            java.util.Map<String, String> rssUrls = new java.util.HashMap<>();
            rssUrls.put("kursiv", "https://kursiv.media/feed/");
            rssUrls.put("kapital", "https://kapital.kz/rss/");
            rssUrls.put("lsm", "https://lsm.kz/rss");
            rssUrls.put("rbc", "https://static.feed.rbc.ru/rbc/logical/footer/news.rss");
            rssUrls.put("vedomosti", "https://www.vedomosti.ru/rss/rubric/technology/internet");

            // Проверяем доступность
            java.util.Map<String, Boolean> accessibilityResults = rssUrlValidator.checkAllRssUrls(rssUrls);

            // Формируем детальный отчет
            java.util.Map<String, Object> report = new java.util.HashMap<>();
            report.put("overallStatus",
                    accessibilityResults.values().stream().allMatch(Boolean::booleanValue) ? "UP" : "DEGRADED");
            report.put("accessibilityResults", accessibilityResults);
            report.put("totalFeeds", rssUrls.size());
            report.put("accessibleFeeds", accessibilityResults.values().stream().mapToInt(b -> b ? 1 : 0).sum());
            report.put("unaccessibleFeeds", accessibilityResults.values().stream().mapToInt(b -> b ? 0 : 1).sum());

            // Добавляем рекомендации по альтернативным URL
            java.util.Map<String, String> recommendations = new java.util.HashMap<>();
            for (String source : rssUrls.keySet()) {
                if (!accessibilityResults.getOrDefault(source, false)) {
                    String alternativeUrl = rssUrlValidator.findWorkingUrl(source);
                    if (alternativeUrl != null) {
                        recommendations.put(source, alternativeUrl);
                    }
                }
            }
            report.put("recommendations", recommendations);

            return ResponseEntity.ok(ApiResponse.success("Проверка RSS-лент завершена", report));

        } catch (Exception e) {
            return ResponseEntity.internalServerError()
                    .body(ApiResponse.error("Ошибка при проверке RSS-лент: " + e.getMessage()));
        }
    }
}
