main.go

package main

import (
	"bytes"
	"context"
	"embed"
	"encoding/base64"
	"fmt"
	"image"
	"image/png"
	"os"
	"path/filepath"
	"strings"

	"github.com/lucasb-eyer/go-colorful"
	"github.com/setanarut/layerbuilder-app/layerbuilder"
	"github.com/setanarut/layerbuilder-app/layerbuilder/utils"
	"github.com/wailsapp/wails/v2"
	"github.com/wailsapp/wails/v2/pkg/options"
	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
	"github.com/wailsapp/wails/v2/pkg/runtime"
)

//go:embed index.html
var assets embed.FS

func main() {
	app := NewApp()

	err := wails.Run(&options.App{
		Title:  "LayerBuilder",
		Width:  900,
		Height: 700,
		AssetServer: &assetserver.Options{
			Assets: assets,
		},
		BackgroundColour: &options.RGBA{R: 18, G: 18, B: 18, A: 1},
		OnStartup:        app.startup,
		Bind: []any{
			app,
		},
	})
	if err != nil {
		println("Error:", err.Error())
	}
}

// App struct
type App struct {
	ctx context.Context
}

type BuildOptions struct {
	NumSuperpixels int
	LLENeighbors   int
	PixelNeighbors int
	Lm             float64
	Lr             float64
	Lu             float64
}

// NewApp creates a new App application struct
func NewApp() *App {
	return &App{}
}

// startup is called when the app starts. The context is saved
// so we can call the runtime methods
func (a *App) startup(ctx context.Context) {
	a.ctx = ctx
}

// SelectOutputDir opens a native directory picker dialog and returns the selected path.
func (a *App) SelectOutputDir() string {
	dir, err := runtime.OpenDirectoryDialog(a.ctx, runtime.OpenDialogOptions{
		Title: "Select output folder",
	})
	if err != nil {
		return ""
	}
	return dir
}

// DefaultDesktopDir returns ~/Desktop when available, otherwise the home directory.
func (a *App) DefaultDesktopDir() string {
	home, err := os.UserHomeDir()
	if err != nil || home == "" {
		return ""
	}
	desktop := filepath.Join(home, "Desktop")
	if st, err := os.Stat(desktop); err == nil && st.IsDir() {
		return desktop
	}
	if st, err := os.Stat(home); err == nil && st.IsDir() {
		return home
	}
	return ""
}

// ExtractPalette decodes a base64 PNG/JPG image and extracts N dominant colors.
// Returns a slice of hex color strings e.g. ["#a1b2c3", ...]
func (a *App) ExtractPalette(imageBase64 string, count int) ([]string, error) {
	img, err := decodeBase64Image(imageBase64)
	if err != nil {
		return nil, fmt.Errorf("failed to decode image: %w", err)
	}

	palette := utils.ExtractPalette(img, count, utils.PaletteMethodDominantColor)
	utils.SortPaletteByBrightness(palette)

	return colorsToHex(palette), nil
}

// SortPaletteByBrightness sorts hex colors from darkest to brightest.
func (a *App) SortPaletteByBrightness(hexColors []string) ([]string, error) {
	palette, err := hexToPalette(hexColors)
	if err != nil {
		return nil, fmt.Errorf("failed to parse palette colors: %w", err)
	}

	utils.SortPaletteByBrightness(palette)
	return colorsToHex(palette), nil
}

// ProcessImage decodes a base64 image, builds layers with the given hex palette,
// and saves outputs to outputDir based on saveMode ("seq" or "kra").
func (a *App) ProcessImage(imageBase64 string, hexColors []string, outputDir string, opt BuildOptions, saveMode string) error {
	if outputDir == "" {
		return fmt.Errorf("output folder not selected")
	}

	img, err := decodeBase64Image(imageBase64)
	if err != nil {
		return fmt.Errorf("failed to decode image: %w", err)
	}

	palette, err := hexToPalette(hexColors)
	if err != nil {
		return fmt.Errorf("failed to parse palette colors: %w", err)
	}

	utils.SortPaletteByBrightness(palette)

	builder := layerbuilder.NewLayerBuilder(img, palette)
	defaultOpt := layerbuilder.OptionsFromSize(img.Bounds().Size())
	finalOpt := layerbuilder.Options{
		NumSuperpixels: opt.NumSuperpixels,
		LLENeighbors:   opt.LLENeighbors,
		PixelNeighbors: opt.PixelNeighbors,
		Lm:             opt.Lm,
		Lr:             opt.Lr,
		Lu:             opt.Lu,
	}
	if finalOpt.NumSuperpixels <= 0 {
		finalOpt.NumSuperpixels = defaultOpt.NumSuperpixels
	}
	if finalOpt.LLENeighbors <= 0 {
		finalOpt.LLENeighbors = defaultOpt.LLENeighbors
	}
	if finalOpt.PixelNeighbors <= 0 {
		finalOpt.PixelNeighbors = defaultOpt.PixelNeighbors
	}
	if finalOpt.Lm <= 0 {
		finalOpt.Lm = defaultOpt.Lm
	}
	if finalOpt.Lr <= 0 {
		finalOpt.Lr = defaultOpt.Lr
	}
	if finalOpt.Lu <= 0 {
		finalOpt.Lu = defaultOpt.Lu
	}

	builder.Build(finalOpt)

	recon := builder.Reconstruct(builder.GrayLayers())
	rgbaLayers := builder.RGBALayers()

	switch strings.ToLower(strings.TrimSpace(saveMode)) {
	case "kra":
		kraLayers := make([]image.Image, len(rgbaLayers))
		for i := range rgbaLayers {
			kraLayers[i] = rgbaLayers[len(rgbaLayers)-1-i]
		}
		kraPath := filepath.Join(outputDir, "layers.kra")
		if err := utils.WriteKRA(kraPath, kraLayers); err != nil {
			return fmt.Errorf("failed to write kra file: %w", err)
		}
	case "", "seq":
		if err := utils.SaveImage(recon, filepath.Join(outputDir, "recon.png")); err != nil {
			return fmt.Errorf("failed to save recon image: %w", err)
		}
		if err := utils.SavePalette(palette, 64, filepath.Join(outputDir, "palette.png")); err != nil {
			return fmt.Errorf("failed to save palette image: %w", err)
		}
		if err := utils.SaveRgbaImages(rgbaLayers, outputDir+"/"); err != nil {
			return fmt.Errorf("failed to save rgba sequence: %w", err)
		}
	default:
		return fmt.Errorf("unsupported save mode: %s", saveMode)
	}

	return nil
}

// --- helpers ---

func decodeBase64Image(b64 string) (image.Image, error) {
	// Strip data URL prefix if present (e.g. "data:image/png;base64,...")
	if idx := strings.Index(b64, ","); idx != -1 {
		b64 = b64[idx+1:]
	}
	data, err := base64.StdEncoding.DecodeString(b64)
	if err != nil {
		return nil, err
	}
	img, _, err := image.Decode(bytes.NewReader(data))
	return img, err
}

func colorsToHex(palette []colorful.Color) []string {
	result := make([]string, len(palette))
	for i, c := range palette {
		r, g, b, _ := c.RGBA()
		result[i] = fmt.Sprintf("#%02x%02x%02x", r>>8, g>>8, b>>8)
	}
	return result
}

func hexToPalette(hexColors []string) ([]colorful.Color, error) {
	palette := make([]colorful.Color, 0, len(hexColors))
	for _, h := range hexColors {
		h = strings.TrimPrefix(h, "#")
		if len(h) != 6 {
			return nil, fmt.Errorf("invalid color: #%s", h)
		}
		var r, g, b uint8
		_, err := fmt.Sscanf(h, "%02x%02x%02x", &r, &g, &b)
		if err != nil {
			return nil, err
		}
		palette = append(palette, colorful.Color{
			R: float64(r) / 255.0,
			G: float64(g) / 255.0,
			B: float64(b) / 255.0,
		})
	}
	return palette, nil
}

// ThumbnailBase64 creates a small PNG thumbnail from a base64 image (max 300px wide)
// and returns it as a base64 data URL for preview.
func (a *App) ThumbnailBase64(imageBase64 string) (string, error) {
	img, err := decodeBase64Image(imageBase64)
	if err != nil {
		return "", err
	}

	bounds := img.Bounds()
	w := bounds.Dx()
	h := bounds.Dy()
	maxW := 300

	var thumb image.Image
	if w > maxW {
		newH := h * maxW / w
		dst := image.NewRGBA(image.Rect(0, 0, maxW, newH))
		// simple nearest-neighbor scale
		for y := 0; y < newH; y++ {
			for x := 0; x < maxW; x++ {
				sx := x * w / maxW
				sy := y * h / newH
				dst.Set(x, y, img.At(sx+bounds.Min.X, sy+bounds.Min.Y))
			}
		}
		thumb = dst
	} else {
		thumb = img
	}

	var buf bytes.Buffer
	if err := png.Encode(&buf, thumb); err != nil {
		return "", err
	}
	return "data:image/png;base64," + base64.StdEncoding.EncodeToString(buf.Bytes()), nil
}