// Copyright 2024 The Hugo Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/bep/helpers/envhelpers"
	"github.com/gohugoio/hugo/commands"
	"github.com/gohugoio/hugo/htesting"
	"github.com/rogpeppe/go-internal/testscript"
)

func TestCommands(t *testing.T) {
	p := commonTestScriptsParam
	p.Dir = "testscripts/commands"
	testscript.Run(t, p)
}

func TestServer(t *testing.T) {
	// See issue #14439
	htesting.SkipSlowTestUnlessCI(t)
	p := commonTestScriptsParam
	p.Dir = "testscripts/server"
	testscript.Run(t, p)
}

// Tests in development can be put in "testscripts/unfinished".
// Also see the watch_testscripts.sh script.
func TestUnfinished(t *testing.T) {
	if os.Getenv("CI") != "" {
		t.Skip("skip unfinished tests on CI")
	}

	p := commonTestScriptsParam
	p.Dir = "testscripts/unfinished"
	// p.UpdateScripts = true
	// p.TestWork = true

	testscript.Run(t, p)
}

func TestMain(m *testing.M) {
	testscript.Main(m, map[string]func(){
		// The main program.
		"hugo": func() {
			err := commands.Execute(os.Args[1:])
			if err != nil {
				fmt.Fprintln(os.Stderr, err)
				os.Exit(1)
			}
		},
	})
}

var commonTestScriptsParam = testscript.Params{
	Setup: func(env *testscript.Env) error {
		return testSetupFunc()(env)
	},
	Cmds: map[string]func(ts *testscript.TestScript, neg bool, args []string){
		// log prints to stderr.
		"log": func(ts *testscript.TestScript, neg bool, args []string) {
			log.Println(args)
		},
		// cat prints a file to stdout.
		"cat": func(ts *testscript.TestScript, neg bool, args []string) {
			filename := ts.MkAbs(args[0])
			b, err := os.ReadFile(filename)
			if err != nil {
				ts.Fatalf("%v", err)
			}
			fmt.Print(string(b))
		},
		// sleep sleeps for a second.
		"sleep": func(ts *testscript.TestScript, neg bool, args []string) {
			i := 1
			if len(args) > 0 {
				var err error
				i, err = strconv.Atoi(args[0])
				if err != nil {
					i = 1
				}
			}
			time.Sleep(time.Duration(i) * time.Second)
		},
		// tree lists a directory recursively to stdout as a simple tree.
		"tree": func(ts *testscript.TestScript, neg bool, args []string) {
			dirname := ts.MkAbs(args[0])

			err := filepath.WalkDir(dirname, func(path string, d fs.DirEntry, err error) error {
				if err != nil {
					return err
				}
				rel, err := filepath.Rel(dirname, path)
				if err != nil {
					return err
				}
				if rel == "." {
					fmt.Fprintln(ts.Stdout(), ".")
					return nil
				}
				depth := strings.Count(rel, string(os.PathSeparator))
				prefix := strings.Repeat("  ", depth) + "└─"
				if d.IsDir() {
					fmt.Fprintf(ts.Stdout(), "%s%s/\n", prefix, d.Name())
				} else {
					fmt.Fprintf(ts.Stdout(), "%s%s\n", prefix, d.Name())
				}
				return nil
			})
			if err != nil {
				ts.Fatalf("%v", err)
			}
		},
		// ls lists a directory to stdout.
		"ls": func(ts *testscript.TestScript, neg bool, args []string) {
			dirname := ts.MkAbs(args[0])

			dir, err := os.Open(dirname)
			if err != nil {
				ts.Fatalf("%v", err)
			}
			fis, err := dir.Readdir(-1)
			if err != nil {
				ts.Fatalf("%v", err)
			}
			if len(fis) == 0 {
				// To simplify empty dir checks.
				fmt.Fprintln(ts.Stdout(), "Empty dir")
				return
			}
			for _, fi := range fis {
				fmt.Fprintf(ts.Stdout(), "%s %04o %s %s\n", fi.Mode(), fi.Mode().Perm(), fi.ModTime().Format(time.RFC3339), fi.Name())
			}
		},
		// lsr lists a directory recursively to stdout.
		"lsr": func(ts *testscript.TestScript, neg bool, args []string) {
			dirname := ts.MkAbs(args[0])

			err := filepath.WalkDir(dirname, func(path string, d fs.DirEntry, err error) error {
				if err != nil {
					return err
				}
				if d.IsDir() {
					return nil
				}

				fi, err := d.Info()
				if err != nil {
					return err
				}

				rel, err := filepath.Rel(dirname, path)
				if err != nil {
					return err
				}

				fmt.Fprintf(ts.Stdout(), "%s %04o %s\n", fi.Mode(), fi.Mode().Perm(), filepath.ToSlash(rel))
				return nil
			})
			if err != nil {
				ts.Fatalf("%v", err)
			}
		},
		// append appends to a file with a leading newline.
		"append": func(ts *testscript.TestScript, neg bool, args []string) {
			if len(args) < 2 {
				ts.Fatalf("usage: append FILE TEXT")
			}

			filename := ts.MkAbs(args[0])
			words := args[1:]
			for i, word := range words {
				words[i] = strings.Trim(word, "\"")
			}
			text := strings.Join(words, " ")

			_, err := os.Stat(filename)
			if err != nil {
				if os.IsNotExist(err) {
					ts.Fatalf("file does not exist: %s", filename)
				}
				ts.Fatalf("failed to stat file: %v", err)
			}

			f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0o644)
			if err != nil {
				ts.Fatalf("failed to open file: %v", err)
			}
			defer f.Close()

			_, err = f.WriteString("\n" + text)
			if err != nil {
				ts.Fatalf("failed to write to file: %v", err)
			}
		},
		// replace replaces a string in a file.
		"replace": func(ts *testscript.TestScript, neg bool, args []string) {
			if len(args) < 3 {
				ts.Fatalf("usage: replace FILE OLD NEW")
			}
			filename := ts.MkAbs(args[0])
			oldContent, err := os.ReadFile(filename)
			if err != nil {
				ts.Fatalf("failed to read file %v", err)
			}
			old, new := args[1], args[2]

			newContent := bytes.Replace(oldContent, []byte(old), []byte(new), -1)
			err = os.WriteFile(filename, newContent, 0o644)
			if err != nil {
				ts.Fatalf("failed to write file: %v", err)
			}
		},

		// httpget checks that a HTTP resource's body matches (if it compiles as a regexp) or contains all of the strings given as arguments.
		"httpget": func(ts *testscript.TestScript, neg bool, args []string) {
			if len(args) < 2 {
				ts.Fatalf("usage: httpget URL STRING...")
			}

			tryget := func() error {
				resp, err := http.Get(args[0])
				if err != nil {
					return fmt.Errorf("failed to get URL %q: %v", args[0], err)
				}

				defer resp.Body.Close()
				body, err := io.ReadAll(resp.Body)
				if err != nil {
					return fmt.Errorf("failed to read response body: %v", err)
				}
				for _, s := range args[1:] {
					re, err := regexp.Compile(s)
					if err == nil {
						ok := re.Match(body)
						if ok != !neg {
							return fmt.Errorf("response body %q for URL %q does not match %q", body, args[0], s)
						}
					} else {
						ok := bytes.Contains(body, []byte(s))
						if ok != !neg {
							return fmt.Errorf("response body %q for URL %q does not contain %q", body, args[0], s)
						}
					}
				}
				return nil
			}

			// The timing on server rebuilds can be a little tricky to get right,
			// so we try again a few times until the server is ready.
			// There may be smarter ways to do this, but this works.
			start := time.Now()
			for {
				time.Sleep(200 * time.Millisecond)
				err := tryget()
				if err == nil {
					return
				}
				if time.Since(start) > 6*time.Second {
					ts.Fatalf("timeout waiting for %q: %v", args[0], err)
				}
			}
		},
		// checkfile checks that a file exists and is not empty.
		"checkfile": func(ts *testscript.TestScript, neg bool, args []string) {
			var readonly, exec bool
		loop:
			for len(args) > 0 {
				switch args[0] {
				case "-readonly":
					readonly = true
					args = args[1:]
				case "-exec":
					exec = true
					args = args[1:]
				default:
					break loop
				}
			}
			if len(args) == 0 {
				ts.Fatalf("usage: checkfile [-readonly] [-exec] file...")
			}

			for _, filename := range args {
				filename = ts.MkAbs(filename)
				fi, err := os.Stat(filename)
				ok := err == nil != neg
				if !ok {
					ts.Fatalf("stat %s: %v", filename, err)
				}
				if fi.Size() == 0 {
					ts.Fatalf("%s is empty", filename)
				}
				if readonly && fi.Mode()&0o222 != 0 {
					ts.Fatalf("%s is writable", filename)
				}
				if exec && runtime.GOOS != "windows" && fi.Mode()&0o111 == 0 {
					ts.Fatalf("%s is not executable", filename)
				}
			}
		},

		// checkfilecount checks that the number of files in a directory is equal to the given count.
		"checkfilecount": func(ts *testscript.TestScript, neg bool, args []string) {
			if len(args) != 2 {
				ts.Fatalf("usage: checkfilecount count dir")
			}
			count, err := strconv.Atoi(args[0])
			if err != nil {
				ts.Fatalf("invalid count: %v", err)
			}
			if count < 0 {
				ts.Fatalf("count must be non-negative")
			}
			dir := args[1]
			dir = ts.MkAbs(dir)

			found := 0

			filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
				if err != nil {
					return err
				}
				if d.IsDir() {
					return nil
				}
				found++
				return nil
			})

			ok := found == count != neg
			if !ok {
				ts.Fatalf("found %d files, want %d", found, count)
			}
		},
		// waitServer waits for the .ready file to be created by the server.
		"waitServer": func(ts *testscript.TestScript, neg bool, args []string) {
			type testInfo struct {
				BaseURLs []string
			}

			// The server will write a .ready file when ready.
			// We wait for that.
			readyFilename := ts.MkAbs(".ready")
			limit := time.Now().Add(10 * time.Second)
			for {
				_, err := os.Stat(readyFilename)
				if err != nil {
					time.Sleep(500 * time.Millisecond)
					if time.Now().After(limit) {
						ts.Fatalf("timeout waiting for .ready file")
					}
					continue
				}
				var info testInfo
				// Read the .ready file's JSON into info.
				f, err := os.Open(readyFilename)
				if err != nil {
					ts.Fatalf("failed to open .ready file: %v", err)
				}
				err = json.NewDecoder(f).Decode(&info)
				if err != nil {
					ts.Fatalf("error decoding json: %v", err)
				}
				f.Close()

				for i, s := range info.BaseURLs {
					ts.Setenv(fmt.Sprintf("HUGOTEST_BASEURL_%d", i), s)
				}

				return
			}
		},
		"stopServer": func(ts *testscript.TestScript, neg bool, args []string) {
			baseURL := ts.Getenv("HUGOTEST_BASEURL_0")
			if baseURL == "" {
				ts.Fatalf("HUGOTEST_BASEURL_0 not set")
			}
			if !strings.HasSuffix(baseURL, "/") {
				baseURL += "/"
			}
			resp, err := http.Head(baseURL + "__stop")
			if err != nil {
				ts.Fatalf("failed to shutdown server: %v", err)
			}
			resp.Body.Close()
			// Allow some time for the server to shut down.
			time.Sleep(2 * time.Second)
		},
	},
}

func testSetupFunc() func(env *testscript.Env) error {
	sourceDir, _ := os.Getwd()
	return func(env *testscript.Env) error {
		var keyVals []string
		keyVals = append(keyVals, "HUGO_TESTRUN", "true")
		keyVals = append(keyVals, "HUGO_CACHEDIR", filepath.Join(env.WorkDir, "hugocache"))
		xdghome := filepath.Join(env.WorkDir, "xdgcachehome")
		keyVals = append(keyVals, "XDG_CACHE_HOME", xdghome)
		home := filepath.Join(env.WorkDir, "home")
		keyVals = append(keyVals, "HOME", home)

		if runtime.GOOS == "darwin" {
			if err := os.MkdirAll(filepath.Join(home, "Library", "Caches"), 0o777); err != nil {
				return err
			}
		}

		if runtime.GOOS == "linux" {
			if err := os.MkdirAll(xdghome, 0o777); err != nil {
				return err
			}
		}

		keyVals = append(keyVals, "SOURCE", sourceDir)

		goVersion := runtime.Version()

		goVersion = strings.TrimPrefix(goVersion, "go")
		if strings.HasPrefix(goVersion, "1.20") {
			// Strip patch version.
			goVersion = goVersion[:strings.LastIndex(goVersion, ".")]
		}

		goModVersion := goVersion
		// From Go 1.26.0 on, the version used in go.mod on go mod init is the current version minus one.
		// This was reverted in Go 1.26.1.
		if goVersion == "1.26.0" {
			goModVersion = "1.25.0"
		}

		keyVals = append(keyVals, "GOVERSION", goVersion)
		keyVals = append(keyVals, "GOMODVERSION", goModVersion)
		envhelpers.SetEnvVars(&env.Vars, keyVals...)

		return nil
	}
}
