package com.saas.admin.controller;

import com.saas.shared.dto.common.ApiResponse;
import com.saas.shared.mcp.service.Context7McpService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * Context7 MCP Controller
 * Provides admin APIs for dependency management and library documentation
 */
@RestController
@RequestMapping("/api/admin/context7")
@RequiredArgsConstructor
@Slf4j
public class Context7ManagedController {

    private final Context7McpService context7McpService;

    /**
     * Resolve a library to its latest compatible version
     */
    @GetMapping("/resolve/{libraryName}/{version}")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> resolveLibrary(
            @PathVariable String libraryName,
            @PathVariable String version) {
        
        log.info("📚 Resolving library: {} version {}", libraryName, version);
        
        try {
            String resolved = context7McpService.resolveDependency(libraryName, version);
            
            Map<String, Object> response = new HashMap<>();
            response.put("library", libraryName);
            response.put("requested_version", version);
            response.put("resolved_version", resolved);
            
            return ResponseEntity.ok(ApiResponse.success(
                response,
                "✅ Library resolved successfully"
            ));
        } catch (Exception e) {
            log.error("❌ Error resolving library: {}", e.getMessage(), e);
            return ResponseEntity.ok(ApiResponse.error(
                "❌ Failed to resolve library: " + e.getMessage()
            ));
        }
    }

    /**
     * Get comprehensive documentation for a library
     */
    @GetMapping("/docs/{libraryId}")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> getLibraryDocs(
            @PathVariable String libraryId) {
        
        log.info("📖 Fetching documentation for: {}", libraryId);
        
        try {
            String docs = context7McpService.getLibraryDocumentation(libraryId);
            
            if (docs == null) {
                return ResponseEntity.ok(ApiResponse.error(
                    "Documentation not found for library: " + libraryId
                ));
            }
            
            Map<String, Object> response = new HashMap<>();
            response.put("library_id", libraryId);
            response.put("documentation", docs);
            
            return ResponseEntity.ok(ApiResponse.success(
                response,
                "✅ Documentation retrieved successfully"
            ));
        } catch (Exception e) {
            log.error("❌ Error fetching documentation: {}", e.getMessage(), e);
            return ResponseEntity.ok(ApiResponse.error(
                "❌ Failed to fetch documentation: " + e.getMessage()
            ));
        }
    }

    /**
     * Check Java compatibility for a library version
     */
    @GetMapping("/java-compat/{libraryName}/{version}")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> checkJavaCompatibility(
            @PathVariable String libraryName,
            @PathVariable String version) {
        
        log.info("☕ Checking Java compatibility for: {} {}", libraryName, version);
        
        try {
            String compat = context7McpService.getJavaCompatibility(libraryName, version);
            
            if (compat == null) {
                return ResponseEntity.ok(ApiResponse.error(
                    "No Java compatibility info found for " + libraryName + " " + version
                ));
            }
            
            Map<String, Object> response = new HashMap<>();
            response.put("library", libraryName);
            response.put("version", version);
            response.put("compatibility", compat);
            
            return ResponseEntity.ok(ApiResponse.success(
                response,
                "✅ Java compatibility retrieved"
            ));
        } catch (Exception e) {
            log.error("❌ Error checking compatibility: {}", e.getMessage(), e);
            return ResponseEntity.ok(ApiResponse.error(
                "❌ Failed to check compatibility: " + e.getMessage()
            ));
        }
    }

    /**
     * Get migration guide between library versions
     */
    @GetMapping("/migration/{libraryName}/{fromVersion}/{toVersion}")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> getMigrationGuide(
            @PathVariable String libraryName,
            @PathVariable String fromVersion,
            @PathVariable String toVersion) {
        
        log.info("🔄 Getting migration guide: {} {} → {}", libraryName, fromVersion, toVersion);
        
        try {
            String guide = context7McpService.getMigrationGuide(libraryName, fromVersion, toVersion);
            
            if (guide == null) {
                return ResponseEntity.ok(ApiResponse.error(
                    "No migration guide available for " + libraryName
                ));
            }
            
            Map<String, Object> response = new HashMap<>();
            response.put("library", libraryName);
            response.put("from_version", fromVersion);
            response.put("to_version", toVersion);
            response.put("migration_guide", guide);
            
            return ResponseEntity.ok(ApiResponse.success(
                response,
                "✅ Migration guide retrieved"
            ));
        } catch (Exception e) {
            log.error("❌ Error getting migration guide: {}", e.getMessage(), e);
            return ResponseEntity.ok(ApiResponse.error(
                "❌ Failed to get migration guide: " + e.getMessage()
            ));
        }
    }

    /**
     * Validate all project dependencies
     */
    @PostMapping("/validate-dependencies")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> validateDependencies() {
        
        log.info("🔐 Validating project dependencies");
        
        try {
            boolean valid = context7McpService.validateDependencies();
            
            Map<String, Object> response = new HashMap<>();
            response.put("valid", valid);
            response.put("timestamp", java.time.LocalDateTime.now());
            
            return ResponseEntity.ok(ApiResponse.success(
                response,
                valid ? "✅ All dependencies validated successfully" 
                      : "⚠️ Some dependencies may need attention"
            ));
        } catch (Exception e) {
            log.error("❌ Error validating dependencies: {}", e.getMessage(), e);
            return ResponseEntity.ok(ApiResponse.error(
                "❌ Failed to validate dependencies: " + e.getMessage()
            ));
        }
    }

    /**
     * Get Context7 MCP status
     */
    @GetMapping("/status")
    @PreAuthorize("hasAuthority('SYSTEM_ADMIN')")
    public ResponseEntity<ApiResponse<?>> getStatus() {
        
        Map<String, Object> response = new HashMap<>();
        response.put("service", "Context7 MCP");
        response.put("endpoint", "https://mcp.context7.com/mcp");
        response.put("timestamp", java.time.LocalDateTime.now());
        response.put("tools", new String[]{"get-library-docs", "resolve-library-id"});
        
        return ResponseEntity.ok(ApiResponse.success(
            response,
            "Context7 MCP service is ready"
        ));
    }
}