##
## STEP 1: create a remote repo with a module at the
##         repo root and a module in a subdirectory
##         (skip this if you want to repro with the
##         the GitHub repo provided at $TEST_REPO)
##

# A repo you have write access to
TEST_REPO=burnson/gomoduletest

# Do this in a scratch directory
cd $(mktemp -d)
echo "Creating repo from here:"
pwd

# Make a git repo
mkdir gomoduletest
cd gomoduletest
git init

# Add a module at the repo root
cat >go.mod <<EOF
module github.com/$TEST_REPO
EOF

# Create a simple package that returns the package name
cat >gomoduletest.go <<EOF
package gomoduletest

func Package() string {
	return "gomoduletest"
}
EOF

# Check the gomoduletest build
go build

# Now add a new module to a subdirectory
mkdir subpackage
cd subpackage
cat >go.mod <<EOF
module github.com/$TEST_REPO/subpackage
EOF

# Create a simple package that returns the package name
cat >subpackage.go <<EOF
package subpackage

func Package() string {
	return "subpackage"
}
EOF

# Check the subpackage build
go build

# What does everything look like so far?
cd ..
find *

# Commit what we have and tag as v1.0.0.
git add .
git commit -m 'v1.0.0 release'
git tag v1.0.0

# Push this repo to github
git remote add origin git@github.com:$TEST_REPO.git
git push -fu origin master
git push -f --tags

##
## STEP 2: create a local go module that makes use of
##         both of the modules created in the remote
##         repo above
##

# The repo created above
TEST_REPO=burnson/gomoduletest

# Do this in a new scratch directory
cd $(mktemp -d)
echo "Creating local go module from here:"
pwd
mkdir localmodule
cd localmodule

# Create a go module file for the test program
cat >go.mod <<EOF
module my/program
EOF

# Create a test program that uses both modules
# and calls the Package() func
cat >main.go <<EOF
package main

import (
	"fmt"

	rootpackage "github.com/$TEST_REPO"
	"github.com/$TEST_REPO/subpackage"
)

func main() {
	fmt.Println(rootpackage.Package())
	fmt.Println(subpackage.Package())
}
EOF

# Build the program
go build

echo
echo "Test program source:"
cat main.go

# Run the program
echo
echo "Test program output:"
./program

# Check the contents of the go.mod file now:
echo
echo "Test program go.mod:"
cat go.mod

# Replace the pseudo-version with the v1.0.0 tag:
cat >go.mod <<EOF
module my/program

require (
	github.com/$TEST_REPO v1.0.0
	github.com/$TEST_REPO/subpackage v1.0.0
)
EOF

echo
echo "Edited go.mod forcing v1.0.0 for subpackage:"
cat go.mod

# Try building
echo
echo "Building with tagged version:"
go build

...
Test program source:
package main

import (
	"fmt"

	rootpackage "github.com/burnson/gomoduletest"
	"github.com/burnson/gomoduletest/subpackage"
)

func main() {
	fmt.Println(rootpackage.Package())
	fmt.Println(subpackage.Package())
}

Test program output:
gomoduletest
subpackage

Test program go.mod:
module my/program

require (
	github.com/burnson/gomoduletest v1.0.0
	github.com/burnson/gomoduletest/subpackage v0.0.0-20190326022552-ee56fd37aed9
)

Edited go.mod forcing v1.0.0 for subpackage:
module my/program

require (
	github.com/burnson/gomoduletest v1.0.0
	github.com/burnson/gomoduletest/subpackage v1.0.0
)

Building with tagged version:
go: finding github.com/burnson/gomoduletest/subpackage v1.0.0
go: github.com/burnson/gomoduletest/subpackage@v1.0.0: unknown revision subpackage/v1.0.0
go: error loading module requirements