package main

import (
	"flag"
	"fmt"
	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"io/fs"
	"os"
	"path/filepath"
	"strings"

	"github.com/nfnt/resize"
)

type config struct {
	Recursive     bool
	Diff          uint
	Quality uint
	Replace       bool
	StartingPath  string
	PNG bool
	GIF bool
	Quiet bool
		AtLeast	uint
		MaxWidth uint
		MaxHeight uint
		IgnoreSuffix bool

}

type stats struct {
	FilesProcessed uint64
	FilesReplaced  uint64
	StartingBytes  uint64
	EndingBytes    uint64
}

func main() {

	var c config
	flag.BoolVar(&c.Recursive, "recursive", false, "Process folders recursively (default false).")
	flag.UintVar(&c.Diff, "diff", 25, "Percent difference required to replace original image.")
	flag.UintVar(&c.Quality, "quality", 85, "JPG compression quality level.")
	flag.BoolVar(&c.Quiet, "quiet", false, "Less output - don't print per-file detail")
	flag.BoolVar(&c.PNG, "png", false, "Convert PNG files without transparency to JPG if the other criteria are met")
	flag.BoolVar(&c.GIF, "gif", false, "Convert GIF files without transparency to JPG if the other criteria are met")
	flag.UintVar(&c.AtLeast, "atleast", 0, "Ignore images that aren't at least this many kilobytes")
	flag.BoolVar(&c.IgnoreSuffix, "ignoresuffix", false, "Ignore suffix on filenames and attempt to treat everything as a JPG")
	flag.UintVar(&c.MaxWidth, "maxwidth", 0, "Maximum width, scale images bigger to fit within this width. 0 ignores. Won't replace unless it meets the diff threashold.")
	flag.UintVar(&c.MaxHeight, "maxheight", 0, "Maximum height, scale images bigger to fit within this height. 0 ignores. Won't replace until it meets the diff threashold.")
	flag.StringVar(&c.StartingPath, "startingpath", ".", "Start from this path instead of current working dir")
	flag.BoolVar(&c.Replace, "replace", false, "Replace with compressed versions if criteria are met. Otheriwse, just test and report, don't replace any images. (default false)")
	flag.Parse()

	fail := false
	if c.Diff > 99 {
		fmt.Println("Fatal: diff out of range (-99)")
		fail = true
	}
	if c.Quality > 99 {
		fmt.Println("Fatal: compresslevel out of range (1-99)")
		fail = true
	}
	s, err := os.Stat(c.StartingPath)
	if err != nil || !s.IsDir() {
		fmt.Println("Starting path is invalid")
		fail = true
	}
	if fail {
		flag.Usage()
		return
	}

	// Generate list of files to examing
	var filelist []string
	if !c.Recursive {
		d, err := os.ReadDir(c.StartingPath)
		if err != nil {
			fmt.Printf("Error reading path: %s", err.Error())
		}
		for _, f := range d {
			if !f.IsDir() {
				ext := strings.ToLower(filepath.Ext(f.Name()))
				if c.IgnoreSuffix || ext == ".jpg" || ext == ".jpeg" || ext==".png" || ext==".gif" {
					filelist = append(filelist, f.Name())
				}

			}
		}
	} else {
		filepath.WalkDir(c.StartingPath, func(path string, d fs.DirEntry, err error) error {
			ext := strings.ToLower(filepath.Ext(path))
			if !d.IsDir() && (c.IgnoreSuffix || ext == ".jpg" || ext == ".jpeg" || ext==".png" || ext==".gif" ) {
				filelist = append(filelist, path)
			}
			return nil
		})
	}
	var st stats
	for _, f := range filelist {
		st = doSingleImage(f, c, st)
	}
	fmt.Println("\nEnding stats:")
	fmt.Printf("Files processed: %d\nFiles replaced: %d\nStarting Size: %s (%d bytes)\nEnding Size: %s (%d bytes)\n",
		st.FilesProcessed, st.FilesReplaced, SIFormat(st.StartingBytes), st.StartingBytes, SIFormat(st.EndingBytes), st.EndingBytes)
	decrease:=st.StartingBytes - st.EndingBytes
	diff := uint((float64(decrease) / float64(st.StartingBytes)) * 100)
	
	fmt.Printf("Total savings %s (%d bytes) or %d%%\n", SIFormat(decrease), decrease, diff )

}

// Check image for transparency
func Opaque(im image.Image) bool {
    // Check if image has Opaque() method:
    if oim, ok := im.(interface {
        Opaque() bool
    }); ok {
        return oim.Opaque() // It does, call it and return its result!
    }

    // No Opaque() method, we need to loop through all pixels and check manually:
    rect := im.Bounds()
    for y := rect.Min.Y; y < rect.Max.Y; y++ {
        for x := rect.Min.X; x < rect.Max.X; x++ {
            if _, _, _, a := im.At(x, y).RGBA(); a != 0xffff {
                return false // Found a non-opaque pixel: image is non-opaque
            }
        }

    }
    return true // All pixels are opaque, so is the image
}

// doSingleImage processes a single file and updateds the run stats as it goes
func doSingleImage(f string, c config, s stats) stats {
	st, err := os.Stat(f)
	if err != nil {
		fmt.Printf("Error reading file %s: %s\n", f, err.Error())
		return s
	}
	if st.Size() < int64(c.AtLeast)*1024 {
			s.StartingBytes += uint64(st.Size())
			if !c.Quiet {
				fmt.Printf("Ignoring %s as %d bytes are below threshold\n", f, st.Size())
			}
			return s
	}
	in, err := os.Open(f)
	if err != nil {
		fmt.Printf("Error opening file %s: %s\n", f, err.Error())
	}
	defer in.Close()
	orig, err := jpeg.Decode(in)
	if err != nil {
		orig,err=png.Decode(in)
		if err!=nil {
			orig,err=gif.Decode(in)
			if err != nil {
				fmt.Printf("Couldn't decode source image %s: %s\n", f, err.Error())
				return s
			}
		}
	}
	in.Close()
	if !Opaque(orig) {
		if !c.Quiet {
			fmt.Printf("Skipping %s as it has transparancy", f)
		}
	return s
	}
	// Check bounds and resize if necessary
	ores:=orig.Bounds()
	if (c.MaxWidth !=0 && ores.Dx() > int(c.MaxWidth) ) || (c.MaxHeight!=0 && ores.Dy()>int(c.MaxHeight)) {
		orig=resize.Thumbnail(c.MaxWidth, c.MaxHeight, orig, resize.Lanczos3)
		fmt.Printf("Resized from %dx%d - ", ores.Dx(), ores.Dy())
	}
	out, err := os.OpenFile("imageoptimizer.tmp", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, st.Mode())
	if err != nil {
		fmt.Printf("Couldn't open out temprary file: %s\n", err.Error())
		return s
	}
	err = jpeg.Encode(out, orig, &jpeg.Options{Quality: int(c.Quality)})
	if err != nil {
		fmt.Printf("Error re-encoding image %s: %s\n", f, err.Error())
		return s
	}
	out.Close()
	stt, err := os.Stat("imageoptimizer.tmp")
	if err != nil {
		fmt.Printf("Error reading re-compressed temp file: %s\n", err.Error())
		return s
	}
	s.StartingBytes += uint64(st.Size())
	decrease:=st.Size() - stt.Size()
	diff := ((float64(decrease) / float64(st.Size())) * 100)
	if diff > float64(c.Diff) {
		// Would replace
		if c.Replace {
			err = os.Rename(f, "imageoptimizer.replacetmp")
			if err != nil {
				fmt.Printf("Fatal error moving original file %s: %s\n", f, err.Error())
				os.Exit(1)
			}
			err = os.Rename("imageoptimizer.tmp", f)
			if err != nil {
				fmt.Printf("Fatal error replacing original file %s: %s\nOriginal file has been renamed to imageoptimizer.replacetmp", f, err.Error())
				os.Exit(1)
			}
			os.Remove("imageoptimizer.replacetmp")
		}


		s.EndingBytes += uint64(stt.Size())
		s.FilesReplaced++
		if (!c.Quiet) {
		fmt.Printf("Replace %s: From %s (%d bytes) to %s (%d bytes) (%.0f%%)\n",
			f, SIFormat(uint64(st.Size())), st.Size(), SIFormat(uint64(stt.Size())), stt.Size(), diff)
		}
	} else {
		if (!c.Quiet) {
		fmt.Printf("Not Replacing %s: From %s (%d bytes) to %s (%d bytes) (%.0f%%)\n",
			f, SIFormat(uint64(st.Size())), st.Size(), SIFormat(uint64(stt.Size())), stt.Size(), diff)
		}
		s.EndingBytes += uint64(st.Size())
		os.Remove("imageoptimizer.tmp")

	}

	s.FilesProcessed++
	return s
}

// SIFormat prints sizes in a nice human readable way
func SIFormat(num_in uint64) string {
	suffix := "B" //just assume bytes
	num := float64(num_in)
	units := []string{"", "K", "M", "G", "T", "P", "E", "Z"}
	for _, unit := range units {
		if num < 1000.0 {
			return fmt.Sprintf("%3.1f%s%s", num, unit, suffix)
		}
		num = (num / 1000)
	}
	return fmt.Sprintf("%.1f%s%s", num, "Yi", suffix)
}