soft_usite/pkg/services/soporte_service.go

package services

import (
	"crypto/tls"
	"fmt"
	"log"
	"net/smtp"
	"strings"
	"sync"

	"github.com/sujit-baniya/fiber-boilerplate/app"
	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
)

// soporteSendMail envía un correo usando la configuración SMTP del webhook de soporte.
// Si no hay SMTP configurado, usa app.Http.Mail como fallback.
func soporteSendMail(to, subject, htmlBody string) error {
	cfg, err := models.GetSoporteWebhookActivo()
	if err != nil || cfg == nil || cfg.SmtpHost == "" {
		return app.Http.Mail.Send(to, subject, htmlBody)
	}
	from := cfg.SmtpFromAddr
	if from == "" {
		from = cfg.EmailDestino
	}
	if from == "" {
		return app.Http.Mail.Send(to, subject, htmlBody)
	}
	fromName := cfg.SmtpFromName
	if fromName == "" {
		fromName = "Soporte"
	}
	port := cfg.SmtpPort
	if port == 0 {
		port = 587
	}
	addr := fmt.Sprintf("%s:%d", cfg.SmtpHost, port)
	msg := []byte(fmt.Sprintf(
		"From: %s <%s>\r\nTo: %s\r\nSubject: %s\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n%s",
		fromName, from, to, subject, htmlBody))

	if err := enviarPorSMTP(cfg, addr, from, to, msg); err != nil {
		return fmt.Errorf("SMTP de soporte (%s): %w", addr, err)
	}
	return nil
}

// enviarPorSMTP abre una sola conexión, la asegura según la configuración,
// manda el mensaje y cierra con QUIT.
//
// Antes el camino STARTTLS abría una conexión, hacía StartTLS, autenticaba… y
// la descartaba para llamar a smtp.SendMail, que abre otra distinta: la primera
// quedaba colgada y el envío real salía por una conexión que podía no estar
// autenticada igual.
func enviarPorSMTP(cfg *models.SoporteWebhookConfig, addr, from, to string, msg []byte) error {
	enc := strings.ToLower(strings.TrimSpace(cfg.SmtpEncryption))

	var cliente *smtp.Client
	var err error
	if enc == "tls" || enc == "ssl" {
		conn, errDial := tls.Dial("tcp", addr, &tls.Config{ServerName: cfg.SmtpHost})
		if errDial != nil {
			return fmt.Errorf("no se pudo conectar por TLS: %w", errDial)
		}
		cliente, err = smtp.NewClient(conn, cfg.SmtpHost)
		if err != nil {
			conn.Close()
			return fmt.Errorf("saludo SMTP rechazado: %w", err)
		}
	} else {
		cliente, err = smtp.Dial(addr)
		if err != nil {
			return fmt.Errorf("no se pudo conectar: %w", err)
		}
		if enc != "none" {
			if err := cliente.StartTLS(&tls.Config{ServerName: cfg.SmtpHost}); err != nil {
				cliente.Close()
				return fmt.Errorf("STARTTLS rechazado: %w", err)
			}
		}
	}
	defer cliente.Close()

	if cfg.SmtpUsername != "" {
		if err := cliente.Auth(smtp.PlainAuth("", cfg.SmtpUsername, cfg.SmtpPassword, cfg.SmtpHost)); err != nil {
			return fmt.Errorf("autenticación rechazada para %s: %w", cfg.SmtpUsername, err)
		}
	}
	if err := cliente.Mail(from); err != nil {
		return fmt.Errorf("el servidor rechazó el remitente %s: %w", from, err)
	}
	if err := cliente.Rcpt(to); err != nil {
		return fmt.Errorf("el servidor rechazó el destinatario %s: %w", to, err)
	}
	w, err := cliente.Data()
	if err != nil {
		return err
	}
	if _, err := w.Write(msg); err != nil {
		return err
	}
	if err := w.Close(); err != nil {
		return fmt.Errorf("el servidor rechazó el mensaje: %w", err)
	}
	return cliente.Quit()
}

// ProbarEnvioSoporte manda un correo de prueba por el mismo camino que usa el
// acuse automático, y devuelve el error tal cual. Es la única forma de saber
// por qué no llega: el acuse real se manda en segundo plano.
func ProbarEnvioSoporte(destino string) error {
	if strings.TrimSpace(destino) == "" {
		return fmt.Errorf("indicá a qué dirección mandar la prueba")
	}
	cuerpo := `<p>Esto es una prueba del envío de soporte.</p>
<p>Si te llegó, el acuse automático de los tickets también va a salir por acá.</p>`
	return soporteSendMail(destino, "Prueba de envío de soporte", cuerpo)
}

// SendSoporteAutoRespuesta envía acuse de recibo automático al crear un ticket por email
func SendSoporteAutoRespuesta(ticket *models.ProyectoTicket) {
	if ticket == nil || ticket.EmailFrom == "" {
		return
	}
	subject := fmt.Sprintf("[Ticket #%d] Recibimos tu solicitud: %s", ticket.ID, ticket.Titulo)
	mensaje := "Hemos recibido tu solicitud y te responderemos a la brevedad."
	if app.Http.Database.DB != nil {
		if cfg, err := models.GetSoporteWebhookActivo(); err == nil && cfg.MensajeAuto != "" {
			mensaje = cfg.MensajeAuto
		}
	}
	htmlBody := fmt.Sprintf(`<!DOCTYPE html>
<html><body style="font-family:Inter,sans-serif;background:#f1f5f9;padding:32px">
<div style="max-width:520px;margin:0 auto;background:#fff;border-radius:16px;padding:32px;border:1px solid #e2e8f0">
  <div style="text-align:center;margin-bottom:24px">
    <div style="width:48px;height:48px;border-radius:50%%;background:#8eb02f;display:inline-flex;align-items:center;justify-content:center;color:#fff;font-weight:700;font-size:20px">U</div>
    <h2 style="margin:12px 0 4px;color:#1e293b">Ticket recibido</h2>
    <p style="color:#64748b;font-size:14px;margin:0">Soporte U-site</p>
  </div>
  <p style="color:#334155;font-size:15px">Hola <strong>%s</strong>,</p>
  <p style="color:#334155;font-size:14px">%s</p>
  <div style="background:#f8fafc;border-radius:10px;padding:16px;margin:20px 0;border:1px solid #e2e8f0">
    <p style="margin:0 0 6px;font-size:13px;color:#64748b"><strong>Ticket:</strong> #%d</p>
    <p style="margin:0 0 6px;font-size:13px;color:#64748b"><strong>Asunto:</strong> %s</p>
    <p style="margin:0;font-size:13px;color:#64748b"><strong>Mensaje:</strong> %s</p>
  </div>
  <p style="color:#94a3b8;font-size:12px">Este es un mensaje automático. No respondas a este correo.</p>
</div></body></html>`, ticket.AutorNombre, mensaje, ticket.ID, ticket.Titulo, ticket.Descripcion)

	go func() {
		if err := soporteSendMail(ticket.EmailFrom, subject, htmlBody); err != nil {
			log.Printf("[Soporte] Error enviando auto-respuesta a %s: %v", ticket.EmailFrom, err)
			guardarErrorAcuse(fmt.Sprintf("el acuse al cliente %s no salió: %v", ticket.EmailFrom, err))
		} else {
			log.Printf("[Soporte] Auto-respuesta enviada a %s (ticket #%d)", ticket.EmailFrom, ticket.ID)
			guardarErrorAcuse("")
		}
	}()
}

// SendSoporteNotifAdmin notifica a los admins sobre un nuevo ticket de email
func SendSoporteNotifAdmin(ticket *models.ProyectoTicket) {
	if ticket == nil {
		return
	}
	adminEmail := ""
	if app.Http.Database.DB != nil {
		if cfg, err := models.GetSmtpConfig(); err == nil {
			adminEmail = cfg.FromAddress
		}
	}
	if adminEmail == "" {
		return
	}
	subject := fmt.Sprintf("🎫 Nuevo ticket por email: %s", ticket.Titulo)
	htmlBody := fmt.Sprintf(`<!DOCTYPE html>
<html><body style="font-family:Inter,sans-serif;background:#f1f5f9;padding:32px">
<div style="max-width:520px;margin:0 auto;background:#fff;border-radius:16px;padding:32px;border:1px solid #e2e8f0">
  <div style="display:flex;align-items:center;gap:12px;margin-bottom:20px">
    <div style="width:40px;height:40px;border-radius:50%%;background:#8eb02f;display:flex;align-items:center;justify-content:center;color:#fff;font-size:18px">🎫</div>
    <div><h2 style="margin:0;color:#1e293b;font-size:17px">Nuevo ticket por email</h2>
    <p style="margin:0;color:#64748b;font-size:13px">De: <strong>%s</strong> &lt;%s&gt;</p></div>
  </div>
  <div style="background:#f8fafc;border-radius:10px;padding:16px;margin-bottom:20px;border:1px solid #e2e8f0">
    <p style="margin:0 0 6px;font-size:14px;color:#334155"><strong>Asunto:</strong> %s</p>
    <p style="margin:0;font-size:14px;color:#334155"><strong>Mensaje:</strong> %s</p>
  </div>
  <a href="%s/app/tickets?ticket=%d" style="display:block;text-align:center;background:#8eb02f;color:#fff;padding:12px 24px;border-radius:10px;font-weight:600;text-decoration:none;font-size:15px">Ver ticket</a>
</div></body></html>`, ticket.AutorNombre, ticket.EmailFrom, ticket.Titulo, ticket.Descripcion, absAppURL(""), ticket.ID)

	go func() {
		if err := soporteSendMail(adminEmail, subject, htmlBody); err != nil {
			log.Printf("[Soporte] Error notificando admin: %v", err)
		}
	}()
}

// El acuse se manda en segundo plano, así que su error no puede devolverse al
// que creó el ticket. Se guarda acá para poder mostrarlo en la pantalla de
// configuración, que es donde alguien lo va a ver.
var (
	muErrorAcuse   sync.Mutex
	ultimoErrAcuse string
)

func guardarErrorAcuse(msg string) {
	muErrorAcuse.Lock()
	defer muErrorAcuse.Unlock()
	ultimoErrAcuse = msg
}

// UltimoErrorAcuse devuelve el último fallo al mandarle el acuse a un cliente
// ("" si el último salió bien).
func UltimoErrorAcuse() string {
	muErrorAcuse.Lock()
	defer muErrorAcuse.Unlock()
	return ultimoErrAcuse
}