package release

import (
	"context"

	edgeinfra "edge-infra.dev"
	"edge-infra.dev/pkg/lib/build/semver"

	"fmt"

	"github.com/go-logr/logr"
	"github.com/google/go-containerregistry/pkg/authn"
	ociname "github.com/google/go-containerregistry/pkg/name"
	"github.com/google/go-containerregistry/pkg/v1/google"
	gremote "github.com/google/go-containerregistry/pkg/v1/remote"

	edgename "edge-infra.dev/pkg/f8n/warehouse/oci/name"
	"edge-infra.dev/pkg/f8n/warehouse/oci/remote"

	"edge-infra.dev/pkg/f8n/warehouse/pallet"
)

var (
	defaultVersion string = edgeinfra.SemVer
)

// The Releaser is the structure for sourcing information to build and lock releases
// from a source repository and list of pallets to serialize into an EdgeRelease
// artifact
type Releaser struct {
	CurrentVersion        string     `yaml:"current_version,omitempty"`
	SourceRepository      Repository `yaml:"source_repository"`
	DestinationRepository Repository `yaml:"destination_repository"`
	PalletNames           []string   `yaml:"pallets"`
	Log                   logr.Logger
}

func (r *Releaser) BuildRelease(ctx context.Context, buildInfo pallet.BuildInfo) (EdgeRelease, error) {
	if r.CurrentVersion == "" {
		r.CurrentVersion = defaultVersion
	}

	err := semver.IsValidSemver(r.CurrentVersion)
	if err != nil {
		return EdgeRelease{}, err
	}

	meta := Metadata{
		Vendor:          "NCR",
		Version:         r.CurrentVersion,
		BuildInfo:       buildInfo,
		ReleaseRegistry: r.SourceRepository.Registry(),
		ReleaseRepo:     r.SourceRepository.Name(),
	}
	pallets, err := r.getPallets(ctx)
	if err != nil {
		return EdgeRelease{}, err
	}

	release := New(meta, pallets)

	return release, nil
}

func (r *Releaser) Push(ctx context.Context, rel EdgeRelease) error {
	relTag, err := edgename.Tag(fmt.Sprintf("%s/edge-release:%s", r.DestinationRepository, rel.Metadata.Version))
	if err != nil {
		return err
	}

	r.Log.Info(fmt.Sprintf("writing %s", relTag))
	err = remote.MultiWrite(
		map[ociname.Reference]gremote.Taggable{relTag: rel.Artifact},
		[]remote.Option{
			remote.WithContext(ctx),
			gremote.WithAuthFromKeychain(authn.NewMultiKeychain(
				google.Keychain,
				authn.DefaultKeychain,
			)),
		}...,
	)
	if err != nil {
		return err
	}
	return nil
}

func (r *Releaser) getPallets(ctx context.Context) ([]pallet.Pallet, error) {
	pallets := []pallet.Pallet{}

	for _, p := range r.PalletNames {
		pkgPath := fmt.Sprintf("%s/%s:%s", r.SourceRepository, p, r.CurrentVersion)
		t, err := edgename.Tag(
			pkgPath,
			[]ociname.Option{
				ociname.WithDefaultRegistry(r.SourceRepository.Registry()),
			}...,
		)
		if err != nil {
			return nil, err
		}
		r.Log.Info(fmt.Sprintf("pulling %s", pkgPath))
		pall, err := remote.Pallet(
			t,
			[]remote.Option{
				remote.WithContext(ctx),
				gremote.WithAuthFromKeychain(authn.NewMultiKeychain(
					google.Keychain,
					authn.DefaultKeychain,
				)),
			}...,
		)
		if err != nil {
			return nil, err
		}
		pallets = append(pallets, pall)
	}
	return pallets, nil
}