13 - Pagamenti e Abbonamenti con Stripe

@Entity
@Table(name = "abbonamenti")
public class Abbonamento {

    // Collegamento utente
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "utente_id", nullable = false)
    private User utente;

    // Dettagli Stripe
    @Column(name = "id_cliente_stripe")
    private String idClienteStripe;       // cus_xxxxxxxxxxxx

    @Column(name = "id_abbonamento_stripe")
    private String idAbbonamentoStripe;   // sub_xxxxxxxxxxxx

    @Column(name = "id_prezzo_stripe")
    private String idPrezzoStripe;        // price_xxxxxxxxxxxx

    // Piano e fatturazione
    @Enumerated(EnumType.STRING)
    private TipoPiano tipoPiano;

    @Enumerated(EnumType.STRING)
    private CicloPagamento cicloFatturazione;

    private BigDecimal importo;
    private String valuta = "EUR";
}

@Service
public class StripeService {

    // Mappa: "PRIVATE_STARTER_MENSILE" -> "price_xxxxx"
    private final Map<String, String> stripePriceIds = new HashMap<>();

    // Mappa inversa: "price_xxxxx" -> "PRIVATE_STARTER_MENSILE"
    private final Map<String, String> priceIdToPlanMap = new HashMap<>();

    public String getPriceId(TipoPiano tipoPiano, CicloPagamento ciclo) {
        String key = tipoPiano.name() + "_" + ciclo.name();
        return stripePriceIds.get(key);
    }

    public TipoPiano getTipoPianoFromPriceId(String priceId) {
        String planKey = priceIdToPlanMap.get(priceId);
        // Parsing: "PRIVATE_STARTER_MENSILE" -> "PRIVATE_STARTER"
        String tipoPianoStr = planKey.endsWith("_MENSILE")
            ? planKey.substring(0, planKey.length() - "_MENSILE".length())
            : planKey.substring(0, planKey.length() - "_ANNUALE".length());
        return TipoPiano.valueOf(tipoPianoStr);
    }
}

public enum TipoPiano {

    PRIVATE_FREE("Private Free", TipoAccount.INDIVIDUO,
        BigDecimal.ZERO, BigDecimal.ZERO, 3, 50),

    PRIVATE_STARTER("Private Starter", TipoAccount.INDIVIDUO,
        new BigDecimal("4.99"), new BigDecimal("49.90"), 10, 100),

    PRIVATE_PRO("Private Pro", TipoAccount.INDIVIDUO,
        new BigDecimal("9.99"), new BigDecimal("99.90"), -1, 300),

    BUSINESS_ENTERPRISE("Business Enterprise", TipoAccount.AZIENDA,
        new BigDecimal("199.00"), new BigDecimal("1990.00"), -1, -1),

    ASSOCIAZIONE_ILLIMITATO("Associazione Illimitato", TipoAccount.ASSOCIAZIONE,
        new BigDecimal("24.00"), new BigDecimal("24.00"), -1, -1);

    // -1 = illimitati
    private final int maxEventi;
    private final int maxPartecipanti;

    public boolean isCompatibileCon(TipoAccount tipoAccount) {
        return this.tipoAccountRichiesto == tipoAccount;
    }

    public BigDecimal calcolaRisparmioAnnuale() {
        BigDecimal costoAnnualeMensile = prezzoMensile.multiply(new BigDecimal("12"));
        BigDecimal risparmio = costoAnnualeMensile.subtract(prezzoAnnuale);
        return risparmio.divide(costoAnnualeMensile, 4, RoundingMode.HALF_UP)
                .multiply(new BigDecimal("100"));
    }
}

public enum CicloPagamento {
    MENSILE("Mensile"),
    ANNUALE("Annuale");

    private final String displayName;
}

// La chiave di lookup per il Price ID Stripe
// combina TipoPiano + CicloPagamento:
// Es: "PRIVATE_STARTER_MENSILE" -> "price_1Abc..."
// Es: "PRIVATE_STARTER_ANNUALE" -> "price_2Def..."

public enum StatoAbbonamento {
    ACTIVE("Attivo"),
    CANCELLED("Annullato"),
    EXPIRED("Scaduto"),
    SUSPENDED("Sospeso"),
    PENDING("In Attesa");

    // Solo ACTIVE consente funzionalità premium
    public boolean consenteFunzionalitaPremium() {
        return this == ACTIVE;
    }

    // PENDING, SUSPENDED, EXPIRED richiedono pagamento
    public boolean richiedePagamento() {
        return this == PENDING || this == SUSPENDED || this == EXPIRED;
    }

    // ACTIVE e CANCELLED sono potenzialmente attivi
    public boolean ePotenzialmenteAttivo() {
        return this == ACTIVE || this == CANCELLED;
    }

    // CANCELLED, SUSPENDED, EXPIRED possono essere riattivati
    public boolean puoEssereRiattivato() {
        return this == CANCELLED || this == SUSPENDED || this == EXPIRED;
    }
}

public class Abbonamento {

    private int tentativiPagamentoFalliti = 0;
    private String ultimoErrorePagamento;

    /**
     * Registra un pagamento fallito.
     * Dopo 3 tentativi falliti, l'abbonamento viene sospeso.
     */
    public void registraPagamentoFallito(String errore) {
        this.ultimoErrorePagamento = errore;
        this.tentativiPagamentoFalliti++;
        if (this.tentativiPagamentoFalliti >= 3) {
            this.stato = StatoAbbonamento.SUSPENDED;
        }
    }

    /**
     * Registra un pagamento riuscito.
     * Resetta il contatore e riattiva se sospeso.
     */
    public void registraPagamentoRiuscito() {
        this.ultimoPagamentoIl = Instant.now();
        this.ultimoErrorePagamento = null;
        this.tentativiPagamentoFalliti = 0;
        if (this.stato == StatoAbbonamento.SUSPENDED
            || this.stato == StatoAbbonamento.PENDING) {
            this.stato = StatoAbbonamento.ACTIVE;
        }
    }
}

public static Abbonamento creaConStripe(
        User utente,
        String idClienteStripe,
        String idAbbonamentoStripe,
        String idPrezzoStripe,
        TipoPiano tipoPiano,
        CicloPagamento cicloFatturazione,
        BigDecimal importo) {

    return Abbonamento.builder()
            .utente(utente)
            .idClienteStripe(idClienteStripe)
            .idAbbonamentoStripe(idAbbonamentoStripe)
            .idPrezzoStripe(idPrezzoStripe)
            .tipoPiano(tipoPiano)
            .cicloFatturazione(cicloFatturazione)
            .importo(importo)
            .valuta("EUR")
            .stato(StatoAbbonamento.PENDING)  // Attesa conferma pagamento
            .dataInizio(Instant.now())
            .tentativiPagamentoFalliti(0)
            .build();
}

public static Abbonamento creaGratuito(User utente) {
    return Abbonamento.builder()
            .utente(utente)
            .tipoPiano(TipoPiano.PRIVATE_FREE)
            .cicloFatturazione(CicloPagamento.MENSILE)
            .importo(BigDecimal.ZERO)
            .valuta("EUR")
            .stato(StatoAbbonamento.ACTIVE)  // Attivo immediatamente
            .dataInizio(Instant.now())
            .tentativiPagamentoFalliti(0)
            .build();
}

public static Abbonamento creaBypass(
        User utente,
        TipoPiano tipoPiano,
        CodicePromozionale codicePromozionale,
        int durataMesi) {

    return Abbonamento.builder()
            .utente(utente)
            .tipoPiano(tipoPiano)
            .cicloFatturazione(CicloPagamento.MENSILE)
            .importo(BigDecimal.ZERO)
            .valuta("EUR")
            .stato(StatoAbbonamento.ACTIVE)
            .dataInizio(Instant.now())
            .scadenzaBypass(Instant.now().plus(
                durataMesi * 30L, ChronoUnit.DAYS))
            .codicePromozionale(codicePromozionale)
            .tentativiPagamentoFalliti(0)
            .build();
}

public static Abbonamento creaBypassPermanente(
        User utente,
        TipoPiano tipoPiano,
        CodicePromozionale codicePromozionale) {

    return Abbonamento.builder()
            .utente(utente)
            .tipoPiano(tipoPiano)
            .cicloFatturazione(CicloPagamento.MENSILE)
            .importo(BigDecimal.ZERO)
            .valuta("EUR")
            .stato(StatoAbbonamento.ACTIVE)
            .dataInizio(Instant.now())
            .scadenzaBypass(null)  // Null = permanente, mai scade
            .codicePromozionale(codicePromozionale)
            .tentativiPagamentoFalliti(0)
            .build();
}

// Metodi di verifica
public boolean isAbbonamentoBypass() {
    return scadenzaBypass != null;
}

public boolean isPermanente() {
    return codicePromozionale != null
        && scadenzaBypass == null
        && importo.compareTo(BigDecimal.ZERO) == 0;
}

public enum TipoCodicePromozionale {
    BYPASS_PAGAMENTO,
    BYPASS_PERMANENTE,
    SCONTO_PERCENTUALE,
    SCONTO_FISSO;

    // Solo SCONTO_* richiedono configurazione Stripe
    public boolean richiedeStripe() {
        return this == SCONTO_PERCENTUALE || this == SCONTO_FISSO;
    }

    // BYPASS_* saltano completamente il pagamento
    public boolean bypassaPagamento() {
        return this == BYPASS_PAGAMENTO || this == BYPASS_PERMANENTE;
    }

    public boolean isPermanente() {
        return this == BYPASS_PERMANENTE;
    }
}

@Entity
@Table(name = "codici_promozionali")
public class CodicePromozionale {

    private String codice;         // "WELCOME50", "PARTNER2024"
    private TipoCodicePromozionale tipo;
    private BigDecimal valore;     // Sconto % o fisso (null per bypass)
    private TipoPiano tipoPianoApplicabile; // Null = tutti i piani
    private Integer durataMesiBypass;  // Solo per BYPASS_PAGAMENTO
    private Integer maxUtilizzi;       // Null = illimitati
    private int utilizziCorrenti;
    private boolean attivo;

    public boolean isValido() {
        if (!attivo) return false;

        Instant now = Instant.now();
        if (validoDa != null && now.isBefore(validoDa)) return false;
        if (validoFino != null && now.isAfter(validoFino)) return false;
        if (maxUtilizzi != null && utilizziCorrenti >= maxUtilizzi)
            return false;

        return true;
    }

    public boolean isApplicabileAPiano(TipoPiano piano) {
        if (tipoPianoApplicabile == null) return true;
        return tipoPianoApplicabile == piano;
    }
}

@Entity
@Table(name = "utilizzi_codici_promozionali")
public class UtilizzoCodicePromozionale {

    private CodicePromozionale codicePromozionale;
    private User utente;
    private Abbonamento abbonamento;
    private Instant utilizzatoIl;
    private String contesto;  // "REGISTRAZIONE" o "CHECKOUT"

    // Factory methods per i due contesti
    public static UtilizzoCodicePromozionale perRegistrazione(
            CodicePromozionale codice, User utente, Abbonamento abb) {
        return UtilizzoCodicePromozionale.builder()
                .codicePromozionale(codice)
                .utente(utente)
                .abbonamento(abb)
                .utilizzatoIl(Instant.now())
                .contesto("REGISTRAZIONE")
                .build();
    }

    public static UtilizzoCodicePromozionale perchèckout(
            CodicePromozionale codice, User utente, Abbonamento abb) {
        // ... stesso pattern con contesto "CHECKOUT"
    }
}

@RestController
@RequestMapping("/api/v1/webhooks/stripe")
public class StripeWebhookController {

    @PostMapping
    public ResponseEntity<String> handleWebhook(
            @RequestBody String payload,
            @RequestHeader("Stripe-Signature") String stripeSignature) {

        // 1. Verifica firma con webhook secret
        Event event = Webhook.constructEvent(
            payload, stripeSignature, webhookSecret);

        // 2. Dispatch in base al tipo di evento
        switch (event.getType()) {
            case "customer.subscription.created"
                -> handleSubscriptionCreated(event);
            case "customer.subscription.updated"
                -> handleSubscriptionUpdated(event);
            case "customer.subscription.deleted"
                -> handleSubscriptionDeleted(event);
            case "invoice.paid"
                -> handleInvoicePaid(event);
            case "invoice.payment_failed"
                -> handleInvoicePaymentFailed(event);
        }

        // 3. Ritorna sempre 200 per evitare retry di Stripe
        return ResponseEntity.ok("Evento ricevuto");
    }
}

public Session creaCheckoutSession(
        String customerId,
        String priceId,
        String successUrl,
        String cancelUrl,
        String promotionCodeId) throws StripeException {

    var paramsBuilder = SessionCreateParams.builder()
            .setCustomer(customerId)
            .setMode(SessionCreateParams.Mode.SUBSCRIPTION)
            .addLineItem(SessionCreateParams.LineItem.builder()
                    .setPrice(priceId)
                    .setQuantity(1L)
                    .build())
            .setSuccessUrl(successUrl + "?session_id={CHECKOUT_SESSION_ID}")
            .setCancelUrl(cancelUrl);

    if (promotionCodeId != null) {
        // Codice promo predefinito
        paramsBuilder.addDiscount(
            SessionCreateParams.Discount.builder()
                .setPromotionCode(promotionCodeId)
                .build());
    } else {
        // Permetti inserimento manuale
        paramsBuilder.setAllowPromotionCodes(true);
    }

    return Session.create(paramsBuilder.build());
}

@Entity
@Table(name = "acquisto_evento")
public class AcquistoEvento {

    private Evento evento;
    private String nome;
    private Integer quantità;
    private String note;
    private Boolean completato;
    private User completatoDa;
    private Instant completatoIl;
    private User creatoDa;

    public static AcquistoEvento crea(
            Evento evento, String nome, Integer quantità,
            String note, User creatoDa) {
        // Validazioni e creazione
    }

    public void completaAcquisto(User utente) {
        this.completato = true;
        this.completatoDa = utente;
        this.completatoIl = Instant.now();
    }

    public void toggleCompletamento(User utente) {
        if (this.completato) annullaCompletamento();
        else completaAcquisto(utente);
    }
}

@Entity
@Table(name = "finanziamenti")
public class Finanziamento {

    private Long eventoId;
    private Long donatoreId;
    private String donatoreNome;
    private String donatoreEmail;
    private String titolo;
    private TipoFinanziamento tipo;

    @Embedded
    private Money importo;        // Value Object immutabile

    private LocalDate dataFinanziamento;
    private Boolean confermato;

    public static Finanziamento crea(
            Long eventoId, String titolo, Money importo,
            TipoFinanziamento tipo, String donatoreNome,
            Long registratoDaId, LocalDate dataFinanziamento) {
        // Validazioni rigorose: importo positivo,
        // titolo e donatore obbligatori
    }

    public void conferma() {
        this.confermato = true;
        this.confermatoIl = Instant.now();
        this.dataRicezione = LocalDate.now();
    }
}

// Il Value Object Money garantisce operazioni
// monetarie sicure con valuta esplicita
Money donazione = Money.euro(150.00);
Money sponsor = Money.of(new BigDecimal("500.00"), "EUR");
Money totale = donazione.add(sponsor); // EUR 650.00