path: root/image.go

package main

import (
	"bytes"
	"errors"
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/dialog"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/widget"
	"image"
	"image/color"
	_ "image/gif"
	"image/jpeg"
	_ "image/png"
	"io"
	"log"
	"math"
	"net/url"
	"random.chars.jp/git/image-board/api"
	"random.chars.jp/git/image-board/store"
	"strings"
	"time"
)

var imageSwitchCallbacks []func()

var imageMenu = &fyne.MenuItem{
	ChildMenu: &fyne.Menu{
		Label: "Image",
		Items: []*fyne.MenuItem{
			{
				Label: "Upload",
				Action: func() {
					if remote == nil {
						go dialog.ShowInformation("Not connected", "Not connected to a remote.", window)
						return
					}
					go fileSelectUpload()
				},
			},
		},
	},
	Label: "Image",
}

var groupItem *fyne.MenuItem

func groupInit() *fyne.MenuItem {
	groupItem = &fyne.MenuItem{
		Label: "   Group",
		Action: func() {
			groupItem.Checked = !groupItem.Checked
			setCollapseCategory(groupItem.Checked)
			if inPageView {
				setPage(currentPage)
			}
		},
		Checked: true,
	}
	return groupItem
}

var (
	currentPage int
	tp          *int
)
var (
	imageCache = make(map[string]*imageEntry)
	groupCache = make(map[string][]store.Image)
	pageCache  = make(map[int][]store.Image)
)

// imageMeta represents image metadata not included in the API payload.
type imageMeta struct {
	owner api.UserPayload
	tags  map[string][]string
}

// imageEntry represents a store.Image entry for displaying on GUI.
type imageEntry struct {
	image   store.Image
	preview *fyne.StaticResource
	file    *fyne.StaticResource
	meta    *imageMeta
}

// resource returns resource with optional preview.
func (i *imageEntry) resource(preview bool) (*fyne.StaticResource, error) {
	if i == nil {
		return nil, errors.New("did not get image entry")
	}
	switch preview {
	case true:
		if i.preview != nil {
			return i.preview, nil
		} else {
			if i.file != nil {
				log.Printf("Making preview from full image of %s.", i.image.Snowflake)
				if img, _, err := image.Decode(bytes.NewReader(i.file.Content())); err != nil {
					return nil, err
				} else {
					w := bytes.NewBuffer(nil)
					if err = jpeg.Encode(w, store.MakePreview(img), &jpeg.Options{Quality: 100}); err != nil {
						return nil, err
					}
					i.preview = fyne.NewStaticResource(i.image.Snowflake+"-preview.jpg", w.Bytes())
					return i.preview, nil
				}
			}
		}
	case false:
		if i.file != nil {
			return i.file, nil
		}
	}

	if res, err := remote.ImageFile(i.image.Snowflake, preview); err != nil {
		return nil, err
	} else {
		switch preview {
		case true:
			i.preview = fyne.NewStaticResource(i.image.Snowflake+"-preview.jpg", res)
			return i.preview, nil
		case false:
			i.file = fyne.NewStaticResource(i.image.Snowflake+"."+i.image.Type, res)
			return i.file, nil
		}
	}

	return nil, nil
}

// metadata returns imageEntry metadata.
func (i *imageEntry) metadata() (*imageMeta, error) {
	if i.meta == nil {
		if err := i.fetchMetadata(); err != nil {
			return nil, err
		}
	}
	return i.meta, nil
}

// fetchMetadata fetches metadata from remote.
func (i *imageEntry) fetchMetadata() error {
	i.meta = new(imageMeta)
	// Fetch owner info
	if owner, err := remote.User(i.image.User); err != nil {
		return err
	} else {
		i.meta.owner = owner
	}

	// Fetch tags
	i.meta.tags = make(map[string][]string)
	if t, err := remote.ImageTag(i.image.Snowflake); err != nil {
		return err
	} else {
		for _, tag := range t {
			// Group by tag type
			var tagInfo store.Tag
			if tagInfo, err = remote.TagInfo(tag); err != nil {
				return err
			} else {
				i.meta.tags[tagInfo.Type] = append(i.meta.tags[tagInfo.Type], tag)
			}
		}
	}

	return nil
}

func dropImageCache() {
	log.Print("Dropping image cache.")
	imageCache = make(map[string]*imageEntry)
}

func dropGroupCache(flake string) {
	log.Printf("Dropping image %s group cache.", flake)
	if group, ok := groupCache[flake]; !ok {
		return
	} else {
		for _, img := range group {
			delete(groupCache, img.Snowflake)
		}
	}
}

func dropPageCache(page int) {
	tp = nil
	if page < 0 {
		log.Printf("Dropping page cache.")
		pageCache = make(map[int][]store.Image)
	} else {
		log.Printf("Dropping page %v cache.", page)
		delete(pageCache, page)
	}
}

func getPage(entry int) ([]store.Image, error) {
	if page, ok := pageCache[entry]; ok {
		return page, nil
	}

	if page, err := remote.ImagePageImage(entry); err != nil {
		return nil, err
	} else {
		pageCache[entry] = page
		return page, nil
	}
}

func totalPages() (int, error) {
	if tp == nil {
		if t, err := remote.ImagePages(); err != nil {
			return 0, err
		} else {
			tp = &t
		}
	}
	return *tp, nil
}

func getImage(image store.Image) *imageEntry {
	if entry, ok := imageCache[image.Snowflake]; !ok {
		imageCache[image.Snowflake] = &imageEntry{image: image}
		return imageCache[image.Snowflake]
	} else {
		return entry
	}
}

func getImageGroup(image store.Image) (entry *imageEntry, group []*imageEntry) {
	if g, ok := groupCache[image.Snowflake]; !ok {
		s := time.Now()
		if gr, err := remote.ImageGroup(image.Snowflake); err != nil {
			log.Printf("Error getting group of image %s, %s", image.Snowflake, err)
			return nil, nil
		} else {
			e := time.Now().Sub(s)
			grFlakes := make([]string, len(gr))
			entry = getImage(image)
			group = make([]*imageEntry, len(gr))
			for i, img := range gr {
				group[i] = getImage(img)
				grFlakes[i] = img.Snowflake
				groupCache[img.Snowflake] = gr
			}
			log.Printf("Fetched group %s in %s.", strings.Join(grFlakes, ", "), e)
		}
	} else {
		entry = getImage(image)
		group = make([]*imageEntry, len(g))
		for i, img := range g {
			group[i] = getImage(img)
		}
	}
	return
}

func makeImageBorder(data []byte, c color.Color, thickness float64) (image.Image, error) {
	var img image.Image
	if i, _, err := image.Decode(bytes.NewReader(data)); err != nil {
		return nil, err
	} else {
		img = i
	}

	var width int
	if x, y := img.Bounds().Dx(), img.Bounds().Dy(); x >= y {
		width = int(math.Floor(float64(x) * thickness / 2.0))
	} else {
		width = int(math.Floor(float64(y) * thickness / 2.0))
	}

	newImg := image.NewRGBA64(image.Rectangle{
		Min: img.Bounds().Min,
		Max: img.Bounds().Max.Add(image.Point{
			X: width * 2,
			Y: width * 2,
		}),
	})
	for x := 0; x < newImg.Bounds().Dx(); x++ {
		for y := 0; y < newImg.Bounds().Dy(); y++ {
			if x < width || x > width+img.Bounds().Dx() || y < width || y > width+img.Bounds().Dy() {
				newImg.Set(x, y, c)
				continue
			}
			newImg.Set(x, y, img.At(x-width, y-width))
		}
	}

	return newImg, nil
}

func makeGallery(images []store.Image) (*fyne.Container, error) {
	var loadImage func(gallery *fyne.Container, m store.Image) error
	switch getCollapseCategory() {
	case false:
		loadImage = func(gallery *fyne.Container, m store.Image) error {
			img := &canvas.Image{
				FillMode:  canvas.ImageFillContain,
				ScaleMode: canvas.ImageScaleFastest,
			}
			if res, err := getImage(m).resource(true); err != nil {
				return err
			} else {
				img.Resource = res
			}

			gallery.Add(newImageButton(img, m))
			log.Printf("Added image %s to view.", m.Snowflake)
			return nil
		}
	case true:
		loadImage = func(gallery *fyne.Container, m store.Image) error {
			entry, group := getImageGroup(m)
			if len(group) == 0 || m.Snowflake != group[0].image.Snowflake {
				log.Printf("Skipped secondary image %s.", m.Snowflake)
				return nil
			}

			img := &canvas.Image{
				FillMode:  canvas.ImageFillContain,
				ScaleMode: canvas.ImageScaleFastest,
			}
			if res, err := entry.resource(true); err != nil {
				return err
			} else {
				if len(group) == 1 {
					img.Resource = res
				} else {
					var i image.Image
					if i, err = makeImageBorder(res.Content(), color.RGBA{R: 0x00, G: 0x00, B: 0xff, A: 0xff}, 0.03); err != nil {
						return err
					} else {
						img.Image = i
					}
				}
			}

			gallery.Add(newImageButton(img, m))
			log.Printf("Added primary image %s to view.", m.Snowflake)
			return nil
		}
	}

	done, value := progress("Loading", "Fetching images...")
	defer done()
	gallery := container.NewGridWrap(fyne.Size{
		Width:  128,
		Height: 128,
	})
	for i, img := range images {
		if err := loadImage(gallery, img); err != nil {
			return nil, err
		}
		go value(float64(i+1) / float64(len(images)))
	}
	return gallery, nil
}

func makePageView(page int) (*fyne.Container, error) {
	if remote == nil {
		return nil, errors.New("attempting to make page view with nil remote")
	}

	s := time.Now()
	var images []store.Image
	if err := func() error {
		defer loading("Loading", "Getting page...")()
		if i, err := getPage(page); err != nil {
			return err
		} else {
			images = i
			return nil
		}
	}(); err != nil {
		return nil, err
	}
	var gallery *fyne.Container
	if g, err := makeGallery(images); err != nil {
		return nil, err
	} else {
		gallery = g
	}
	log.Printf("Fetched page %v in %s.", page, time.Now().Sub(s).String())

	sc := container.NewVScroll(gallery)
	sc.SetMinSize(fyne.Size{
		Width:  116,
		Height: 200,
	})

	var fwd *widget.Button
	fwd = widget.NewButton("Previous", func() {
		fwd.Disable()
		setPage(page - 1)
	})
	if page == 0 {
		fwd.Disable()
	}

	var aft *widget.Button
	aft = widget.NewButton("Next", func() {
		aft.Disable()
		setPage(page + 1)
	})

	if err := func() error {
		defer loading("Loading", "Getting total pages...")()
		if t, err := totalPages(); err != nil {
			return err
		} else if page == t-1 {
			aft.Disable()
		}
		return nil
	}(); err != nil {
		return nil, err
	}

	p := container.NewBorder(nil, nil,
		fwd,
		aft,
	)

	border := container.New(layout.NewBorderLayout(nil, p, nil, nil),
		p, sc)

	return border, nil
}

func setPage(page int) {
	if gallery, err := makePageView(page); err != nil {
		dialog.ShowError(err, window)
	} else {
		giantLock.Lock()
		defer giantLock.Unlock()
		setContent(gallery)
		inPageView = true
		currentPage = page
	}
}

func makeImageView(image store.Image) (*fyne.Container, error) {
	if remote == nil {
		return nil, errors.New("attempting to make image with nil remote")
	}

	entry, group := getImageGroup(image)
	img := &canvas.Image{
		FillMode:  canvas.ImageFillContain,
		ScaleMode: canvas.ImageScaleSmooth,
	}

	s := time.Now()
	if res, err := entry.resource(false); err != nil {
		return nil, err
	} else {
		img.Resource = res
	}
	log.Printf("Fetched image %s in %s.", image.Snowflake, time.Now().Sub(s).String())

	var metadata *imageMeta
	s = time.Now()
	if meta, err := entry.metadata(); err != nil {
		return nil, err
	} else {
		metadata = meta
	}
	log.Printf("Fetched image %s metadata in %s.", image.Snowflake, time.Now().Sub(s).String())

	info := widget.NewForm(
		widget.NewFormItem("ID", newLink(image.Snowflake, func() { window.Clipboard().SetContent(image.Snowflake) })),
		widget.NewFormItem("Uploader", newLink(metadata.owner.Username, func() { displayUserInfo(metadata.owner) })),
	)
	if image.Source != "" {
		u, err := url.Parse(image.Source)
		if err != nil {
			return nil, err
		}
		src := widget.NewHyperlink(u.Host, u)
		src.Wrapping = fyne.TextWrapWord
		info.Append("Source", src)
	}

	cL := widget.NewLabel(image.Commentary)
	cL.Wrapping = fyne.TextWrapBreak
	ctL := widget.NewLabel(image.CommentaryTranslation)
	ctL.Wrapping = fyne.TextWrapBreak
	if image.Commentary != "" {
		info.Append("Commentary", cL)
		if image.CommentaryTranslation != "" {
			info.Append("Translation", ctL)
		}
	} else {
		if image.CommentaryTranslation != "" {
			info.Append("Translated Commentary", ctL)
		}
	}

	info.Append("Download", widget.NewButton(strings.ToUpper(image.Type), func() {
		go fileSave(image.Snowflake, image.Type, img.Resource.Content())
	}))

	// Make tag list
	makeTags := func(tagType string) *fyne.Container {
		a := container.NewVBox()
		for _, tag := range metadata.tags[tagType] {
			func(tag string) { a.Add(newLink(tag, func() { tagSearch([]string{tag}, func() { setImage(image) }) })) }(tag)
		}
		return a
	}
	ts := widget.NewForm()
	appendTags := func(tagType string) {
		a := makeTags(tagType)
		if len(a.Objects) > 0 {
			ts.Append(strings.Title(tagType), a)
		}
	}
	appendTags(store.ArtistType)
	appendTags(store.CharacterType)
	appendTags(store.CopyrightType)
	appendTags(store.MetaType)
	appendTags(store.GenericType)

	sc := container.NewVScroll(container.NewBorder(nil, nil, nil, widget.NewSeparator(),
		container.NewVBox(info, container.NewBorder(widget.NewSeparator(), nil, nil, nil, ts))))

	br := container.NewBorder(nil, nil, sc, nil,
		img, sc)

	const (
		retract = "<<"
		expand  = ">>"
	)
	var rt *widget.Button
	rt = widget.NewButton(retract, func() {
		rt.Disable()
		defer rt.Enable()
		defer br.Refresh()
		switch rt.Text {
		case retract:
			sc.Hide()
			rt.SetText(expand)
		case expand:
			sc.Show()
			rt.SetText(retract)
		}
	})

	lf := container.NewBorder(nil, nil, rt, nil,
		br)

	var fwd *widget.Button
	fwd = widget.NewButton("Back", func() {
		fwd.Disable()
		setPage(currentPage)
	})

	var diag dialog.Dialog

	var newTags []string
	var cnf *widget.Button
	cnf = widget.NewButton("Configure", func() {
		cnf.Disable()
		src := widget.NewFormItem("Source", widget.NewEntry())
		src.Widget.(*widget.Entry).Text = image.Source
		prt := widget.NewFormItem("Parent", widget.NewEntry())
		prt.Widget.(*widget.Entry).Text = image.Parent
		c := widget.NewFormItem("Commentary", widget.NewMultiLineEntry())
		c.Widget.(*widget.Entry).Text = image.Commentary
		ct := widget.NewFormItem("Commentary Translation", widget.NewMultiLineEntry())
		ct.Widget.(*widget.Entry).Text = image.CommentaryTranslation
		actuate := func(submit bool) {
			var (
				source                = "\000"
				parent                = "\000"
				commentary            = "\000"
				commentaryTranslation = "\000"
			)

			var msg string
			if src.Widget.(*widget.Entry).Text != image.Source {
				if msg != "" {
					msg += ", "
				}
				msg += "source"

				source = src.Widget.(*widget.Entry).Text

				// Update cache
				entry.image.Source = source
			}
			if prt.Widget.(*widget.Entry).Text != image.Parent {
				if msg != "" {
					msg += ", "
				}
				msg += "parent"

				parent = prt.Widget.(*widget.Entry).Text

				// Update cache
				entry.image.Parent = parent
				dropGroupCache(parent)
			}
			if c.Widget.(*widget.Entry).Text != image.Commentary {
				if msg != "" {
					msg += ", "
				}
				msg += "commentary"

				commentary = c.Widget.(*widget.Entry).Text

				// Update cache
				entry.image.Commentary = commentary
			}
			if ct.Widget.(*widget.Entry).Text != image.CommentaryTranslation {
				if msg != "" {
					msg += ", "
				}
				msg += "commentary translation"

				commentaryTranslation = ct.Widget.(*widget.Entry).Text

				// Update cache
				entry.image.CommentaryTranslation = commentaryTranslation
			}

			if submit {
				defer loading("Submitting", "Waiting for server...")()
				s = time.Now()
				if err := remote.ImageUpdate(image.Snowflake, source, parent, commentary, commentaryTranslation); err != nil {
					go dialog.ShowError(err, window)
				}
				log.Printf("Updated image %s %s in %s.", image.Snowflake, msg, time.Now().Sub(s))

				if newTags != nil {
					curTags :=
						append(metadata.tags[store.ArtistType],
							append(metadata.tags[store.CharacterType],
								append(metadata.tags[store.CopyrightType],
									append(metadata.tags[store.MetaType],
										metadata.tags[store.GenericType]...)...)...)...)
					var (
						additions  []string
						deletions  []string
						curTagsMap = make(map[string]bool, len(curTags))
					)

					for _, tag := range curTags {
						curTagsMap[tag] = false
					}
					for _, tag := range newTags {
						if _, ok := curTagsMap[tag]; !ok {
							// If tag doesn't exist in current tags mark it as an addition
							additions = append(additions, tag)
						} else {
							// If tag exists in current tags mark it as not deleted
							curTagsMap[tag] = true
						}
					}
					for tag, keep := range curTagsMap {
						if !keep {
							deletions = append(deletions, tag)
						}
					}

					for _, tag := range deletions {
						s = time.Now()
						if err := remote.ImageTagRemove(image.Snowflake, tag); err != nil {
							go dialog.ShowError(err, window)
						}
						log.Printf("Removed tag %s from image %s in %s.", tag, image.Snowflake, time.Now().Sub(s))
					}
					for _, tag := range additions {
						s = time.Now()
						if err := remote.ImageTagAdd(image.Snowflake, tag); err != nil {
							go dialog.ShowError(err, window)
						}
						log.Printf("Added tag %s to image %s in %s.", tag, image.Snowflake, time.Now().Sub(s))
					}

					if err := entry.fetchMetadata(); err != nil {
						go dialog.ShowError(err, window)
					}
				}

				// Refresh image view
				setImage(entry.image)
			}
		}

		te := widget.NewFormItem("Tags", widget.NewButton("Edit", func() {
			go func() {
				newTags = tagSelectDialog(
					append(metadata.tags[store.ArtistType],
						append(metadata.tags[store.CharacterType],
							append(metadata.tags[store.CopyrightType],
								append(metadata.tags[store.MetaType],
									metadata.tags[store.GenericType]...)...)...)...), true)
			}()
		}))

		del := widget.NewFormItem("Delete", widget.NewButton("Delete image", func() {
			go dialog.ShowConfirm("Confirmation", "Are you sure you want to destroy this image?", func(okay bool) {
				if okay {
					s = time.Now()
					if err := remote.ImageDestroy(image.Snowflake); err != nil {
						go dialog.ShowError(err, window)
						return
					}
					dropPageCache(-1)
					log.Printf("Destroyed image %s in %s.", image.Snowflake, time.Now().Sub(s))
					diag.Hide()
					setPage(currentPage)
				}
			}, window)
		}))

		diag = dialog.NewForm("Configure image", "Submit", "Cancel",
			[]*widget.FormItem{src, prt, c, ct, te, del},
			actuate, window)
		diag.Resize(fyne.Size{
			Width: 512,
		})
		diag.Show()
		cnf.Enable()
	})

	if image.User != this.ID && !this.Privileged {
		cnf.Disable()
	}

	ops := container.NewBorder(nil, nil, fwd, cnf)
	var border *fyne.Container

	switch len(group) == 1 {
	case true:
		border = container.NewBorder(ops, nil, nil, nil,
			container.NewBorder(widget.NewSeparator(), nil, nil, nil, lf))
	case false:
		var ent int
		for i, im := range group {
			if im.image.Snowflake == image.Snowflake {
				ent = i
			}
		}
		b := widget.NewButton("Previous", func() {
			setImage(group[ent-1].image)
		})
		r := widget.NewButton("Next", func() {
			setImage(group[ent+1].image)
		})
		if ent == 0 {
			b.Disable()
		}
		if ent == len(group)-1 {
			r.Disable()
		}

		var (
			groupView    *container.Scroll
			groupViewBox = container.NewGridWrap(fyne.Size{Width: 128, Height: 128})
		)
		groupView = container.NewHScroll(groupViewBox)
		for _, e := range group {
			eImg := &canvas.Image{
				FillMode:  canvas.ImageFillContain,
				ScaleMode: canvas.ImageScaleFastest,
			}
			if res, err := e.resource(true); err != nil {
				return nil, err
			} else {
				if e.image.Snowflake == entry.image.Snowflake {
					if i, err := makeImageBorder(res.Content(), color.RGBA{R: 0x00, G: 0x00, B: 0xff, A: 0xff}, 0.03); err != nil {
						return nil, err
					} else {
						eImg.Image = i
					}
				} else {
					eImg.Resource = res
				}
			}

			groupViewBox.Add(newImageButton(eImg, e.image))
			log.Printf("Added image %s to group view of %s.", e.image.Snowflake, entry.image.Snowflake)
		}
		groupViewDiag := dialog.NewCustom("Image group", "Close", groupView, window)
		groupViewDiag.Resize(fyne.Size{Width: window.Content().Size().Width - 16})
		groupView.SetMinSize(fyne.Size{Height: 128})

		var groupViewToggle *widget.Button
		groupViewToggle = widget.NewButton("Show group", func() {
			groupViewDiag.Show()
		})
		ops.Add(groupViewToggle)
		registerImageSwitchCallback(func() {
			groupViewDiag.Hide()
		})

		border = container.NewBorder(ops, container.NewBorder(nil, nil, b, r), nil, nil,
			container.NewBorder(widget.NewSeparator(), nil, nil, nil, lf))
	}

	return border, nil
}

func setImage(image store.Image) {
	defer loading("Loading", "Loading image...")()
	func() {
		giantLock.Lock()
		defer giantLock.Unlock()

		// Fire callbacks
		for i, f := range imageSwitchCallbacks {
			log.Printf("Firing image switch callback %v.", i)
			f()
		}
		imageSwitchCallbacks = []func(){}
	}()

	if img, err := makeImageView(image); err != nil {
		dialog.ShowError(err, window)
	} else {
		setContent(img)
	}
}

func registerImageSwitchCallback(f func()) {
	giantLock.Lock()
	defer giantLock.Unlock()

	log.Printf("Registering image switch callback.")
	imageSwitchCallbacks = append(imageSwitchCallbacks, f)
}

func addImage(path string, reader io.ReadCloser) {
	s := time.Now()
	if img, err := remote.ImageAdd(reader); err != nil {
		log.Printf("Error adding image file %s, %s", path, err)
		go dialog.ShowError(err, window)
		return
	} else if img.Snowflake == "" {
		log.Printf("Image %s upload failure.", path)
		go dialog.ShowInformation("Image upload failure",
			"Wasn't able to upload the image, report this to your system administrator if this keeps happening.", window)
		return
	} else {
		log.Printf("Uploaded image %s in %s.", img.Snowflake, time.Now().Sub(s))
		dropPageCache(-1)
		go setImage(img)
	}
}

func makeReturnFunc() func() {
	if inPageView {
		return func() { setPage(currentPage) }
	}
	o := window.Content()
	return func() { window.SetContent(o) }
}