package repostatus

// does processing on the go.mod and go.sum files

import (
	"bufio"
	"errors"
	"os"
	"path/filepath"
	"strings"

	"go.wit.com/log"
)

// Detect a 'Primative' package. Sets the isPrimative flag
// will return true if the repo is truly not dependent on _anything_ else
// like spew or lib/widget
func (rs *RepoStatus) isPrimativeGoMod() (bool, error) {
	// go mod init & go mod tidy ran without errors
	log.Log(WARN, "isPrimativeGoMod()", rs.realPath.String())
	tmp := filepath.Join(rs.realPath.String(), "go.mod")
	gomod, err := os.Open(tmp)
	if err != nil {
		log.Log(WARN, "missing go.mod", rs.realPath.String())
		rs.goConfig = nil
		return false, err
	}
	defer gomod.Close()

	scanner := bufio.NewScanner(gomod)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		parts := strings.Split(line, " ")
		log.Log(INFO, "  gomod:", parts)
		if len(parts) >= 1 {
			log.Log(INFO, "  gomod: part[0] =", parts[0])
			if parts[0] == "require" {
				log.Log(INFO, "  should return false here")
				return false, errors.New("bad go.mod file" + rs.GoPath())
			}

		}
	}
	return true, nil
}

// readGoMod reads and parses the go.sum file
// saves the config information in repo.goConfig
func (rs *RepoStatus) parseGoSum() (bool, error) {
	ok, err := rs.isPrimativeGoMod()
	if err != nil {
		// this means this repo does not depend on any other package
		log.Info("PRIMATIVE repo:", rs.String(), "err =", err)
		rs.goConfig = nil
		rs.primitive.SetText("false")
		return false, err
	}
	if ok {
		// this means the repo is primitive so there is no go.sum
		rs.goConfig = nil
		rs.primitive.SetText("true")
		return true, nil
	}
	rs.primitive.SetText("false")

	tmp := filepath.Join(rs.realPath.String(), "go.sum")
	gosum, err := os.Open(tmp)
	if err != nil {
		log.Log(WARN, "missing go.sum", rs.realPath.String())
		rs.goConfig = nil
		return false, err
	}
	defer gosum.Close()

	var deps GoConfig
	deps = make(GoConfig)

	scanner := bufio.NewScanner(gosum)
	log.Log(INFO, "gosum:", tmp)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		parts := strings.Split(line, " ")
		if len(parts) == 3 {
			godep := strings.TrimSpace(parts[0])
			version := strings.TrimSpace(parts[1])
			if strings.HasSuffix(version, "/go.mod") {
				version = strings.TrimSuffix(version, "/go.mod")
			}
			currentversion, ok := deps[godep]
			if ok {
				if currentversion != version {
					// ignore these warnings for now
					depname := rs.String()
					if strings.HasPrefix(depname, "go.wit.com") {
						log.Log(INFO, "REPO:", rs.realPath.String())
						log.Log(INFO, "  version mismatch:", godep, version, currentversion)
					} else {
						log.Log(INFO, "REPO:", rs.realPath.String())
						log.Log(INFO, "  version mismatch:", godep, version, currentversion)
					}
				}
			} else {
				deps[godep] = version
				log.Log(INFO, "\t", godep, "=", version)
			}
		} else {
			log.Log(WARN, "\t INVALID:", parts)
		}
	}

	if err := scanner.Err(); err != nil {
		rs.goConfig = nil
		return false, err
	}

	rs.goConfig = deps
	return true, nil
}

func (rs *RepoStatus) GoConfig() map[string]string {
	return rs.goConfig
}

// poor name perhaps. It's because in most of these
// repos you can also type "make redomod" to do the same thing
// since it's a Makefile task that is also useful to be able to run
// from the command line
func (rs *RepoStatus) MakeRedomod() (bool, error) {
	var err error
	var output string
	if rs.ReadOnly() {
		log.Log(WARN, "will not go mod redo read only repos", rs.String())
		return false, errors.New(rs.GoPath() + " is read-only ")
	}

	// unset the go development ENV var to generate release files
	os.Unsetenv("GO111MODULE")
	err, output = rs.RunCmd([]string{"rm", "-f", "go.mod", "go.sum"})
	if err != nil {
		log.Log(WARN, "rm failed", err, output)
		return false, err
	}
	err, output = rs.RunCmd([]string{"go", "mod", "init"})
	if err != nil {
		log.Log(WARN, "go mod init failed", err, output)
		return false, err
	}
	err, output = rs.RunCmd([]string{"go", "mod", "tidy"})
	if err != nil {
		log.Log(WARN, "go mod tidy failed", err, output)
		return false, err
	}
	log.Log(INFO, "MakeRedomod() worked", rs.GoPath())

	// return the attempt to parse go.mod & go.sum
	return rs.parseGoSum()
}

func (rs *RepoStatus) IsReleased() bool {
	if rs.GetTargetVersion() == rs.GetCurrentVersion() {
		return true
	}
	return false
}