file-tool-wails/handlers.go

package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	stdruntime "runtime"
	"strings"
	"time"

	wailsRuntime "github.com/wailsapp/wails/v2/pkg/runtime"

	"xk/services"
)

type FileHandler struct {
	ctx          context.Context
	pdfService   *services.PDFService
	wordService  *services.WordService
	excelService *services.ExcelService
	imageService *services.ImageService
}

func NewFileHandler() *FileHandler {
	return &FileHandler{
		pdfService:   services.NewPDFService(),
		wordService:  services.NewWordService(),
		excelService: services.NewExcelService(),
		imageService: services.NewImageService(),
	}
}

func (h *FileHandler) startup(ctx context.Context) {
	h.ctx = ctx
}

type FileResult struct {
	Success      bool   `json:"success"`
	Message      string `json:"message"`
	Path         string `json:"path,omitempty"`
	Size         int64  `json:"size,omitempty"`
	OriginalSize int64  `json:"originalSize,omitempty"`
}

type ProcessRequest struct {
	InputPath          string              `json:"inputPath"`
	InputPaths         []string            `json:"inputPaths,omitempty"`
	OutputPath         string              `json:"outputPath,omitempty"`
	Format             string              `json:"format,omitempty"`
	OutputFormat       string              `json:"outputFormat,omitempty"`
	Quality            string              `json:"quality,omitempty"`
	QualityInt         int                 `json:"qualityInt,omitempty"`
	Width              int                 `json:"width,omitempty"`
	Height             int                 `json:"height,omitempty"`
	Angle              float64             `json:"angle,omitempty"`
	BgColor            string              `json:"bgColor,omitempty"`
	BgRemoveColor      *services.ColorRGB  `json:"bgRemoveColor,omitempty"`
	Text               string              `json:"text,omitempty"`
	Threshold          int                 `json:"threshold,omitempty"`
	Shape              *services.CropShape `json:"shape,omitempty"`
	Brightness         int                 `json:"brightness,omitempty"`
	Contrast           int                 `json:"contrast,omitempty"`
	Saturation         int                 `json:"saturation,omitempty"`
	GrayscaleIntensity int                 `json:"grayscaleIntensity,omitempty"`
	SharpenAmount      float64             `json:"sharpenAmount,omitempty"`
	BlurRadius         float64             `json:"blurRadius,omitempty"`
	FlipH              bool                `json:"flipH,omitempty"`
	FlipV              bool                `json:"flipV,omitempty"`
	MaintainRatio      *bool               `json:"maintainRatio,omitempty"`
	PageRanges         string              `json:"pageRanges,omitempty"`
	DPI                float64             `json:"dpi,omitempty"`
	ImageFormat        string              `json:"imageFormat,omitempty"`
	OptimizeLevel      string              `json:"optimizeLevel,omitempty"`
	CropX              int                 `json:"cropX,omitempty"`
	CropY              int                 `json:"cropY,omitempty"`
}

type AppConfig struct {
	DefaultOutputDir string `json:"defaultOutputDir"`
}

type Shortcut struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Category string `json:"category"`
	Icon     string `json:"icon"`
}

type RecentUse struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Category string `json:"category"`
	UsedAt   int64  `json:"usedAt"`
}

func (h *FileHandler) OpenFileDialog(title string, filters []string) (string, error) {
	var fileFilters []wailsRuntime.FileFilter
	if title == "" {
		title = "选择文件"
	}
	if len(filters) == 0 {
		filters = []string{"*"}
	}
	for _, f := range filters {
		displayName := "所有文件 (*.*)"
		switch f {
		case "*.pdf":
			displayName = "PDF 文件 (*.pdf)"
		case "*.doc;*.docx":
			displayName = "Word 文档 (*.doc;*.docx)"
		case "*.xls;*.xlsx":
			displayName = "Excel 文件 (*.xls;*.xlsx)"
		case "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.webp;*.ico":
			displayName = "图片文件 (*.jpg;*.png;*.gif;*.bmp;*.tiff;*.webp;*.ico)"
		}
		fileFilters = append(fileFilters, wailsRuntime.FileFilter{DisplayName: displayName, Pattern: f})
	}

	path, err := wailsRuntime.OpenFileDialog(h.ctx, wailsRuntime.OpenDialogOptions{Title: title, Filters: fileFilters})
	return path, err
}

func (h *FileHandler) OpenFilesDialog(title string, filters []string) ([]string, error) {
	var fileFilters []wailsRuntime.FileFilter
	if title == "" {
		title = "选择文件"
	}
	if len(filters) == 0 {
		filters = []string{"*"}
	}
	for _, f := range filters {
		displayName := "所有文件 (*.*)"
		switch f {
		case "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.webp;*.ico":
			displayName = "图片文件 (*.jpg;*.png;*.gif;*.bmp;*.tiff;*.webp;*.ico)"
		case "*.pdf":
			displayName = "PDF 文件 (*.pdf)"
		}
		fileFilters = append(fileFilters, wailsRuntime.FileFilter{DisplayName: displayName, Pattern: f})
	}

	paths, err := wailsRuntime.OpenMultipleFilesDialog(h.ctx, wailsRuntime.OpenDialogOptions{Title: title, Filters: fileFilters})
	return paths, err
}

func (h *FileHandler) OpenSaveDialog(title string, defaultFilename string, filters []string, defaultDir string) (string, error) {
	if title == "" {
		title = "保存文件"
	}
	var fileFilters []wailsRuntime.FileFilter
	for _, f := range filters {
		displayName := "所有文件 (*.*)"
		switch f {
		case "*.pdf":
			displayName = "PDF 文件 (*.pdf)"
		case "*.csv":
			displayName = "CSV 文件 (*.csv)"
		case "*.json":
			displayName = "JSON 文件 (*.json)"
		case "*.jpg;*.jpeg":
			displayName = "JPEG 图片 (*.jpg;*.jpeg)"
		case "*.png":
			displayName = "PNG 图片 (*.png)"
		case "*.ico":
			displayName = "ICO 图标 (*.ico)"
		}
		fileFilters = append(fileFilters, wailsRuntime.FileFilter{DisplayName: displayName, Pattern: f})
	}
	path, err := wailsRuntime.SaveFileDialog(h.ctx, wailsRuntime.SaveDialogOptions{Title: title, DefaultFilename: defaultFilename, DefaultDirectory: defaultDir, Filters: fileFilters})
	return path, err
}

func (h *FileHandler) OpenFolder(path string) error {
	if path == "" {
		return fmt.Errorf("路径不能为空")
	}
	var cmd *exec.Cmd
	switch stdruntime.GOOS {
	case "windows":
		cmd = exec.Command("explorer", path)
	case "darwin":
		cmd = exec.Command("open", path)
	default:
		cmd = exec.Command("xdg-open", path)
	}
	return cmd.Start()
}

// SaveBase64ToFile 将 base64 数据写入指定路径
func (h *FileHandler) SaveBase64ToFile(base64Data string, outputPath string) FileResult {
	if base64Data == "" {
		return FileResult{Success: false, Message: "数据为空"}
	}
	if outputPath == "" {
		return FileResult{Success: false, Message: "输出路径为空"}
	}
	data, err := base64.StdEncoding.DecodeString(base64Data)
	if err != nil {
		return FileResult{Success: false, Message: "解码失败: " + err.Error()}
	}
	if err := os.WriteFile(outputPath, data, 0644); err != nil {
		return FileResult{Success: false, Message: "写入文件失败: " + err.Error()}
	}
	return FileResult{Success: true, Path: outputPath, Size: int64(len(data))}
}

func (h *FileHandler) GetConfig() AppConfig {
	config := AppConfig{DefaultOutputDir: getDefaultOutputDir()}
	data, err := os.ReadFile(getConfigPath())
	if err != nil {
		return config
	}
	_ = services.ParseJSON(data, &config)
	return config
}

func (h *FileHandler) SaveConfig(config AppConfig) error {
	data, err := services.ToJSON(config)
	if err != nil {
		return err
	}
	return os.WriteFile(getConfigPath(), data, 0644)
}

func (h *FileHandler) GetShortcuts() []Shortcut {
	var shortcuts []Shortcut
	data, err := os.ReadFile(getShortcutsPath())
	if err != nil {
		return getDefaultShortcuts()
	}
	_ = services.ParseJSON(data, &shortcuts)
	if len(shortcuts) == 0 {
		return getDefaultShortcuts()
	}
	return shortcuts
}

func (h *FileHandler) SaveShortcuts(shortcuts []Shortcut) error {
	data, err := services.ToJSON(shortcuts)
	if err != nil {
		return err
	}
	return os.WriteFile(getShortcutsPath(), data, 0644)
}

func (h *FileHandler) GetRecentUses() []RecentUse {
	var recent []RecentUse
	data, err := os.ReadFile(getRecentPath())
	if err != nil {
		return []RecentUse{}
	}
	_ = services.ParseJSON(data, &recent)
	return recent
}

func (h *FileHandler) AddRecentUse(tool RecentUse) error {
	var recent []RecentUse
	data, err := os.ReadFile(getRecentPath())
	if err == nil {
		_ = services.ParseJSON(data, &recent)
	}
	for i, r := range recent {
		if r.ID == tool.ID {
			recent = append(recent[:i], recent[i+1:]...)
			break
		}
	}
	recent = append([]RecentUse{tool}, recent...)
	if len(recent) > 5 {
		recent = recent[:5]
	}
	data, err = services.ToJSON(recent)
	if err != nil {
		return err
	}
	return os.WriteFile(getRecentPath(), data, 0644)
}

func (h *FileHandler) GetImageBase64(path string) (string, error) {
	return h.imageService.GetImageBase64(path)
}

func (h *FileHandler) GetCompareImages(originalPath, processedPath string) (map[string]string, error) {
	result := make(map[string]string)
	if originalPath != "" {
		b64, err := h.imageService.GetImageBase64(originalPath)
		if err == nil {
			result["original"] = b64
		}
	}
	if processedPath != "" {
		b64, err := h.imageService.GetImageBase64(processedPath)
		if err == nil {
			result["processed"] = b64
		}
	}
	return result, nil
}

func (h *FileHandler) SaveResult(tempPath, outputPath string) (FileResult, error) {
	if outputPath == "" {
		return FileResult{}, fmt.Errorf("未指定输出路径")
	}

	data, err := os.ReadFile(tempPath)
	if err != nil {
		return FileResult{}, fmt.Errorf("读取临时文件失败: %v", err)
	}

	dir := filepath.Dir(outputPath)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return FileResult{}, fmt.Errorf("创建目录失败: %v", err)
	}

	if err := os.WriteFile(outputPath, data, 0644); err != nil {
		return FileResult{}, fmt.Errorf("保存文件失败: %v", err)
	}

	info, err := os.Stat(outputPath)
	if err != nil {
		return FileResult{}, fmt.Errorf("获取文件信息失败: %v", err)
	}

	return FileResult{
		Success: true,
		Message: "保存成功",
		Path:    outputPath,
		Size:    info.Size(),
	}, nil
}

func (h *FileHandler) ProcessFile(req ProcessRequest) FileResult {
	if req.InputPath == "" {
		return FileResult{Success: false, Message: "请选择文件"}
	}

	ext := strings.ToLower(filepath.Ext(req.InputPath))

	switch ext {
	case ".pdf":
		return h.processPDF(req)
	case ".doc", ".docx":
		return h.processWord(req)
	case ".xls", ".xlsx":
		return h.processExcel(req)
	case ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".webp", ".ico":
		return h.processImage(req)
	case ".txt", ".md", ".html":
		return h.processTextToPDF(req)
	default:
		return FileResult{Success: false, Message: fmt.Sprintf("不支持的文件格式: %s", ext)}
	}
}

func (h *FileHandler) resolveOutputPath(inputPath, outputPath, suffix, ext string) string {
	if outputPath != "" {
		return outputPath
	}
	config := h.GetConfig()
	outDir := config.DefaultOutputDir
	if outDir == "" {
		outDir = filepath.Dir(inputPath)
	}
	baseName := services.GetBaseName(inputPath)
	return filepath.Join(outDir, baseName+suffix+ext)
}

func (h *FileHandler) getTempPath(inputPath, suffix string) string {
	tempDir := os.TempDir()
	baseName := services.GetBaseName(inputPath)
	return filepath.Join(tempDir, "xk_"+baseName+suffix+".png")
}

func (h *FileHandler) processPDF(req ProcessRequest) FileResult {
	var err error
	outputPath := h.resolveOutputPath(req.InputPath, req.OutputPath, "_processed", ".pdf")

	switch req.Format {
	case "compress":
		err = h.pdfService.OptimizePDF(req.InputPath, outputPath, req.OptimizeLevel)
	case "split":
		outputDir := filepath.Dir(outputPath)
		_, err = h.pdfService.SplitPDF(req.InputPath, outputDir, req.PageRanges)
	case "rotate":
		err = h.pdfService.RotatePDF(req.InputPath, outputPath, int(req.Angle))
	case "watermark":
		err = h.pdfService.AddWatermark(req.InputPath, outputPath, req.Text)
	case "merge":
		err = h.pdfService.MergePDFs(req.InputPaths, outputPath)
	case "toImage":
		outputDir := filepath.Dir(outputPath)
		results, imgErr := h.pdfService.PDFToImages(req.InputPath, outputDir, req.ImageFormat, req.DPI)
		if imgErr != nil {
			err = imgErr
		} else if len(results) > 0 {
			return FileResult{Success: true, Message: fmt.Sprintf("已生成 %d 张图片", len(results)), Path: results[0], Size: 0}
		}
	case "toText":
		text, txtErr := h.pdfService.ExtractText(req.InputPath)
		if txtErr != nil {
			err = txtErr
		} else {
			txtPath := services.ChangeExtension(outputPath, ".txt")
			if writeErr := os.WriteFile(txtPath, []byte(text), 0644); writeErr != nil {
				err = writeErr
			} else {
				return h.getFileResult(req.InputPath, txtPath)
			}
		}
	case "toWord":
		text, txtErr := h.pdfService.ExtractText(req.InputPath)
		if txtErr != nil {
			err = txtErr
		} else {
			txtPath := services.ChangeExtension(outputPath, ".txt")
			if writeErr := os.WriteFile(txtPath, []byte(text), 0644); writeErr != nil {
				err = writeErr
			} else {
				return h.getFileResult(req.InputPath, txtPath)
			}
		}
	case "toExcel":
		text, txtErr := h.pdfService.ExtractText(req.InputPath)
		if txtErr != nil {
			err = txtErr
		} else {
			csvPath := services.ChangeExtension(outputPath, ".csv")
			lines := strings.Split(text, "\n")
			var csvContent strings.Builder
			for _, line := range lines {
				line = strings.TrimSpace(line)
				if line != "" {
					if strings.ContainsAny(line, ",\"") {
						csvContent.WriteString("\"" + strings.ReplaceAll(line, "\"", "\"\"") + "\"\n")
					} else {
						csvContent.WriteString(line + "\n")
					}
				}
			}
			if writeErr := os.WriteFile(csvPath, []byte(csvContent.String()), 0644); writeErr != nil {
				err = writeErr
			} else {
				return h.getFileResult(req.InputPath, csvPath)
			}
		}
	case "toHtml":
		text, txtErr := h.pdfService.ExtractText(req.InputPath)
		if txtErr != nil {
			err = txtErr
		} else {
			htmlPath := services.ChangeExtension(outputPath, ".html")
			lines := strings.Split(text, "\n")
			var html strings.Builder
			html.WriteString("<!DOCTYPE html>\n<html>\n<head>\n<meta charset=\"utf-8\">\n<title>PDF Text</title>\n<style>body{font-family:sans-serif;max-width:800px;margin:0 auto;padding:20px;line-height:1.6}</style>\n</head>\n<body>\n")
			for _, line := range lines {
				line = strings.TrimSpace(line)
				if line != "" {
					html.WriteString("<p>" + line + "</p>\n")
				}
			}
			html.WriteString("</body>\n</html>")
			if writeErr := os.WriteFile(htmlPath, []byte(html.String()), 0644); writeErr != nil {
				err = writeErr
			} else {
				return h.getFileResult(req.InputPath, htmlPath)
			}
		}
	case "toMarkdown":
		text, txtErr := h.pdfService.ExtractText(req.InputPath)
		if txtErr != nil {
			err = txtErr
		} else {
			mdPath := services.ChangeExtension(outputPath, ".md")
			if writeErr := os.WriteFile(mdPath, []byte(text), 0644); writeErr != nil {
				err = writeErr
			} else {
				return h.getFileResult(req.InputPath, mdPath)
			}
		}
	default:
		err = h.pdfService.OptimizePDF(req.InputPath, outputPath, "medium")
	}

	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}
	return h.getFileResult(req.InputPath, outputPath)
}

func (h *FileHandler) processWord(req ProcessRequest) FileResult {
	outputPath := h.resolveOutputPath(req.InputPath, req.OutputPath, "", ".pdf")
	err := h.wordService.ConvertToPDF(req.InputPath, outputPath)
	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}
	return h.getFileResult(req.InputPath, outputPath)
}

func (h *FileHandler) processExcel(req ProcessRequest) FileResult {
	outputExt := ".csv"
	if req.Format == "json" {
		outputExt = ".json"
	}
	outputPath := h.resolveOutputPath(req.InputPath, req.OutputPath, "", outputExt)

	var err error
	switch req.Format {
	case "csv":
		err = h.excelService.ConvertToCSV(req.InputPath, outputPath)
	case "json":
		err = h.excelService.ConvertToJSON(req.InputPath, outputPath)
	default:
		err = h.excelService.ConvertToCSV(req.InputPath, outputPath)
	}

	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}
	return h.getFileResult(req.InputPath, outputPath)
}

func (h *FileHandler) processTextToPDF(req ProcessRequest) FileResult {
	outputPath := h.resolveOutputPath(req.InputPath, req.OutputPath, "", ".pdf")

	ext := strings.ToLower(filepath.Ext(req.InputPath))
	var err error
	switch ext {
	case ".md":
		err = h.pdfService.MarkdownToPDF(req.InputPath, outputPath)
	case ".html":
		err = h.pdfService.HTMLToPDF(req.InputPath, outputPath)
	default:
		err = h.pdfService.TextToPDF(req.InputPath, outputPath)
	}

	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}
	return h.getFileResult(req.InputPath, outputPath)
}

func (h *FileHandler) processImage(req ProcessRequest) FileResult {
	isImageOp := req.Format == "compress" || req.Format == "resize" ||
		req.Format == "rotate" || req.Format == "grayscale" || req.Format == "brightness" ||
		req.Format == "removebg" || req.Format == "crop" || req.Format == "flipH" || req.Format == "flipV" ||
		req.Format == "sharpen" || req.Format == "blur" || req.Format == "invert"

	var outputPath string
	if isImageOp {
		outputPath = h.getTempPath(req.InputPath, "_processed")
	} else if req.Format == "convert" {
		outputPath = h.resolveOutputPath(req.InputPath, req.OutputPath, "", "."+h.getConvertFormat(req))
	} else {
		outputPath = h.resolveOutputPath(req.InputPath, req.OutputPath, "", "."+req.Format)
	}

	var err error
	switch req.Format {
	case "compress":
		quality := 85
		if req.QualityInt > 0 {
			quality = req.QualityInt
		} else {
			switch req.Quality {
			case "high":
				quality = 95
			case "low":
				quality = 60
			}
		}
		err = h.imageService.CompressImage(req.InputPath, outputPath, quality, req.Width, req.Height)
	case "resize":
		maintainRatio := true
		if req.MaintainRatio != nil {
			maintainRatio = *req.MaintainRatio
		}
		err = h.imageService.ResizeImage(req.InputPath, outputPath, req.Width, req.Height, maintainRatio)
	case "rotate":
		err = h.imageService.RotateImage(req.InputPath, outputPath, req.Angle, req.BgColor)
		if err == nil && req.FlipH {
			err = h.imageService.FlipH(outputPath, outputPath)
		}
		if err == nil && req.FlipV {
			err = h.imageService.FlipV(outputPath, outputPath)
		}
	case "grayscale":
		intensity := req.GrayscaleIntensity
		if intensity <= 0 {
			intensity = 100
		}
		err = h.imageService.AdjustGrayscale(req.InputPath, outputPath, intensity)
	case "brightness":
		brightness := float64(req.Brightness)
		err = h.imageService.AdjustBrightness(req.InputPath, outputPath, brightness)
		if err == nil && req.Contrast != 0 {
			contrastPath := h.getTempPath(req.InputPath, "_contrast")
			if err2 := h.imageService.AdjustContrast(outputPath, contrastPath, float64(req.Contrast)); err2 != nil {
				err = err2
			} else {
				os.Remove(outputPath)
				os.Rename(contrastPath, outputPath)
			}
		}
		if err == nil && req.Saturation != 0 {
			satPath := h.getTempPath(req.InputPath, "_saturation")
			if err2 := h.imageService.AdjustSaturation(outputPath, satPath, float64(req.Saturation)); err2 != nil {
				err = err2
			} else {
				os.Remove(outputPath)
				os.Rename(satPath, outputPath)
			}
		}
	case "flipH":
		err = h.imageService.FlipH(req.InputPath, outputPath)
	case "flipV":
		err = h.imageService.FlipV(req.InputPath, outputPath)
	case "sharpen":
		amount := req.SharpenAmount
		if amount <= 0 {
			amount = 1.0
		}
		err = h.imageService.SharpenImage(req.InputPath, outputPath, amount)
	case "blur":
		radius := req.BlurRadius
		if radius <= 0 {
			radius = 3.0
		}
		err = h.imageService.BlurImage(req.InputPath, outputPath, radius)
	case "invert":
		err = h.imageService.InvertImage(req.InputPath, outputPath)
	case "removebg":
		err = h.imageService.RemoveBackground(req.InputPath, outputPath, req.Threshold, req.BgRemoveColor)
	case "crop":
		if req.Shape != nil {
			shape := *req.Shape
			if shape.X == 0 && shape.Y == 0 && (req.CropX != 0 || req.CropY != 0) {
				shape.X = req.CropX
				shape.Y = req.CropY
			}
			err = h.imageService.CropImageShape(req.InputPath, outputPath, shape)
		} else {
			err = h.imageService.CropImageShape(req.InputPath, outputPath, services.CropShape{
				Type: "rectangle", X: req.CropX, Y: req.CropY, Width: req.Width, Height: req.Height,
			})
		}
	case "toPdf":
		if outputPath == "" {
			outputPath = services.ChangeExtension(req.InputPath, ".pdf")
		}
		err = h.imageService.ImageToPDF(req.InputPath, outputPath)
	default:
		quality := 85
		if req.QualityInt > 0 {
			quality = req.QualityInt
		}
		err = h.imageService.ConvertFormat(req.InputPath, outputPath, h.getConvertFormat(req), quality)
	}

	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}

	result := h.getFileResult(req.InputPath, outputPath)
	if result.Success && isImageOp {
		result.Path = outputPath
	}
	return result
}

func (h *FileHandler) getConvertFormat(req ProcessRequest) string {
	if req.OutputFormat != "" {
		return req.OutputFormat
	}
	if req.Format == "convert" {
		return "png"
	}
	return req.Format
}

func (h *FileHandler) getFileResult(inputPath, outputPath string) FileResult {
	info, err := os.Stat(outputPath)
	if err != nil {
		return FileResult{Success: false, Message: fmt.Sprintf("获取文件信息失败: %v", err)}
	}
	result := FileResult{Success: true, Message: "处理完成", Path: outputPath, Size: info.Size()}
	if inputPath != "" {
		if inputInfo, err := os.Stat(inputPath); err == nil {
			result.OriginalSize = inputInfo.Size()
		}
	}
	return result
}

func (h *FileHandler) GetFileInfo(path string) map[string]interface{} {
	ext := strings.ToLower(filepath.Ext(path))
	result := make(map[string]interface{})
	switch ext {
	case ".pdf":
		info, err := h.pdfService.GetPDFInfo(path)
		if err == nil {
			result["type"] = "pdf"
			result["pages"] = info.Pages
			result["size"] = info.Size
		}
	case ".doc", ".docx":
		info, err := h.wordService.GetWordInfo(path)
		if err == nil {
			result["type"] = "word"
			result["title"] = info.Title
			result["words"] = info.Words
			result["size"] = info.Size
		}
	case ".xls", ".xlsx":
		info, err := h.excelService.GetExcelInfo(path)
		if err == nil {
			result["type"] = "excel"
			result["sheets"] = info.Sheets
			result["size"] = info.Size
		}
	case ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".webp", ".ico":
		info, err := h.imageService.GetImageInfo(path)
		if err == nil {
			result["type"] = "image"
			result["width"] = info.Width
			result["height"] = info.Height
			result["format"] = info.Format
			result["size"] = info.Size
		}
	}
	return result
}

func (h *FileHandler) ExtractPDFText(path string) (string, error) {
	return h.pdfService.ExtractText(path)
}

func (h *FileHandler) StitchImages(inputPaths []string, direction string, gap int, bgColor string, outputPath string) FileResult {
	if len(inputPaths) < 2 {
		return FileResult{Success: false, Message: "至少需要 2 张图片才能拼接"}
	}

	// 确定输出路径
	if outputPath == "" {
		config := h.GetConfig()
		outDir := config.DefaultOutputDir
		if outDir == "" {
			outDir = filepath.Dir(inputPaths[0])
		}
		outputPath = filepath.Join(outDir, "拼接长图.png")
	}

	resultPath, err := h.imageService.StitchImages(services.StitchRequest{
		InputPaths: inputPaths,
		Direction:  direction,
		Gap:        gap,
		BgColor:    bgColor,
		OutputPath: outputPath,
	})
	if err != nil {
		return FileResult{Success: false, Message: err.Error()}
	}

	info, statErr := os.Stat(resultPath)
	if statErr != nil {
		return FileResult{Success: false, Message: fmt.Sprintf("获取文件信息失败: %v", statErr)}
	}

	return FileResult{
		Success: true,
		Message: fmt.Sprintf("拼接完成，共 %d 张图片", len(inputPaths)),
		Path:    resultPath,
		Size:    info.Size(),
	}
}

func (h *FileHandler) LogError(msg string) {
	h.writeLog("ERROR", msg)
}

func (h *FileHandler) LogInfo(msg string) {
	h.writeLog("INFO", msg)
}

func (h *FileHandler) writeLog(level, msg string) {
	exe, _ := os.Executable()
	logDir := filepath.Join(filepath.Dir(exe), "logs")
	if err := os.MkdirAll(logDir, 0755); err != nil {
		return
	}
	logFile := filepath.Join(logDir, time.Now().Format("2006-01-02")+".log")
	f, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return
	}
	defer f.Close()
	fmt.Fprintf(f, "[%s] [%s] %s\n", time.Now().Format("15:04:05"), level, msg)
}

func (h *FileHandler) GetLogDates() []string {
	exe, _ := os.Executable()
	logDir := filepath.Join(filepath.Dir(exe), "logs")
	entries, err := os.ReadDir(logDir)
	if err != nil {
		return []string{}
	}
	var dates []string
	for _, e := range entries {
		if !e.IsDir() && strings.HasSuffix(e.Name(), ".log") {
			dates = append(dates, strings.TrimSuffix(e.Name(), ".log"))
		}
	}
	return dates
}

func (h *FileHandler) GetLogs(date string) string {
	exe, _ := os.Executable()
	logDir := filepath.Join(filepath.Dir(exe), "logs")
	logFile := filepath.Join(logDir, date+".log")
	data, err := os.ReadFile(logFile)
	if err != nil {
		return ""
	}
	return string(data)
}

func (h *FileHandler) GetExeDir() string {
	exe, _ := os.Executable()
	return filepath.Dir(exe)
}

func getConfigPath() string {
	home, _ := os.UserHomeDir()
	return filepath.Join(home, ".xk-config.json")
}

func getShortcutsPath() string {
	home, _ := os.UserHomeDir()
	return filepath.Join(home, ".xk-shortcuts.json")
}

func getRecentPath() string {
	home, _ := os.UserHomeDir()
	return filepath.Join(home, ".xk-recent.json")
}

func getDefaultOutputDir() string {
	home, _ := os.UserHomeDir()
	return filepath.Join(home, "Desktop")
}

func getDefaultShortcuts() []Shortcut {
	return []Shortcut{
		{ID: "pdf-compress", Name: "压缩PDF", Category: "pdf", Icon: "FolderChecked"},
		{ID: "image-compress", Name: "压缩图片", Category: "image", Icon: "FolderChecked"},
		{ID: "image-convert", Name: "图片格式转换", Category: "image", Icon: "Switch"},
		{ID: "excel-csv", Name: "Excel转CSV", Category: "excel", Icon: "Document"},
		{ID: "word-pdf", Name: "Word转PDF", Category: "word", Icon: "Document"},
	}
}