package dev.lions.audit;

import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.util.List;
import java.util.Map;

/**
 * API REST pour l'outil d'audit de maturité digitale
 */
@Path("/api/audit")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class AuditResource {
    
    @Inject
    AuditService auditService;
    
    @Inject
    AuditReportService reportService;
    
    /**
     * Récupère toutes les questions d'audit par catégorie
     */
    @GET
    @Path("/questions")
    public Response getQuestions(@QueryParam("lang") @DefaultValue("fr") String language) {
        try {
            Map<String, List<AuditQuestion>> questions = auditService.getQuestionsByCategory();
            return Response.ok(questions).build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du chargement des questions"))
                    .build();
        }
    }
    
    /**
     * Soumet les réponses d'audit et génère le rapport
     */
    @POST
    @Path("/submit")
    public Response submitAudit(AuditSubmissionDTO submission) {
        try {
            // Validation des données
            if (submission.getCompanyName() == null || submission.getCompanyName().trim().isEmpty()) {
                return Response.status(Response.Status.BAD_REQUEST)
                        .entity(Map.of("error", "Le nom de l'entreprise est requis"))
                        .build();
            }
            
            if (submission.getEmail() == null || !isValidEmail(submission.getEmail())) {
                return Response.status(Response.Status.BAD_REQUEST)
                        .entity(Map.of("error", "Email valide requis"))
                        .build();
            }
            
            // Création de la réponse d'audit
            AuditResponse response = new AuditResponse();
            response.setCompanyName(submission.getCompanyName());
            response.setContactName(submission.getContactName());
            response.setEmail(submission.getEmail());
            response.setPhone(submission.getPhone());
            response.setSector(submission.getSector());
            response.setEmployeeCount(submission.getEmployeeCount());
            response.setTurnover(submission.getTurnover());
            response.setAnswers(submission.getAnswers());
            
            // Traitement de l'audit
            AuditResponse processedResponse = auditService.processAuditResponse(response);
            
            // Génération du rapport PDF
            byte[] pdfReport = reportService.generateAuditReport(processedResponse);
            
            // Envoi par email
            reportService.sendAuditReportByEmail(processedResponse, pdfReport);
            
            // Réponse avec résumé
            AuditResultDTO result = new AuditResultDTO();
            result.setAuditId(processedResponse.getId());
            result.setMaturityPercentage(processedResponse.getMaturityPercentage());
            result.setCategoryScores(processedResponse.getCategoryScores());
            result.setRecommendations(processedResponse.getRecommendations());
            result.setPriorityActions(processedResponse.getPriorityActions());
            result.setEstimatedBudgetMin(processedResponse.getEstimatedBudgetMin());
            result.setEstimatedBudgetMax(processedResponse.getEstimatedBudgetMax());
            
            return Response.ok(result).build();
            
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du traitement de l'audit: " + e.getMessage()))
                    .build();
        }
    }
    
    /**
     * Télécharge le rapport PDF d'un audit
     */
    @GET
    @Path("/report/{auditId}")
    @Produces("application/pdf")
    public Response downloadReport(@PathParam("auditId") Long auditId) {
        try {
            AuditResponse audit = auditService.getAuditById(auditId);
            if (audit == null) {
                return Response.status(Response.Status.NOT_FOUND)
                        .entity("Audit non trouvé")
                        .build();
            }
            
            byte[] pdfReport = reportService.generateAuditReport(audit);
            
            return Response.ok(pdfReport)
                    .header("Content-Disposition", 
                           "attachment; filename=\"audit-" + audit.getCompanyName() + ".pdf\"")
                    .build();
                    
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity("Erreur lors de la génération du rapport")
                    .build();
        }
    }
    
    /**
     * Récupère les statistiques d'audit pour le dashboard admin
     */
    @GET
    @Path("/stats")
    public Response getAuditStats() {
        try {
            Map<String, Object> stats = auditService.getAuditStatistics();
            return Response.ok(stats).build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du chargement des statistiques"))
                    .build();
        }
    }
    
    /**
     * Récupère les audits non contactés (pour équipe commerciale)
     */
    @GET
    @Path("/leads")
    public Response getUncontactedLeads() {
        try {
            List<AuditResponse> leads = auditService.getUncontactedAudits();
            return Response.ok(leads).build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors du chargement des leads"))
                    .build();
        }
    }
    
    /**
     * Marque un audit comme contacté
     */
    @PUT
    @Path("/contact/{auditId}")
    public Response markAsContacted(@PathParam("auditId") Long auditId, 
                                   Map<String, String> notes) {
        try {
            auditService.markAsContacted(auditId, notes.get("notes"));
            return Response.ok(Map.of("success", true)).build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de la mise à jour"))
                    .build();
        }
    }
    
    /**
     * Demande de rendez-vous après audit
     */
    @POST
    @Path("/request-meeting")
    public Response requestMeeting(MeetingRequestDTO request) {
        try {
            auditService.processMeetingRequest(request);
            return Response.ok(Map.of("success", true, 
                                    "message", "Demande de rendez-vous enregistrée"))
                    .build();
        } catch (Exception e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                    .entity(Map.of("error", "Erreur lors de l'enregistrement"))
                    .build();
        }
    }
    
    private boolean isValidEmail(String email) {
        return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
}