package main

import (
  "os"
  "errors"
  "io/fs"
  "fmt"
  "path/filepath"
  "strings"
  "image"
  "log"
  "regexp"
  "image/png"
  "github.com/disintegration/gift"
  "lcthw.dev/go/jankifier/filters"
)

func LoadImage(filename string) image.Image {
  reader, err := os.Open(filename)
  if err != nil { log.Fatal(err) }
  defer reader.Close()

  img, _, err := image.Decode(reader)
  if err != nil { log.Fatal(err) }

  return img
}

func SaveImage(filename string, img image.Image) {
  out, err := os.Create(filename)
  if err != nil {
    log.Fatalf("can't write file %s: %v", filename, err)
  }
  defer out.Close()

  err = png.Encode(out, img)
  if err != nil {
    log.Fatalf("can't png encode %s: %v", filename, err)
  }
}

func JankImage(settings Conversion, in_file string, out_file string) {
  src := LoadImage(in_file)
  src_bounds := src.Bounds()
  target_bounds := src_bounds

  if settings.Width > 0 {
    target_bounds.Max.X = settings.Width
  }

  if settings.Height > 0 {
    target_bounds.Max.Y = settings.Height
  }

  fmt.Println("final size is: ", target_bounds.Max.X, target_bounds.Max.Y)

  // only done when shrinking/growing
  presize := gift.Resize(target_bounds.Max.X, target_bounds.Max.Y, gift.NearestNeighborResampling)

  resize := gift.Resize(target_bounds.Max.X / settings.PixelWidth, 0, gift.NearestNeighborResampling)
  posterize := filters.Posterize(uint16(settings.ColorDepth), settings.DitherType)
  upscale := filters.Upscale(target_bounds, settings.PixelWidth)
  sharpen := gift.UnsharpMask(1, 1, 0)

  var g *gift.GIFT

  if target_bounds.Max.X != src_bounds.Max.X || target_bounds.Max.Y != src_bounds.Max.Y {
    g = gift.New(presize, resize, posterize, upscale, sharpen)
  } else {
    g = gift.New(resize, posterize, upscale, sharpen)
  }

  out_img := image.NewNRGBA(g.Bounds(target_bounds))
  g.Draw(out_img, src)

  SaveImage(out_file, out_img)
}

func UnfuckedPathSplit(path string) []string {
	path = filepath.ToSlash(path)
	// WARN: have to use strings.Split because fsnotify uses /, even on windows
	return strings.Split(path, "/")[1:]
}

func SplitPathExt(path string) (string, string, bool) {
	split_path := UnfuckedPathSplit(path)
	source_name := strings.Join(split_path, "/") // Render wants / even on windows

	ext := filepath.Ext(source_name)
	source_name, found := strings.CutSuffix(source_name, ext)
	return source_name, ext, found
}

func RePrefixPath(path string, new_prefix string) string {
	split_path := UnfuckedPathSplit(path)

	prefixed_path := append([]string{new_prefix}, split_path...)

	res := filepath.Join(prefixed_path...)
	return filepath.ToSlash(res)
}

func SamePath(a string, b string) bool {
	return filepath.ToSlash(a) == filepath.ToSlash(b)
}

func MkdirPath(target_path string) error {
	target_dir := filepath.Dir(target_path)
	_, err := os.Stat(target_dir)

	if os.IsNotExist(err) {
		log.Println("MAKING: ", target_dir)
		err = os.MkdirAll(target_dir, 0750)

		if err != nil {
          log.Fatal("making path to %s: %v", target_dir, err)
		}
	}

	return nil
}

func Included(config Settings, path string) bool {
  _, ext, found := SplitPathExt(path)
  if !found { return false }

  for _, include_ext := range config.Include {
    if include_ext == ext {
      return true
    }
  }

  return false
}

func GetConversion(config Settings, path string) Conversion {
  path = RePrefixPath(path, "")
  for key, conversion := range config.Exceptions {
    match, err := regexp.MatchString(key, path)
    if err != nil { log.Fatalf("problem matching regex %s: %v", key, err) }

    if match {
      return conversion
    }
  }

  return config.Base
}

func HasChanged(old_info fs.FileInfo, new_path string) bool {
  new_info, err := os.Stat(new_path)

  if errors.Is(err, fs.ErrNotExist) {
    return true
  } else if err != nil {
    log.Printf("!!!! can't stat target: %s: %v", new_path, err)
    return false
  }

   return old_info.ModTime().After(new_info.ModTime())
}

func RenderImages(config Settings, force bool) error {
  err := filepath.WalkDir(config.Source,
    func(path string, d fs.DirEntry, err error) error {
      path = filepath.ToSlash(path)

      if !d.IsDir() && Included(config, path) {
        target := RePrefixPath(path, config.Target)

        err = MkdirPath(target)
        if err != nil {
          log.Fatalf("failed to make path %s: %v", path, err)
        }

        fmt.Println("FILE: ", path, "TARGET:", target)
        convert := GetConversion(config, path)

        path_info, err := d.Info()
        if err != nil {
          log.Fatalf("failed to stat %s: %v", path, err)
        }

        if force || HasChanged(path_info, target) {
          JankImage(convert, path, target)
        }
      } else {
        fmt.Println("SKIP:", path)
      }

      return nil
  })

  return err
}