package com.social.media.interfaces.web.controller;

import com.social.media.application.service.AuthService;
import com.social.media.application.service.DashboardAnalyticsService;
import com.social.media.application.service.FollowersAnalyticsService;
import com.social.media.application.service.PostsAnalyticsService;
import com.social.media.interfaces.web.dto.analytics.*;
import com.social.media.interfaces.web.dto.user.UserResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * REST Controller for Analytics management
 */
@RestController
@RequestMapping("/api/v1/analytics")
public class AnalyticsController {
    
    private static final Logger logger = LoggerFactory.getLogger(AnalyticsController.class);
    
    private final DashboardAnalyticsService dashboardAnalyticsService;
    private final FollowersAnalyticsService followersAnalyticsService;
    private final PostsAnalyticsService postsAnalyticsService;
    private final AuthService authService;
    
    public AnalyticsController(DashboardAnalyticsService dashboardAnalyticsService,
                              FollowersAnalyticsService followersAnalyticsService,
                              PostsAnalyticsService postsAnalyticsService,
                              AuthService authService) {
        this.dashboardAnalyticsService = dashboardAnalyticsService;
        this.followersAnalyticsService = followersAnalyticsService;
        this.postsAnalyticsService = postsAnalyticsService;
        this.authService = authService;
    }
    
    /**
     * Generate analytics report
     */
    @PostMapping("/reports")
    public ResponseEntity<String> generateReport(@Valid @RequestBody GenerateReportRequest request) {
        // TODO: Implement report generation logic
        return ResponseEntity.status(HttpStatus.CREATED).body("Report generation started");
    }
    
    /**
     * Get account metrics
     */
    @GetMapping("/metrics/account/{accountId}")
    public ResponseEntity<String> getAccountMetrics(@PathVariable Long accountId) {
        // TODO: Implement get account metrics logic
        return ResponseEntity.ok("Metrics for account: " + accountId);
    }
    
    /**
     * Get company analytics
     */
    @GetMapping("/company/{companyId}")
    public ResponseEntity<String> getCompanyAnalytics(@PathVariable Long companyId) {
        // TODO: Implement get company analytics logic
        return ResponseEntity.ok("Analytics for company: " + companyId);
    }
    
    /**
     * Get dashboard data - COM VERIFICAÇÃO DE PERMISSÃO
     */
    @GetMapping("/dashboard/{companyId}")
    public ResponseEntity<DashboardAnalyticsResponse> getDashboard(@PathVariable Long companyId, 
                                                                  HttpServletRequest request) {
        try {
            // Extrair token do header Authorization
            String authHeader = request.getHeader("Authorization");
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                logger.warn("Missing or invalid Authorization header for company: {}", companyId);
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            String token = authHeader.substring(7);
            
            // Obter usuário logado através do token
            UserResponse currentUser = authService.getCurrentUser(token);
            Long userCompanyId = Long.valueOf(currentUser.companyId());
            
            // Verificar se o usuário tem acesso aos dados desta empresa
            if (!userCompanyId.equals(companyId)) {
                logger.warn("User {} from company {} attempted to access data from company {}", 
                           currentUser.email(), userCompanyId, companyId);
                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
            }
            
            logger.info("Getting dashboard analytics for company: {} by user: {}", 
                       companyId, currentUser.email());
            
            DashboardAnalyticsResponse response = dashboardAnalyticsService.getDashboardAnalytics(companyId);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            logger.error("Error getting dashboard analytics for company {}: {}", companyId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * Get dashboard data - FOR DEVELOPMENT WITHOUT AUTHENTICATION
     */
    @GetMapping("/dashboard/dev/{companyId}")
    public ResponseEntity<DashboardAnalyticsResponse> getDashboardDev(@PathVariable Long companyId) {
        try {
            logger.info("Getting dashboard analytics for company: {} (DEVELOPMENT MODE)", companyId);
            
            DashboardAnalyticsResponse response = dashboardAnalyticsService.getDashboardAnalytics(companyId);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            logger.error("Error getting dashboard analytics for company {} (DEV): {}", companyId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * Get dashboard data - USA O USUÁRIO LOGADO
     */
    @GetMapping("/dashboard")
    public ResponseEntity<DashboardAnalyticsResponse> getDashboard(HttpServletRequest request) {
        try {
            // Extrair token do header Authorization
            String authHeader = request.getHeader("Authorization");
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                logger.warn("Missing or invalid Authorization header");
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            String token = authHeader.substring(7);
            
            // Obter usuário logado através do token
            UserResponse currentUser = authService.getCurrentUser(token);
            Long companyId = Long.valueOf(currentUser.companyId());
            
            logger.info("Getting dashboard analytics for logged user: {} (company: {})", 
                       currentUser.email(), companyId);
            
            DashboardAnalyticsResponse response = dashboardAnalyticsService.getDashboardAnalytics(companyId);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            logger.error("Error getting dashboard analytics for logged user: {}", e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get followers by lists (Option 1)
     * Buscar seguidores através das listas de usuários
     */
    @GetMapping("/followers/by-lists/{socialAccountId}")
    public ResponseEntity<List<FollowersByListResponse>> getFollowersByLists(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting followers by lists for social account: {}", socialAccountId);
            List<FollowersByListResponse> followers = followersAnalyticsService.getFollowersByLists(socialAccountId);
            return ResponseEntity.ok(followers);
            
        } catch (Exception e) {
            logger.error("Error getting followers by lists for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get specific followers (Option 2)
     * Buscar especificamente a lista de seguidores
     */
    @GetMapping("/followers/specific/{socialAccountId}")
    public ResponseEntity<List<SpecificFollowersResponse>> getSpecificFollowers(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting specific followers for social account: {}", socialAccountId);
            List<SpecificFollowersResponse> followers = followersAnalyticsService.getSpecificFollowers(socialAccountId);
            return ResponseEntity.ok(followers);
            
        } catch (Exception e) {
            logger.error("Error getting specific followers for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get complete account followers (Option 3)
     * Query completa com informações da conta e seguidores
     */
    @GetMapping("/followers/complete/{socialAccountId}")
    public ResponseEntity<List<CompleteAccountFollowersResponse>> getCompleteAccountFollowers(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting complete account followers for social account: {}", socialAccountId);
            List<CompleteAccountFollowersResponse> followers = followersAnalyticsService.getCompleteAccountFollowers(socialAccountId);
            return ResponseEntity.ok(followers);
            
        } catch (Exception e) {
            logger.error("Error getting complete account followers for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get followers count (Option 4)
     * Contar seguidores
     */
    @GetMapping("/followers/count/{socialAccountId}")
    public ResponseEntity<List<FollowersCountResponse>> getFollowersCount(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting followers count for social account: {}", socialAccountId);
            List<FollowersCountResponse> count = followersAnalyticsService.getFollowersCount(socialAccountId);
            return ResponseEntity.ok(count);
            
        } catch (Exception e) {
            logger.error("Error getting followers count for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get total followers for a social account
     */
    @GetMapping("/followers/total/{socialAccountId}")
    public ResponseEntity<List<TotalFollowersResponse>> getTotalFollowers(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting total followers for social account: {}", socialAccountId);
            List<TotalFollowersResponse> followers = postsAnalyticsService.getTotalFollowers(socialAccountId);
            return ResponseEntity.ok(followers);
            
        } catch (Exception e) {
            logger.error("Error getting total followers for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get total posts summary for a social account
     */
    @GetMapping("/posts/total/{socialAccountId}")
    public ResponseEntity<TotalPostsResponse> getTotalPosts(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting total posts for social account: {}", socialAccountId);
            TotalPostsResponse posts = postsAnalyticsService.getTotalPosts(socialAccountId);
            return ResponseEntity.ok(posts);
            
        } catch (Exception e) {
            logger.error("Error getting total posts for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get total likes summary for a social account
     */
    @GetMapping("/likes/total/{socialAccountId}")
    public ResponseEntity<TotalLikesResponse> getTotalLikes(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting total likes for social account: {}", socialAccountId);
            TotalLikesResponse likes = postsAnalyticsService.getTotalLikes(socialAccountId);
            return ResponseEntity.ok(likes);
            
        } catch (Exception e) {
            logger.error("Error getting total likes for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Get likes by post for a social account
     */
    @GetMapping("/likes/by-post/{socialAccountId}")
    public ResponseEntity<List<LikesByPostResponse>> getLikesByPost(
            @PathVariable String socialAccountId,
            HttpServletRequest request) {
        try {
            // Verificar autenticação
            if (!isAuthenticated(request)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
            }
            
            logger.info("Getting likes by post for social account: {}", socialAccountId);
            List<LikesByPostResponse> likesByPost = postsAnalyticsService.getLikesByPost(socialAccountId);
            return ResponseEntity.ok(likesByPost);
            
        } catch (Exception e) {
            logger.error("Error getting likes by post for account {}: {}", socialAccountId, e.getMessage(), e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * Helper method to check authentication
     */
    private boolean isAuthenticated(HttpServletRequest request) {
        String authHeader = request.getHeader("Authorization");
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            logger.warn("Missing or invalid Authorization header");
            return false;
        }
        
        try {
            String token = authHeader.substring(7);
            authService.getCurrentUser(token);
            return true;
        } catch (Exception e) {
            logger.warn("Invalid token: {}", e.getMessage());
            return false;
        }
    }
    
    /**
     * Health check endpoint
     */
    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("Analytics service is healthy");
    }
}
