package distribution
 
 import (

 	"fmt"

 	"net/http"
 	"os"

 	"runtime"
 	"sort"
 	"strings"

 	"github.com/docker/distribution"
 	"github.com/docker/distribution/context"

 	"github.com/docker/distribution/manifest/manifestlist"

 	"github.com/docker/distribution/manifest/schema2"

 	"github.com/docker/distribution/registry/client/transport"

 	"github.com/docker/docker/pkg/system"

 	"github.com/sirupsen/logrus"

 )
 

 var _ distribution.Describable = &v2LayerDescriptor{}

 func (ld *v2LayerDescriptor) Descriptor() distribution.Descriptor {
 	if ld.src.MediaType == schema2.MediaTypeForeignLayer && len(ld.src.URLs) > 0 {
 		return ld.src
 	}
 	return distribution.Descriptor{}

 }
 
 func (ld *v2LayerDescriptor) open(ctx context.Context) (distribution.ReadSeekCloser, error) {

 	blobs := ld.repo.Blobs(ctx)
 	rsc, err := blobs.Open(ctx, ld.digest)
 

 	if len(ld.src.URLs) == 0 {

 		return rsc, err

 	}
 

 	// We're done if the registry has this blob.
 	if err == nil {
 		// Seek does an HTTP GET.  If it succeeds, the blob really is accessible.
 		if _, err = rsc.Seek(0, os.SEEK_SET); err == nil {
 			return rsc, nil
 		}
 		rsc.Close()
 	}

 
 	// Find the first URL that results in a 200 result code.

 	for _, url := range ld.src.URLs {

 		logrus.Debugf("Pulling %v from foreign URL %v", ld.digest, url)

 		rsc = transport.NewHTTPReadSeeker(http.DefaultClient, url, nil)

 
 		// Seek does an HTTP GET.  If it succeeds, the blob really is accessible.

 		_, err = rsc.Seek(0, os.SEEK_SET)
 		if err == nil {
 			break
 		}

 		logrus.Debugf("Download for %v failed: %v", ld.digest, err)

 		rsc.Close()
 		rsc = nil
 	}
 	return rsc, err
 }

 func filterManifests(manifests []manifestlist.ManifestDescriptor, os string) []manifestlist.ManifestDescriptor {
 	osVersion := ""
 	if os == "windows" {

 		// TODO: Add UBR (Update Build Release) component after build

 		version := system.GetOSVersion()
 		osVersion = fmt.Sprintf("%d.%d.%d", version.MajorVersion, version.MinorVersion, version.Build)

 		logrus.Debugf("will prefer entries with version %s", osVersion)

 	}
 
 	var matches []manifestlist.ManifestDescriptor
 	for _, manifestDescriptor := range manifests {

 		// TODO: Consider filtering out greater versions, including only greater UBR

 		if manifestDescriptor.Platform.Architecture == runtime.GOARCH && manifestDescriptor.Platform.OS == os {

 			matches = append(matches, manifestDescriptor)

 			logrus.Debugf("found match for %s/%s with media type %s, digest %s", os, runtime.GOARCH, manifestDescriptor.MediaType, manifestDescriptor.Digest.String())

 		}
 	}

 	if os == "windows" {

 		sort.Stable(manifestsByVersion{osVersion, matches})

 	}

 	return matches
 }
 
 func versionMatch(actual, expected string) bool {

 	// Check whether the version matches up to the build, ignoring UBR
 	return strings.HasPrefix(actual, expected+".")

 }
 

 type manifestsByVersion struct {
 	version string
 	list    []manifestlist.ManifestDescriptor
 }

 
 func (mbv manifestsByVersion) Less(i, j int) bool {
 	// TODO: Split version by parts and compare
 	// TODO: Prefer versions which have a greater version number

 	// Move compatible versions to the top, with no other ordering changes
 	return versionMatch(mbv.list[i].Platform.OSVersion, mbv.version) && !versionMatch(mbv.list[j].Platform.OSVersion, mbv.version)

 }
 
 func (mbv manifestsByVersion) Len() int {

 	return len(mbv.list)

 }
 
 func (mbv manifestsByVersion) Swap(i, j int) {

 	mbv.list[i], mbv.list[j] = mbv.list[j], mbv.list[i]

 }