package com.social.media;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.FilterType;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import io.micrometer.core.aop.TimedAspect;
import io.micrometer.core.instrument.MeterRegistry;

/**
 * Social Media Manager Application - Advanced Architecture v2.0
 * 
 * Comprehensive social media management platform built with modern Java 21 and Spring Boot 3.3,
 * implementing enterprise-grade architecture patterns and best practices.
 * 
 * Architecture Patterns:
 * - Hexagonal Architecture (Ports & Adapters Pattern)
 * - Domain-Driven Design (DDD) with Bounded Contexts
 * - Command Query Responsibility Segregation (CQRS)
 * - Event Sourcing with Axon Framework
 * - Microservices-ready modular design
 * - Clean Architecture principles
 * 
 * Core Features:
 * - 🏢 Multi-tenant enterprise management
 * - 👥 Advanced user and permission management
 * - 📱 Social media account integration (Instagram, Facebook, Twitter, LinkedIn, TikTok, etc.)
 * - 📝 Intelligent content management and scheduling
 * - 🤖 Advanced automation and bot management
 * - 📊 Real-time analytics and comprehensive reporting
 * - 🎯 Campaign management with ROI tracking
 * - 👤 Audience analytics and relationship management
 * - 🔒 Enterprise-grade security and audit logging
 * - ⚡ High-performance rate limiting and circuit breakers
 * 
 * Technology Stack:
 * - ☕ Java 21 with Virtual Threads and Pattern Matching
 * - 🚀 Spring Boot 3.3+ with GraalVM native compilation
 * - 🐘 PostgreSQL 17 with advanced indexing and partitioning
 * - 🔴 Redis for caching, session management, and rate limiting
 * - 🍃 MongoDB for analytics and log aggregation
 * - 🐰 RabbitMQ for asynchronous messaging and event streaming
 * - ⚙️ Axon Framework for CQRS/Event Sourcing implementation
 * - 🛡️ Resilience4j for fault tolerance and circuit breakers
 * - 📊 Micrometer + Prometheus for observability and metrics
 * - 🧪 Comprehensive testing with TestContainers and ArchUnit
 * 
 * Business Domains (Bounded Contexts):
 * - Company & User Management
 * - Social Account Integration
 * - Content & Media Management
 * - Automation & Bot Framework
 * - Campaign & Analytics Engine
 * - Audience & Relationship Management
 * 
 * @author Felipe Palma & Social Media Manager Team
 * @version 2.0.0-SNAPSHOT
 * @since 2025-08-19
 */
@SpringBootApplication(
    scanBasePackages = {
        "com.social.media"
    }
)
@ComponentScan(
    basePackages = "com.social.media",
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.REGEX,
        pattern = "com\\.social\\.media\\.infrastructure\\.web\\.controllers\\..*"
    )
)
@EnableJpaRepositories(basePackages = "com.social.media.infrastructure.persistence")
// Temporarily disabled MongoDB repositories until they are implemented
// @EnableMongoRepositories(basePackages = {
//     "com.social.media.infrastructure.persistence.mongodb"
// })
@EnableJpaAuditing(auditorAwareRef = "auditorAware")
@EnableTransactionManagement
@EnableCaching
@EnableScheduling
@EnableAsync
@EnableAspectJAutoProxy
@ConfigurationPropertiesScan(basePackages = "com.social.media.infrastructure.configuration")
public class SocialMediaManagerApplication {

    private static final Logger log = LoggerFactory.getLogger(SocialMediaManagerApplication.class);
    private static final String APPLICATION_NAME = "Social Media Manager";
    private static final String VERSION = "2.0.0";
    
    public static void main(String[] args) {
        // Configure system properties for optimal performance
        System.setProperty("spring.output.ansi.enabled", "always");
        System.setProperty("java.awt.headless", "true");
        
        // Enable virtual threads if available (Java 21+)
        if (Runtime.version().feature() >= 21) {
            System.setProperty("spring.threads.virtual.enabled", "true");
            log.info("Virtual Threads enabled for improved concurrency");
        }
        
        log.info("🚀 Starting {} v{}", APPLICATION_NAME, VERSION);
        log.info("📊 Java Version: {}", Runtime.version());
        log.info("🔧 Available Processors: {}", Runtime.getRuntime().availableProcessors());
        log.info("💾 Max Memory: {} MB", Runtime.getRuntime().maxMemory() / 1024 / 1024);
        
        SpringApplication application = new SpringApplication(SocialMediaManagerApplication.class);
        
        // Configure additional properties
        application.setAdditionalProfiles(determineActiveProfiles());
        
        var context = application.run(args);
        
        logApplicationStartup(context);
    }
    
    /**
     * Bean for enabling @Timed annotation support for metrics
     */
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
    
    /**
     * Determine active profiles based on environment
     */
    private static String[] determineActiveProfiles() {
        String profile = System.getProperty("spring.profiles.active", "dev");
        log.info("🔧 Active Profile: {}", profile);
        return new String[]{profile};
    }
    
    /**
     * Log application startup information
     */
    private static void logApplicationStartup(org.springframework.context.ConfigurableApplicationContext context) {
        var environment = context.getEnvironment();
        var applicationName = environment.getProperty("spring.application.name", APPLICATION_NAME);
        var port = environment.getProperty("server.port", "8000");
        var contextPath = environment.getProperty("server.servlet.context-path", "");
        var profiles = environment.getActiveProfiles();
                
        // Check if running with virtual threads
        if (Runtime.version().feature() >= 21) {
            var virtualThreadsEnabled = environment.getProperty("spring.threads.virtual.enabled", "false");
            if ("true".equals(virtualThreadsEnabled)) {
                log.info("⚡ Virtual Threads: ENABLED - Enhanced concurrency available");
            }
        }
        
        // Log important configuration
        var dbUrl = environment.getProperty("spring.datasource.url", "Not configured");
        var redisHost = environment.getProperty("spring.data.redis.host", "Not configured");
        var mongoUri = environment.getProperty("spring.data.mongodb.uri", "Not configured");
        
        log.info("💾 Database: {}", maskSensitiveInfo(dbUrl));
        log.info("🔴 Redis: {}", redisHost);
        log.info("🍃 MongoDB: {}", maskSensitiveInfo(mongoUri));
        
        log.info("");
        log.info("✅ Application is ready to serve requests!");
        log.info("");
    }
    
    /**
     * Mask sensitive information in URLs
     */
    private static String maskSensitiveInfo(String url) {
        if (url == null || url.equals("Not configured")) {
            return url;
        }
        return url.replaceAll("(://[^:@]*):([^@]*)@", "://$1:***@");
    }
}