package kz.konturai.parser.controller;

import kz.konturai.parser.dto.ApiResponse;
import kz.konturai.parser.dto.ParserResultDto;
import kz.konturai.parser.model.MarketItem;
import kz.konturai.parser.service.MarketItemService;
import kz.konturai.parser.service.ParserManagerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.concurrent.CompletableFuture;

/**
 * Контроллер для административных действий с парсерами.
 * Содержит эндпоинты для управления парсерами.
 */
@RestController
@RequestMapping("/api/parser/admin/parsers")
public class ParserAdminController {

    @Autowired
    private ParserManagerService parserManagerService;

    @Autowired
    private MarketItemService marketItemService;

    /**
     * Запуск парсера по имени источника
     */
    @PostMapping("/parse/{sourceName}")
    public ResponseEntity<ApiResponse<ParserResultDto>> parseSource(@PathVariable String sourceName) {
        try {
            if (!parserManagerService.hasParser(sourceName)) {
                return ResponseEntity.badRequest()
                        .body(ApiResponse.error("Парсер не найден: " + sourceName));
            }

            List<MarketItem> savedItems = parserManagerService.runParser(sourceName);
            long totalItems = marketItemService.getTotalItemsCount();

            ParserResultDto result = new ParserResultDto(
                    sourceName,
                    savedItems.size(),
                    totalItems,
                    "completed");

            return ResponseEntity.ok(ApiResponse.success("Парсинг " + sourceName + " завершен", result));

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

    /**
     * Запуск всех парсеров асинхронно
     */
    @PostMapping("/parse/all")
    public ResponseEntity<ApiResponse<List<ParserResultDto>>> parseAll() {
        try {
            CompletableFuture<List<ParserResultDto>> future = parserManagerService.runAllParsers();
            List<ParserResultDto> results = future.get(); // .get() для ожидания результата

            return ResponseEntity.ok(ApiResponse.success("Парсинг всех источников завершен", results));

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

    /**
     * Получение списка доступных парсеров
     */
    @GetMapping
    public ResponseEntity<ApiResponse<List<String>>> getAvailableParsers() {
        try {
            List<String> parsers = parserManagerService.getAvailableParsers();
            return ResponseEntity.ok(ApiResponse.success("Список парсеров получен", parsers));

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

    /**
     * Получение информации о парсерах
     */
    @GetMapping("/info")
    public ResponseEntity<ApiResponse<java.util.Map<String, Object>>> getParsersInfo() {
        try {
            java.util.Map<String, Object> info = new java.util.HashMap<>();
            info.put("totalParsers", parserManagerService.getParserCount());
            info.put("availableParsers", parserManagerService.getAvailableParsers());
            info.put("totalItems", marketItemService.getTotalItemsCount());
            info.put("sourceStatistics", marketItemService.getSourceStatistics());

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

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

    /**
     * Проверка существования парсера
     */
    @GetMapping("/exists/{sourceName}")
    public ResponseEntity<ApiResponse<Boolean>> checkParserExists(@PathVariable String sourceName) {
        try {
            boolean exists = parserManagerService.hasParser(sourceName);
            return ResponseEntity.ok(ApiResponse.success("Проверка завершена", exists));

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