processor_extras.go

package main

import (
	"archive/zip"
	"encoding/json"
	"image/jpeg"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"

	"github.com/EdlinOrg/prominentcolor"
	"github.com/makiuchi-d/gozxing"
	"github.com/makiuchi-d/gozxing/qrcode"
	"github.com/pdfcpu/pdfcpu/pkg/api"
	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu/model"
	goqr "github.com/skip2/go-qrcode"
)

// PDF Merge
func handlePdfMerge(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxBatchUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	files := r.MultipartForm.File["pdfs"]
	if len(files) < 2 {
		http.Error(w, "Selecione pelo menos 2 PDFs", http.StatusBadRequest)
		return
	}
	if len(files) > maxBatchFiles {
		http.Error(w, "Quantidade máxima de PDFs excedida", http.StatusBadRequest)
		return
	}

	var inFiles []string
	defer func() {
		for _, name := range inFiles {
			_ = os.Remove(name)
		}
	}()
	for _, fileHeader := range files {
		if fileHeader.Size > maxPDFUploadSize {
			http.Error(w, "Um dos PDFs excede o limite individual", http.StatusRequestEntityTooLarge)
			return
		}
		file, err := fileHeader.Open()
		if err != nil {
			http.Error(w, "Erro ao ler arquivo", http.StatusInternalServerError)
			return
		}
		tmp, err := os.CreateTemp("", "canivete-merge-*.pdf")
		if err != nil {
			_ = file.Close()
			internalError(w, "Erro ao preparar PDF temporário", err)
			return
		}
		if _, err := io.Copy(tmp, file); err != nil {
			_ = tmp.Close()
			_ = file.Close()
			_ = os.Remove(tmp.Name())
			internalError(w, "Erro ao salvar PDF temporário", err)
			return
		}
		if err := tmp.Close(); err != nil {
			_ = file.Close()
			_ = os.Remove(tmp.Name())
			internalError(w, "Erro ao salvar PDF temporário", err)
			return
		}
		if err := file.Close(); err != nil {
			_ = os.Remove(tmp.Name())
			internalError(w, "Erro ao ler PDF", err)
			return
		}
		inFiles = append(inFiles, tmp.Name())
	}

	outFile, err := os.CreateTemp("", "canivete-merged-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	outName := outFile.Name()
	if err := outFile.Close(); err != nil {
		_ = os.Remove(outName)
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	defer func() { _ = os.Remove(outName) }()

	conf := model.NewDefaultConfiguration()
	err = api.MergeCreateFile(inFiles, outName, false, conf)
	if err != nil {
		log.Printf("Erro ao juntar PDFs: %v", err)
		http.Error(w, "Um ou mais PDFs são inválidos ou não suportados", http.StatusBadRequest)
		return
	}

	// #nosec G304 -- outName é retornado por os.CreateTemp e nunca recebe entrada do usuário.
	result, err := os.Open(outName)
	if err != nil {
		internalError(w, "Erro ao abrir PDF gerado", err)
		return
	}
	defer result.Close()
	if err := serveDownloadFile(w, result, "application/pdf", "merged.pdf"); err != nil {
		log.Printf("Erro ao enviar PDF unido: %v", err)
	}
}

// PDF Split
func handlePdfSplit(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxPDFUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	file, _, err := r.FormFile("pdf")
	if err != nil {
		http.Error(w, "Arquivo PDF ausente ou inválido na requisição", http.StatusBadRequest)
		return
	}
	defer file.Close()

	tmpPdf, err := os.CreateTemp("", "canivete-split-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF temporário", err)
		return
	}
	defer func() { _ = os.Remove(tmpPdf.Name()) }()
	if _, err := io.Copy(tmpPdf, file); err != nil {
		_ = tmpPdf.Close()
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}
	if err := tmpPdf.Close(); err != nil {
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}

	outDir, err := os.MkdirTemp("", "canivete-split-dir-*")
	if err != nil {
		internalError(w, "Erro ao preparar diretório temporário", err)
		return
	}
	defer func() { _ = os.RemoveAll(outDir) }()

	conf := model.NewDefaultConfiguration()
	err = api.SplitFile(tmpPdf.Name(), outDir, 1, conf)
	if err != nil {
		log.Printf("Erro ao dividir PDF: %v", err)
		http.Error(w, "PDF inválido ou não suportado", http.StatusBadRequest)
		return
	}

	zipFile, err := os.CreateTemp("", "canivete-split-*.zip")
	if err != nil {
		internalError(w, "Erro ao preparar arquivo ZIP", err)
		return
	}
	defer func() {
		_ = zipFile.Close()
		_ = os.Remove(zipFile.Name())
	}()
	zipWriter := zip.NewWriter(zipFile)
	if err := addDirectoryToZip(zipWriter, outDir); err != nil {
		_ = zipWriter.Close()
		internalError(w, "Erro ao compactar páginas", err)
		return
	}
	if err := zipWriter.Close(); err != nil {
		internalError(w, "Erro ao finalizar arquivo ZIP", err)
		return
	}
	if err := serveDownloadFile(w, zipFile, "application/zip", "split_pdfs.zip"); err != nil {
		log.Printf("Erro ao enviar páginas divididas: %v", err)
	}
}

// PDF Protect
func handlePdfProtect(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxPDFUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	password := r.FormValue("password")
	if password == "" {
		http.Error(w, "Senha é obrigatória", http.StatusBadRequest)
		return
	}
	// Segurança: exigir senha com comprimento mínimo razoável
	if len([]rune(password)) < 8 {
		http.Error(w, "A senha deve ter no mínimo 8 caracteres", http.StatusBadRequest)
		return
	}
	if len([]rune(password)) > 128 {
		http.Error(w, "A senha deve ter no máximo 128 caracteres", http.StatusBadRequest)
		return
	}

	file, _, err := r.FormFile("pdf")
	if err != nil {
		http.Error(w, "Erro ao ler arquivo", http.StatusBadRequest)
		return
	}
	defer file.Close()

	tmpPdf, err := os.CreateTemp("", "canivete-protect-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF temporário", err)
		return
	}
	defer func() { _ = os.Remove(tmpPdf.Name()) }()
	if _, err := io.Copy(tmpPdf, file); err != nil {
		_ = tmpPdf.Close()
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}
	if err := tmpPdf.Close(); err != nil {
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}

	outPdf, err := os.CreateTemp("", "canivete-protected-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	outName := outPdf.Name()
	if err := outPdf.Close(); err != nil {
		_ = os.Remove(outName)
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	defer func() { _ = os.Remove(outName) }()

	conf := model.NewDefaultConfiguration()
	conf.UserPW = password
	conf.OwnerPW = password

	err = api.EncryptFile(tmpPdf.Name(), outName, conf)
	if err != nil {
		log.Printf("Erro ao proteger PDF: %v", err)
		http.Error(w, "PDF inválido ou não suportado", http.StatusBadRequest)
		return
	}

	// #nosec G304 -- outName é retornado por os.CreateTemp e nunca recebe entrada do usuário.
	result, err := os.Open(outName)
	if err != nil {
		internalError(w, "Erro ao abrir PDF protegido", err)
		return
	}
	defer result.Close()
	if err := serveDownloadFile(w, result, "application/pdf", "protegido.pdf"); err != nil {
		log.Printf("Erro ao enviar PDF protegido: %v", err)
	}
}

// PDF Optimize
func handlePdfOptimize(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxPDFUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	file, _, err := r.FormFile("pdf")
	if err != nil {
		http.Error(w, "Erro ao ler arquivo", http.StatusBadRequest)
		return
	}
	defer file.Close()

	tmpPdf, err := os.CreateTemp("", "canivete-opt-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF temporário", err)
		return
	}
	defer func() { _ = os.Remove(tmpPdf.Name()) }()
	if _, err := io.Copy(tmpPdf, file); err != nil {
		_ = tmpPdf.Close()
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}
	if err := tmpPdf.Close(); err != nil {
		internalError(w, "Erro ao salvar PDF temporário", err)
		return
	}

	outPdf, err := os.CreateTemp("", "canivete-optout-*.pdf")
	if err != nil {
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	outName := outPdf.Name()
	if err := outPdf.Close(); err != nil {
		_ = os.Remove(outName)
		internalError(w, "Erro ao preparar PDF de saída", err)
		return
	}
	defer func() { _ = os.Remove(outName) }()

	conf := model.NewDefaultConfiguration()
	err = api.OptimizeFile(tmpPdf.Name(), outName, conf)
	if err != nil {
		log.Printf("Erro ao otimizar PDF: %v", err)
		http.Error(w, "PDF inválido ou não suportado", http.StatusBadRequest)
		return
	}

	// #nosec G304 -- outName é retornado por os.CreateTemp e nunca recebe entrada do usuário.
	result, err := os.Open(outName)
	if err != nil {
		internalError(w, "Erro ao abrir PDF otimizado", err)
		return
	}
	defer result.Close()
	if err := serveDownloadFile(w, result, "application/pdf", "otimizado.pdf"); err != nil {
		log.Printf("Erro ao enviar PDF otimizado: %v", err)
	}
}

// Image Compress
func handleImgCompress(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	qualityStr := r.FormValue("quality")
	quality := 80
	if q, err := strconv.Atoi(qualityStr); err == nil {
		quality = q
	}
	// Segurança: clampar qualidade dentro do intervalo válido do codec JPEG
	if quality < 1 {
		quality = 1
	}
	if quality > 100 {
		quality = 100
	}

	file, _, err := r.FormFile("image")
	if err != nil {
		http.Error(w, "Arquivo de imagem ausente ou inválido na requisição", http.StatusBadRequest)
		return
	}
	defer file.Close()

	img, _, err := decodeImage(file)
	if err != nil {
		http.Error(w, "Imagem inválida ou acima dos limites permitidos", http.StatusBadRequest)
		return
	}

	setDownloadHeaders(w, "image/jpeg", "comprimida.jpg")
	if err := jpeg.Encode(w, img, &jpeg.Options{Quality: quality}); err != nil {
		log.Printf("Erro ao codificar imagem comprimida: %v", err)
	}
}

// Image Watermark (skipped for brevity, but let's just implement a simple text watermark via pdfcpu or just skip it because drawing text on image requires freetype/golang.org/x/image/font which is complex to setup. Wait, I'll just skip image watermark and do something simpler, or use ImageMagick for it. Actually, I will NOT do Image Watermark right now to avoid complex font dependencies. I will remove it from the list of routes.)

// QR Generate
func handleQrGenerate(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, 1<<20) {
		return
	}
	defer cleanupMultipartForm(r)

	text := r.FormValue("text")
	if text == "" {
		http.Error(w, "Texto vazio", http.StatusBadRequest)
		return
	}
	if len([]rune(text)) > 4096 {
		http.Error(w, "Texto muito longo para QR Code", http.StatusBadRequest)
		return
	}

	png, err := goqr.Encode(text, goqr.Medium, 256)
	if err != nil {
		http.Error(w, "Erro ao gerar QR Code", http.StatusInternalServerError)
		return
	}

	setDownloadHeaders(w, "image/png", "qrcode.png")
	// #nosec G705 -- bytes são um PNG gerado pela biblioteca, com nosniff e tipo fixo.
	_, _ = w.Write(png)
}

// QR Read
func handleQrRead(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	file, _, err := r.FormFile("image")
	if err != nil {
		http.Error(w, "Arquivo de imagem ausente ou inválido na requisição", http.StatusBadRequest)
		return
	}
	defer file.Close()

	img, _, err := decodeImage(file)
	if err != nil {
		http.Error(w, "Imagem inválida ou acima dos limites permitidos", http.StatusBadRequest)
		return
	}

	bmp, _ := gozxing.NewBinaryBitmapFromImage(img)
	qrReader := qrcode.NewQRCodeReader()
	result, err := qrReader.Decode(bmp, nil)
	if err != nil {
		http.Error(w, "Nenhum QR Code encontrado ou legível", http.StatusBadRequest)
		return
	}

	setDownloadHeaders(w, "text/plain; charset=utf-8", "qrcode.txt")
	// #nosec G705 -- resposta é texto puro com nosniff; a UI usa textarea.value.
	_, _ = w.Write([]byte(result.GetText()))
}

// Image Palette
func handleImgPalette(w http.ResponseWriter, r *http.Request) {
	if !parseMultipartForm(w, r, maxUploadSize) {
		return
	}
	defer cleanupMultipartForm(r)

	file, _, err := r.FormFile("image")
	if err != nil {
		http.Error(w, "Arquivo de imagem ausente ou inválido na requisição", http.StatusBadRequest)
		return
	}
	defer file.Close()

	img, _, err := decodeImage(file)
	if err != nil {
		http.Error(w, "Imagem inválida ou acima dos limites permitidos", http.StatusBadRequest)
		return
	}

	cols, err := prominentcolor.Kmeans(img)
	if err != nil {
		http.Error(w, "Erro ao extrair cores", http.StatusInternalServerError)
		return
	}

	var hexColors []string
	for _, c := range cols {
		hexColors = append(hexColors, "#"+c.AsString())
	}

	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(map[string]interface{}{"colors": hexColors}); err != nil {
		log.Printf("Erro ao enviar paleta de cores: %v", err)
	}
}