package thumb

import (
	"errors"
	"fmt"
	"image"
	"image/png"
	"path"
	"path/filepath"

	"github.com/disintegration/imaging"

	"github.com/photoprism/photoprism/pkg/clean"
	"github.com/photoprism/photoprism/pkg/fs"
)

// Suffix returns the thumb cache file suffix.
func Suffix(width, height int, opts ...ResampleOption) (result string) {
	method, _, format := ResampleOptions(opts...)

	result = fmt.Sprintf("%dx%d_%s.%s", width, height, ResampleMethods[method], format)

	return result
}

// FileName returns the file name of the thumbnail for the matching size.
func FileName(hash, thumbPath string, width, height int, opts ...ResampleOption) (fileName string, err error) {
	if InvalidSize(width) {
		return "", fmt.Errorf("thumb: width exceeds limit (%d)", width)
	}

	if InvalidSize(height) {
		return "", fmt.Errorf("thumb: height exceeds limit (%d)", height)
	}

	if len(hash) < 4 {
		return "", fmt.Errorf("thumb: file hash is empty or too short (%s)", clean.Log(hash))
	}

	if len(thumbPath) == 0 {
		return "", errors.New("thumb: folder is empty")
	}

	suffix := Suffix(width, height, opts...)
	p := path.Join(thumbPath, hash[0:1], hash[1:2], hash[2:3])

	if err = fs.MkdirAll(p); err != nil {
		return "", err
	}

	fileName = fmt.Sprintf("%s/%s_%s", p, hash, suffix)

	return fileName, nil
}

// ResolvedName returns the file name of the thumbnail for the matching size with all symlinks resolved.
func ResolvedName(hash, thumbPath string, width, height int, opts ...ResampleOption) (fileName string, err error) {
	if fileName, err = FileName(hash, thumbPath, width, height, opts...); err != nil {
		return fileName, err
	} else {
		return fs.Resolve(fileName)
	}
}

// FromCache returns the filename if a thumbnail image with the matching size is in the cache.
func FromCache(imageFilename, hash, thumbPath string, width, height int, opts ...ResampleOption) (fileName string, err error) {
	if len(hash) < 4 {
		return "", fmt.Errorf("thumb: invalid file hash %s", clean.Log(hash))
	}

	if len(imageFilename) < 4 {
		return "", fmt.Errorf("thumb: invalid file name %s", clean.Log(imageFilename))
	}

	if fileName, err = FileName(hash, thumbPath, width, height, opts...); err != nil {
		log.Debugf("thumb: %s in %s (filename)", err, clean.Log(filepath.Base(imageFilename)))
		return "", err
	} else if fileName, err = fs.Resolve(fileName); err != nil {
		return "", ErrNotCached
	} else if fs.FileExistsNotEmpty(fileName) {
		return fileName, nil
	}

	return "", ErrNotCached
}

// FromFile generates a new thumbnail with the requested size, if it does not already exist, and returns its filename.
func FromFile(imageName, hash, thumbPath string, width, height, orientation int, opts ...ResampleOption) (fileName string, err error) {
	if fileName, err = FromCache(imageName, hash, thumbPath, width, height, opts...); err == nil {
		return fileName, err
	} else if !errors.Is(err, ErrNotCached) {
		return "", err
	}

	// Use libvips to generate thumbnails?
	if Library == LibVips {
		fileName, _, err = Vips(imageName, nil, hash, thumbPath, width, height, opts...)
		return fileName, err
	}

	// Generate thumb cache filename.
	fileName, err = FileName(hash, thumbPath, width, height, opts...)

	if err != nil {
		log.Debugf("thumb: %s in %s (filename)", err, clean.Log(filepath.Base(imageName)))
		return "", err
	}

	// Load image from file.
	img, err := Open(imageName, orientation)

	if err != nil {
		log.Debugf("thumb: %s in %s", err, clean.Log(filepath.Base(imageName)))
		return "", err
	}

	// Create thumb from image.
	if _, err = Create(img, fileName, width, height, opts...); err != nil {
		return "", err
	}

	return fileName, nil
}

// Create creates an image thumbnail.
func Create(img image.Image, fileName string, width, height int, opts ...ResampleOption) (result image.Image, err error) {
	if InvalidSize(width) {
		return img, fmt.Errorf("thumb: width has an invalid value (%d)", width)
	}

	if InvalidSize(height) {
		return img, fmt.Errorf("thumb: height has an invalid value (%d)", height)
	}

	result = Resample(img, width, height, opts...)

	var quality imaging.EncodeOption

	if fs.FileType(fileName) == fs.ImagePng {
		quality = imaging.PNGCompressionLevel(png.DefaultCompression)
	} else {
		quality = JpegQuality(width, height).EncodeOption()
	}

	err = imaging.Save(result, fileName, quality)

	if err != nil {
		log.Debugf("thumb: failed to save %s", clean.Log(filepath.Base(fileName)))
		return result, err
	}

	return result, nil
}
