package gitpb

import (
	"errors"
	"net/url"
	"path/filepath"

	"go.wit.com/log"
)

// scans in a new git repo. If it detects the repo is a golang project,
// then it parses the go.mod/go.sum files
// TODO: try adding python, rails, perl, rust, other language things?
// I probably will never have time to try that, but I'd take patches for anyone
// that might see this note and feel so inclined.
// todo: use Repos.Lock() ?
func (all *Repos) NewGoRepo(fullpath string, gopath string) (*Repo, error) {
	if gopath == "" {
		return nil, errors.New("blank gopath")
	}
	if r := all.FindByFullPath(fullpath); r != nil {
		log.Info("gitpb.NewGoPath() already has gopath", r.GetGoPath())
		log.Info("gitpb.NewGoPath() already has FullPath", r.FullPath)
		// already had this gopath
		return r, errors.New("gitpb.NewGoPath() duplicate gopath " + gopath)
	}

	// add a new one here
	newr := Repo{
		FullPath:  fullpath,
		Namespace: gopath,
	}
	newr.Times = new(GitTimes)

	newr.GoInfo = new(GoInfo)
	newr.GoInfo.GoPath = gopath
	// everything happens in here
	newr.Reload()

	newr.ValidateUTF8()
	if all.AppendByFullPath(&newr) {
		// worked
		return &newr, nil
	} else {
		// this is dumb, probably never happens. todo: use Repos.Lock()
		if r := all.FindByFullPath(fullpath); r != nil {
			// already had this gopath
			return r, errors.New("gitpb.NewGoPath() AppendUnique() failed but Find() worked" + gopath)
		}
	}
	// todo: use Repos.Lock()
	return nil, errors.New("repo gitpb.NewGoPath() should never have gotten here " + gopath)
}

// enforces GoPath is unique
// TODO: deprecate this (?)
// mutex's should finally work in the autogenpb protobuf code
/*
func (all *Repos) AppendByGoPathOld(newr *Repo) bool {
	// all.RLock()
	repoMu.RLock()

	for _, r := range all.Repos {
		if r.GoInfo.GoPath == newr.GoInfo.GoPath {
			// all.RUnlock()
			repoMu.RUnlock()
			return false
		}
	}
	// all.RUnlock()
	repoMu.RUnlock()

	all.Append(newr)
	return true
}
*/

func (all *Repos) NewRepo(fullpath string, namespace string) (*Repo, error) {
	if r := all.FindByFullPath(fullpath); r != nil {
		log.Info("gitpb.NewRepo() might already have namespace", r.GetNamespace())
		log.Info("gitpb.NewRepo() already has FullPath", r.FullPath)
		// already had this gopath
		return r, errors.New("gitpb.NewRepo() duplicate path " + fullpath)
	}

	// add a new one here
	newr := Repo{
		FullPath:  fullpath,
		Namespace: namespace,
	}
	newr.Times = new(GitTimes)

	// everything happens in here
	newr.Reload()

	newr.ValidateUTF8()
	if all.AppendByFullPath(&newr) {
		// worked
		return &newr, nil
	}

	// todo: use Repos.Lock()
	return nil, errors.New("gitpb.NewRepo() append failed " + fullpath)
}

func NewRepo(fullpath string) (*Repo, error) {
	// add a new one here
	repo := Repo{
		FullPath: fullpath,
	}
	repo.Times = new(GitTimes)

	// everything happens in here
	repo.Reload()
	repo.ValidateUTF8()
	if repo.Namespace == "" {
		giturl := repo.GetURL()
		if giturl == "" {
			log.Info(repo.FullPath, "Namespace & URL are both blank. Warn the user of a local repo.")
			return &repo, nil
		}
		// log.Info("GET Namespace from URL", giturl)
		tmpURL, err := url.Parse(giturl)
		if err != nil {
			log.Info(repo.FullPath, "URL parse failed", giturl, err)
			return &repo, nil
		}
		// log.Info(repo.FullPath, "namespace might be:", tmpURL.Hostname(), tmpURL.Path)
		repo.Namespace = filepath.Join(tmpURL.Hostname(), tmpURL.Path)
		// log.Info(repo.FullPath, "Namesapce =", repo.Namespace)
	}
	return &repo, nil
}