package forgepb

/*
	lookup settings for a particular *gitpb.Repo or namespace string

	user settings are configured in ~/.config/forge/forge.text

	// searchs by string
	Configs.IsReadOnly(path)	// user can't push commits
	Configs.IsWritable(path)	// the opposite, but maybe different so I put both here

	IsPrivate(repo)		// repo can't be published to the pkg.go.dev system
	DebName()		// for 'zookeeper' returns 'zookeeper-go'

	This code is practical, not perfect
*/

import (
	"path/filepath"
	"strings"

	"go.wit.com/lib/protobuf/gitpb"
)

// move away from IsReadOnly. Only use repo.Namespace
func (f *Forge) IsWritable(repo *gitpb.Repo) bool {
	if f.Config.IsWritable(repo.Namespace) {
		return true
	}
	//	if f.Config.IsWritable(repo.FullPath) {
	//		return true
	//	}
	//	if !f.Config.IsWritable(repo.GetNamespace()) {
	//		return true
	//	}
	return false
}

// returns true if namespace is readonly()
// will attempt to match IsWritable("foo") against anything ending in "foo"
func (fc *ForgeConfigs) IsReadOnly(namespace string) bool {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == namespace {
			// exact namespace match
			if r.Writable {
				return false
			}
			if r.ReadOnly {
				return true
			}
			// private is assumed to be r/w unless above is specifically set
			if r.Private {
				return false
			}
		}
		// if namespace == "foo" will return false if "go.wit.com/apps/foo" is Writable
		base := filepath.Base(r.Namespace)
		if base == namespace {
			if r.Writable {
				return false
			}
		}
		// search for potential dir matches
		if r.Directory {
			// test the dir
			if strings.HasPrefix(namespace, r.Namespace) {
				match = r
			}
		}
	}

	if match == nil {
		// log.Info("did not match in IsReadOnly()", namespace)
		return true
	}

	// take the settings from the directory match
	if match.Writable {
		return false
	}
	if match.ReadOnly {
		return true
	}
	// private is assumed to be r/w unless above is specifically set
	if match.Private {
		return false
	}

	// always assume readonly
	return true
}

// returns the deb package name
// this let's you check a git tag version against a package .deb version
// allows namespace's to not need to match the .deb name
// this is important in lots of cases! It is normal and happens often enough.
func (fc *ForgeConfigs) DebName(namespace string) string {
	// get "zookeeper" from "go.wit.com/apps/zookeeper"
	normalBase := filepath.Base(namespace)

	all := fc.All()
	for all.Scan() {
		r := all.Next()
		if r.Namespace == namespace {
			// returns "zookeeper-go" for "go.wit.com/apps/zookeeper"
			if r.DebName != "" {
				// log.Info("FOUND DebName", r.DebName)
				return r.DebName
			} else {
				return normalBase
			}
		}
	}
	return normalBase
}

// a work in progress
func (f *Forge) IsPrivate(repo *gitpb.Repo) bool {
	namespace := repo.GetNamespace()
	if namespace == "" {
		// assume true
		return true
	}

	return f.Config.IsPrivate(namespace)
}

// is this a non-publishable repo?
// matches package names from apt
//
// IsPrivate("foo") will match anything in the config file ending in "foo"
//
// IsPrivate("go.foo.com/jcarr/foo") returns true if private
// IsPrivate("foo") also returns true if "go.bar.com/jcarr/foo" is private
func (fc *ForgeConfigs) IsPrivate(thing string) bool {
	var match *ForgeConfig

	// sort by path means the simple 'match' logic
	// here works in the sense the last directory match
	// is the one that is used
	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			// if private is set here, then ok, otherwise
			// still check if a Directory match exists
			if r.Private {
				return true
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.Private {
				return true
			}
		}
		// check to see if IsPrivate("foo")
		// search for potential dir matches
		if r.Directory {
			// test the dir
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		// log.Info("did not match in IsPrivate()", thing)
		return false
	}

	// otherwise, assume not private
	return match.Private
}

// IsFavorite() -- fun option for the config
// file that lets you set things as favorites
// so you can just go-clone a bunch of common things
// on a new box or after you reset/delete your ~/go/src dir
func (fc *ForgeConfigs) IsFavorite(thing string) bool {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			if r.Favorite {
				return true
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.Favorite {
				return true
			}
		}
		if r.Directory {
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		return false
	}

	return match.Favorite
}

// IsWritable() checks your .config/forge/ settings
// looks for an exact match, then
// looks for a directory match
func (fc *ForgeConfigs) IsWritable(thing string) bool {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			if r.Writable {
				return true
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.Writable {
				return true
			}
		}
		if r.Directory {
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		return false
	}

	return match.Writable
}

// allows custom user branch names in the forge config
func (fc *ForgeConfigs) FindUserBranch(thing string) string {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			if r.UserBranchName != "" {
				return r.UserBranchName
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.UserBranchName != "" {
				return r.UserBranchName
			}
		}
		if r.Directory {
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		return ""
	}

	return match.UserBranchName
}

// allows custom devel branch names in the forge config
func (fc *ForgeConfigs) FindDevelBranch(thing string) string {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			if r.DevelBranchName != "" {
				return r.DevelBranchName
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.DevelBranchName != "" {
				return r.DevelBranchName
			}
		}
		if r.Directory {
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		return ""
	}

	return match.DevelBranchName
}

// allows custom devel branch names in the forge config
func (fc *ForgeConfigs) FindMasterBranch(thing string) string {
	var match *ForgeConfig

	all := fc.All() // get the list of repos
	for all.Scan() {
		r := all.Next()
		if r.Namespace == thing {
			if r.MasterBranchName != "" {
				return r.MasterBranchName
			}
		}
		base := filepath.Base(r.Namespace)
		if base == thing {
			if r.MasterBranchName != "" {
				return r.MasterBranchName
			}
		}
		if r.Directory {
			if strings.HasPrefix(thing, r.Namespace) {
				match = r
			}
		}
	}
	if match == nil {
		return ""
	}

	return match.MasterBranchName
}