package com.saas.admin.controller;

import com.saas.admin.dto.*;
import com.saas.voip.service.VapiCostTrackingService;
import com.saas.voip.service.VapiService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * Admin Controller for Vapi.ai management
 * SYSTEM_ADMIN only - global view of all tenants
 */
@RestController
@RequestMapping("/api/admin/vapi")
@PreAuthorize("hasRole('SYSTEM_ADMIN')")
@RequiredArgsConstructor
@Slf4j
@Tag(name = "Admin - Vapi.ai", description = "SYSTEM_ADMIN endpoints for managing Vapi.ai assistants and calls across all tenants")
public class AdminVapiController {
    
    private final VapiService vapiService;
    private final VapiCostTrackingService costTrackingService;
    
    // ========================================
    // ASSISTANTS
    // ========================================
    
    @GetMapping("/assistants")
    @Operation(summary = "List all Vapi assistants", description = "Get all assistants for a specific tenant (admin view)")
    @ApiResponse(responseCode = "200", description = "Assistants retrieved successfully")
    public ResponseEntity<List<VapiAssistantDTO>> getAllAssistants(
            @RequestParam String tenantId) {
        
        log.info("🔑 [ADMIN] Listing Vapi assistants for tenant: {}", tenantId);
        List<VapiAssistantDTO> assistants = vapiService.listAssistants(tenantId);
        return ResponseEntity.ok(assistants);
    }
    
    @GetMapping("/assistants/{assistantId}")
    @Operation(summary = "Get assistant by ID", description = "Retrieve a specific Vapi assistant")
    @ApiResponse(responseCode = "200", description = "Assistant found")
    @ApiResponse(responseCode = "404", description = "Assistant not found")
    public ResponseEntity<VapiAssistantDTO> getAssistant(
            @PathVariable Long assistantId,
            @RequestParam String tenantId) {
        
        log.info("🔍 [ADMIN] Getting Vapi assistant {} for tenant: {}", assistantId, tenantId);
        try {
            VapiAssistantDTO assistant = vapiService.getAssistant(tenantId, assistantId);
            return ResponseEntity.ok(assistant);
        } catch (Exception e) {
            log.error("❌ Assistant not found: {}", assistantId);
            return ResponseEntity.notFound().build();
        }
    }
    
    @PostMapping("/assistants")
    @Operation(summary = "Create Vapi assistant", description = "Create a new Vapi assistant for a tenant (admin)")
    @ApiResponse(responseCode = "201", description = "Assistant created successfully")
    public ResponseEntity<VapiAssistantDTO> createAssistant(
            @RequestParam String tenantId,
            @RequestBody CreateVapiAssistantDTO dto) {
        
        log.info("➕ [ADMIN] Creating Vapi assistant for tenant: {}", tenantId);
        VapiAssistantDTO created = vapiService.createAssistant(tenantId, dto);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }
    
    @PatchMapping("/assistants/{assistantId}")
    @Operation(summary = "Update Vapi assistant", description = "Update an existing Vapi assistant (admin)")
    @ApiResponse(responseCode = "200", description = "Assistant updated successfully")
    public ResponseEntity<VapiAssistantDTO> updateAssistant(
            @PathVariable Long assistantId,
            @RequestParam String tenantId,
            @RequestBody UpdateVapiAssistantDTO dto) {
        
        log.info("✏️ [ADMIN] Updating Vapi assistant {} for tenant: {}", assistantId, tenantId);
        try {
            VapiAssistantDTO updated = vapiService.updateAssistant(tenantId, assistantId, dto);
            return ResponseEntity.ok(updated);
        } catch (Exception e) {
            log.error("❌ Error updating assistant: {}", e.getMessage());
            return ResponseEntity.notFound().build();
        }
    }
    
    @DeleteMapping("/assistants/{assistantId}")
    @Operation(summary = "Delete Vapi assistant", description = "Delete a Vapi assistant (admin)")
    @ApiResponse(responseCode = "204", description = "Assistant deleted successfully")
    public ResponseEntity<Void> deleteAssistant(
            @PathVariable Long assistantId,
            @RequestParam String tenantId) {
        
        log.info("🗑️ [ADMIN] Deleting Vapi assistant {} for tenant: {}", assistantId, tenantId);
        try {
            vapiService.deleteAssistant(tenantId, assistantId);
            return ResponseEntity.noContent().build();
        } catch (Exception e) {
            log.error("❌ Error deleting assistant: {}", e.getMessage());
            return ResponseEntity.notFound().build();
        }
    }
    
    // ========================================
    // CALLS
    // ========================================
    
    @GetMapping("/calls")
    @Operation(summary = "List all Vapi calls", description = "Get all calls for a specific tenant (admin view)")
    @ApiResponse(responseCode = "200", description = "Calls retrieved successfully")
    public ResponseEntity<List<VapiCallDTO>> getAllCalls(
            @RequestParam String tenantId) {
        
        log.info("📞 [ADMIN] Listing Vapi calls for tenant: {}", tenantId);
        List<VapiCallDTO> calls = vapiService.listCalls(tenantId);
        return ResponseEntity.ok(calls);
    }
    
    @GetMapping("/calls/{vapiCallId}")
    @Operation(summary = "Get call by ID", description = "Retrieve a specific Vapi call")
    @ApiResponse(responseCode = "200", description = "Call found")
    @ApiResponse(responseCode = "404", description = "Call not found")
    public ResponseEntity<VapiCallDTO> getCall(
            @PathVariable String vapiCallId,
            @RequestParam String tenantId) {
        
        log.info("🔍 [ADMIN] Getting Vapi call {} for tenant: {}", vapiCallId, tenantId);
        try {
            VapiCallDTO call = vapiService.getCall(tenantId, vapiCallId);
            return ResponseEntity.ok(call);
        } catch (Exception e) {
            log.error("❌ Call not found: {}", vapiCallId);
            return ResponseEntity.notFound().build();
        }
    }
    
    // ========================================
    // COST ANALYTICS
    // ========================================
    
    @GetMapping("/costs")
    @Operation(summary = "Get cost analytics", description = "Get Vapi cost analytics for a tenant (admin view)")
    @ApiResponse(responseCode = "200", description = "Cost analytics retrieved successfully")
    public ResponseEntity<VapiCostAnalyticsDTO> getCostAnalytics(
            @RequestParam String tenantId,
            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
        
        log.info("💰 [ADMIN] Getting Vapi cost analytics for tenant: {} ({} to {})", 
            tenantId, startDate, endDate);
        
        VapiCostAnalyticsDTO analytics = costTrackingService.getCostAnalytics(tenantId, startDate, endDate);
        return ResponseEntity.ok(analytics);
    }
}