@Entity
@Table(name = "api_traces")
@Data
public class ApiTrace {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "trace_id", nullable = false, unique = true)
    private String traceId; // UUID for correlation
    
    @Column(name = "request_path")
    private String requestPath; // /api/declaration/save
    
    @Column(name = "http_method")
    private String httpMethod; // POST, GET, etc.
    
    @Column(name = "class_name")
    private String className; // com.example.DeclarationController
    
    @Column(name = "method_name")
    private String methodName; // saveDeclaration
    
    @Column(columnDefinition = "TEXT")
    private String parameters; // JSON serialized params
    
    @Column(columnDefinition = "TEXT")
    private String result; // Return value (if exists)
    
    @Column(columnDefinition = "TEXT")
    private String exception; // Exception message + stack trace
    
    @Column(name = "execution_time_ms")
    private Long executionTimeMs;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    @Column(name = "user_id")
    private String userId;
    
    @Column(name = "session_id")
    private String sessionId;
}

@Aspect
@Component
@Slf4j
public class ApiTraceAspect {

    @Autowired
    private ApiTraceRepository traceRepository;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    private static final ThreadLocal TRACE_ID = new ThreadLocal<>();

    // Intercept all Controller methods
    @Around("execution(* com.experilabs..controller..*(..))")
    public Object traceController(ProceedingJoinPoint joinPoint) throws Throwable {
        return traceMethod(joinPoint, "CONTROLLER");
    }

    // Intercept all Service methods
    @Around("execution(* com.experilabs..service..*(..))")
    public Object traceService(ProceedingJoinPoint joinPoint) throws Throwable {
        return traceMethod(joinPoint, "SERVICE");
    }

    // Intercept all Repository methods
    @Around("execution(* com.experilabs..repository..*(..))")
    public Object traceRepository(ProceedingJoinPoint joinPoint) throws Throwable {
        return traceMethod(joinPoint, "REPOSITORY");
    }

    private Object traceMethod(ProceedingJoinPoint joinPoint, String layer) throws Throwable {
        // Check if tracing is enabled via header
        HttpServletRequest request = 
            ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest();
        
        String traceHeader = request.getHeader("x-trace-enable");
        if (!"true".equalsIgnoreCase(traceHeader)) {
            // Tracing disabled, proceed normally (no performance impact)
            return joinPoint.proceed();
        }

        // Generate or reuse trace ID
        String traceId = TRACE_ID.get();
        if (traceId == null) {
            traceId = UUID.randomUUID().toString();
            TRACE_ID.set(traceId);
        }

        // Capture method info
        String className = joinPoint.getSignature().getDeclaringTypeName();
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();

        ApiTrace trace = new ApiTrace();
        trace.setTraceId(traceId);
        trace.setClassName(className);
        trace.setMethodName(methodName);
        trace.setRequestPath(request.getRequestURI());
        trace.setHttpMethod(request.getMethod());
        trace.setUserId(getCurrentUserId());
        trace.setSessionId(request.getSession().getId());

        try {
            // Serialize parameters (sanitize sensitive data)
            trace.setParameters(sanitizeAndSerialize(args));
        } catch (Exception e) {
            trace.setParameters("Serialization failed: " + e.getMessage());
        }

        long startTime = System.currentTimeMillis();
        Object result = null;
        Exception exception = null;

        try {
            // Execute the actual method
            result = joinPoint.proceed();
            
            // Capture result (limit size)
            try {
                String resultJson = objectMapper.writeValueAsString(result);
                if (resultJson.length() > 5000) {
                    resultJson = resultJson.substring(0, 5000) + "... (truncated)";
                }
                trace.setResult(resultJson);
            } catch (Exception e) {
                trace.setResult("Result serialization failed");
            }
            
            return result;
            
        } catch (Exception e) {
            exception = e;
            
            // Capture full stack trace
            StringWriter sw = new StringWriter();
            e.printStackTrace(new PrintWriter(sw));
            trace.setException(sw.toString());
            
            throw e;
            
        } finally {
            long endTime = System.currentTimeMillis();
            trace.setExecutionTimeMs(endTime - startTime);
            trace.setCreatedAt(LocalDateTime.now());
            
            // Save trace asynchronously (don't block main flow)
            CompletableFuture.runAsync(() -> {
                try {
                    traceRepository.save(trace);
                    log.debug("Trace saved: {} - {}.{} ({}ms)",
                        traceId, className, methodName, trace.getExecutionTimeMs());
                } catch (Exception e) {
                    log.error("Failed to save trace", e);
                }
            });
            
            // Clean up ThreadLocal if this is the last method in chain
            if (layer.equals("CONTROLLER")) {
                TRACE_ID.remove();
            }
        }
    }

    private String sanitizeAndSerialize(Object[] args) throws JsonProcessingException {
        // Remove sensitive data (password, token, etc.)
        List