package main

import (
	"errors"
	"fmt"
	"io"
	"os"
	"strings"
	"unique"

	"hakurei.app/internal/pkg"
	"hakurei.app/internal/rosa"
)

// commandInfo implements the info subcommand.
func commandInfo(
	cm *cache,
	args []string,
	w io.Writer,
	writeStatus bool,
	r *rosa.Report,
) (err error) {
	if len(args) == 0 {
		for _, h := range rosa.Native().CollectAll() {
			fmt.Println(h)
		}
		return nil
	}

	// recovered by HandleAccess
	mustPrintln := func(a ...any) {
		if _, _err := fmt.Fprintln(w, a...); _err != nil {
			panic(_err)
		}
	}
	mustPrint := func(a ...any) {
		if _, _err := fmt.Fprint(w, a...); _err != nil {
			panic(_err)
		}
	}

	t := rosa.Native().Std()
	for i, name := range args {
		handle := rosa.ArtifactH(unique.Make(name))
		if meta, a := t.Load(handle); meta == nil {
			return fmt.Errorf("unknown artifact %q", name)
		} else {
			var suffix string

			if meta.Version != rosa.Unversioned {
				suffix += "-" + meta.Version
			}
			mustPrintln("name        : " + name + suffix)

			mustPrintln("description : " + meta.Description)
			if meta.Website != "" {
				mustPrintln("website     : " +
					strings.TrimSuffix(meta.Website, "/"))
			}
			if len(meta.Dependencies) > 0 {
				mustPrint("depends on  :")
				for _, d := range meta.Dependencies {
					_meta, _ := rosa.Native().Std().MustLoad(d)
					s := _meta.Name
					if _meta.Version != rosa.Unversioned {
						s += "-" + _meta.Version
					}
					mustPrint(" " + s)
				}
				mustPrintln()
			}

			const statusPrefix = "status      : "
			if writeStatus {
				if r == nil {
					var f io.ReadSeekCloser
					err = cm.Do(func(cache *pkg.Cache) (err error) {
						f, err = cache.OpenStatus(a)
						return
					})
					if err != nil {
						if errors.Is(err, os.ErrNotExist) {
							mustPrintln(
								statusPrefix + "not yet cured",
							)
						} else {
							return
						}
					} else {
						mustPrint(statusPrefix)
						_, err = io.Copy(w, f)
						if err = errors.Join(err, f.Close()); err != nil {
							return
						}
					}
				} else if err = cm.Do(func(cache *pkg.Cache) (err error) {
					status, n := r.ArtifactOf(cache.Ident(a))
					if status == nil {
						mustPrintln(
							statusPrefix + "not in report",
						)
					} else {
						mustPrintln("size        :", n)
						mustPrint(statusPrefix)
						if _, err = w.Write(status); err != nil {
							return
						}
					}
					return
				}); err != nil {
					return
				}
			}

			if i != len(args)-1 {
				mustPrintln()
			}
		}
	}
	return nil
}
