// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package misc

import (
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"golang.org/x/telemetry/counter"
	"golang.org/x/telemetry/counter/countertest"
	"golang.org/x/tools/gopls/internal/protocol"
	"golang.org/x/tools/gopls/internal/protocol/command"
	"golang.org/x/tools/gopls/internal/server"
	. "golang.org/x/tools/gopls/internal/test/integration"
)

// Test prompt file in old and new formats are handled as expected.
func TestTelemetryPrompt_PromptFile(t *testing.T) {
	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {}
`

	defaultTelemetryStartTime := "1714521600" // 2024-05-01
	defaultToken := "7"
	samplesPerMille := "500"

	testCases := []struct {
		name, in, want string
		wantPrompt     bool
	}{
		{
			name:       "empty",
			in:         "",
			want:       "failed 1 1714521600 7",
			wantPrompt: true,
		},
		{
			name:       "v0.15-format/invalid",
			in:         "pending",
			want:       "failed 1 1714521600 7",
			wantPrompt: true,
		},
		{
			name:       "v0.15-format/pPending",
			in:         "pending 1",
			want:       "failed 2 1714521600 7",
			wantPrompt: true,
		},
		{
			name:       "v0.15-format/pPending",
			in:         "failed 1",
			want:       "failed 2 1714521600 7",
			wantPrompt: true,
		},
		{
			name: "v0.15-format/pYes",
			in:   "yes 1",
			want: "yes 1", // untouched since short-circuited
		},
		{
			name: "v0.16-format/pNotReady",
			in:   "- 0 1714521600 1000",
			want: "- 0 1714521600 1000",
		},
		{
			name:       "v0.16-format/pPending",
			in:         "pending 1 1714521600 1",
			want:       "failed 2 1714521600 1",
			wantPrompt: true,
		},
		{
			name:       "v0.16-format/pFailed",
			in:         "failed 2 1714521600 1",
			want:       "failed 3 1714521600 1",
			wantPrompt: true,
		},
		{
			name:       "v0.16-format/invalid",
			in:         "xxx 0 12345 678",
			want:       "failed 1 1714521600 7",
			wantPrompt: true,
		},
		{
			name: "v0.16-format/extra",
			in:   "- 0 1714521600 1000 7777 xxx",
			want: "- 0 1714521600 1000", // drop extra
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			modeFile := filepath.Join(t.TempDir(), "mode")
			goplsConfigDir := t.TempDir()
			promptDir := filepath.Join(goplsConfigDir, "prompt")
			promptFile := filepath.Join(promptDir, "telemetry")

			if err := os.MkdirAll(promptDir, 0777); err != nil {
				t.Fatal(err)
			}
			if err := os.WriteFile(promptFile, []byte(tc.in), 0666); err != nil {
				t.Fatal(err)
			}
			WithOptions(
				Modes(Default), // no need to run this in all modes
				EnvVars{
					server.GoplsConfigDirEnvvar:                  goplsConfigDir,
					server.FakeTelemetryModefileEnvvar:           modeFile,
					server.GoTelemetryGoplsClientStartTimeEnvvar: defaultTelemetryStartTime,
					server.GoTelemetryGoplsClientTokenEnvvar:     defaultToken,
					server.FakeSamplesPerMille:                   samplesPerMille,
				},
				Settings{
					"telemetryPrompt": true,
				},
			).Run(t, src, func(t *testing.T, env *Env) {
				expectation := ShownMessageRequest(".*Would you like to enable Go telemetry?")
				if !tc.wantPrompt {
					expectation = Not(expectation)
				}
				env.OnceMet(
					CompletedWork(server.TelemetryPromptWorkTitle, 1, true),
					expectation,
				)
				if got, err := os.ReadFile(promptFile); err != nil || string(got) != tc.want {
					t.Fatalf("(%q) -> (%q, %v), want %q", tc.in, got, err, tc.want)
				}
			})
		})
	}
}

// Test that gopls prompts for telemetry only when it is supposed to.
func TestTelemetryPrompt_Conditions_Mode(t *testing.T) {
	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {
}
`

	for _, enabled := range []bool{true, false} {
		t.Run(fmt.Sprintf("telemetryPrompt=%v", enabled), func(t *testing.T) {
			for _, initialMode := range []string{"", "local", "off", "on"} {
				t.Run(fmt.Sprintf("initial_mode=%s", initialMode), func(t *testing.T) {
					modeFile := filepath.Join(t.TempDir(), "mode")
					if initialMode != "" {
						if err := os.WriteFile(modeFile, []byte(initialMode), 0666); err != nil {
							t.Fatal(err)
						}
					}
					telemetryStartTime := time.Now().Add(-8 * 24 * time.Hour) // telemetry started a while ago
					WithOptions(
						Modes(Default), // no need to run this in all modes
						EnvVars{
							server.GoplsConfigDirEnvvar:                  t.TempDir(),
							server.FakeTelemetryModefileEnvvar:           modeFile,
							server.GoTelemetryGoplsClientStartTimeEnvvar: strconv.FormatInt(telemetryStartTime.Unix(), 10),
							server.GoTelemetryGoplsClientTokenEnvvar:     "1", // always sample because samplingPerMille >= 1.
						},
						Settings{
							"telemetryPrompt": enabled,
						},
					).Run(t, src, func(t *testing.T, env *Env) {
						wantPrompt := enabled && (initialMode == "" || initialMode == "local")
						expectation := ShownMessageRequest(".*Would you like to enable Go telemetry?")
						if !wantPrompt {
							expectation = Not(expectation)
						}
						env.OnceMet(
							CompletedWork(server.TelemetryPromptWorkTitle, 1, true),
							expectation,
						)
					})
				})
			}
		})
	}
}

// Test that gopls prompts for telemetry only after instrumenting for a while, and
// when the token is within the range for sample.
func TestTelemetryPrompt_Conditions_StartTimeAndSamplingToken(t *testing.T) {
	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {
}
`
	day := 24 * time.Hour
	samplesPerMille := 50
	for _, token := range []int{1, samplesPerMille, samplesPerMille + 1} {
		wantSampled := token <= samplesPerMille
		t.Run(fmt.Sprintf("to_sample=%t/tokens=%d", wantSampled, token), func(t *testing.T) {
			for _, elapsed := range []time.Duration{8 * day, 1 * day, 0} {
				telemetryStartTimeOrEmpty := ""
				if elapsed > 0 {
					telemetryStartTimeOrEmpty = strconv.FormatInt(time.Now().Add(-elapsed).Unix(), 10)
				}
				t.Run(fmt.Sprintf("elapsed=%s", elapsed), func(t *testing.T) {
					modeFile := filepath.Join(t.TempDir(), "mode")
					WithOptions(
						Modes(Default), // no need to run this in all modes
						EnvVars{
							server.GoplsConfigDirEnvvar:                  t.TempDir(),
							server.FakeTelemetryModefileEnvvar:           modeFile,
							server.GoTelemetryGoplsClientStartTimeEnvvar: telemetryStartTimeOrEmpty,
							server.GoTelemetryGoplsClientTokenEnvvar:     strconv.Itoa(token),
							server.FakeSamplesPerMille:                   strconv.Itoa(samplesPerMille), // want token ∈ [1, 50] is always sampled.
						},
						Settings{
							"telemetryPrompt": true,
						},
					).Run(t, src, func(t *testing.T, env *Env) {
						wantPrompt := wantSampled && elapsed > 7*day
						expectation := ShownMessageRequest(".*Would you like to enable Go telemetry?")
						if !wantPrompt {
							expectation = Not(expectation)
						}
						env.OnceMet(
							CompletedWork(server.TelemetryPromptWorkTitle, 1, true),
							expectation,
						)
					})
				})
			}
		})
	}
}

// Test that responding to the telemetry prompt results in the expected state.
func TestTelemetryPrompt_Response(t *testing.T) {
	if !countertest.SupportedPlatform {
		t.Skip("requires counter support")
	}

	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {
}
`

	var (
		acceptanceCounter = "gopls/telemetryprompt/accepted"
		declinedCounter   = "gopls/telemetryprompt/declined"
		attempt1Counter   = "gopls/telemetryprompt/attempts:1"
		allCounters       = []string{acceptanceCounter, declinedCounter, attempt1Counter}
	)

	// We must increment counters in order for the initial reads below to
	// succeed.
	//
	// TODO(rfindley): ReadCounter should simply return 0 for uninitialized
	// counters.
	for _, name := range allCounters {
		counter.New(name).Inc()
	}

	readCounts := func(t *testing.T) map[string]uint64 {
		t.Helper()
		counts := make(map[string]uint64)
		for _, name := range allCounters {
			count, err := countertest.ReadCounter(counter.New(name))
			if err != nil {
				t.Fatalf("ReadCounter(%q) failed: %v", name, err)
			}
			counts[name] = count
		}
		return counts
	}

	tests := []struct {
		name       string // subtest name
		response   string // response to choose for the telemetry dialog
		wantMode   string // resulting telemetry mode
		wantMsg    string // substring contained in the follow-up popup (if empty, no popup is expected)
		wantInc    uint64 // expected 'prompt accepted' counter increment
		wantCounts map[string]uint64
	}{
		{"yes", server.TelemetryYes, "on", "uploading is now enabled", 1, map[string]uint64{
			acceptanceCounter: 1,
			declinedCounter:   0,
			attempt1Counter:   1,
		}},
		{"no", server.TelemetryNo, "", "", 0, map[string]uint64{
			acceptanceCounter: 0,
			declinedCounter:   1,
			attempt1Counter:   1,
		}},
		{"empty", "", "", "", 0, map[string]uint64{
			acceptanceCounter: 0,
			declinedCounter:   0,
			attempt1Counter:   1,
		}},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			initialCounts := readCounts(t)
			modeFile := filepath.Join(t.TempDir(), "mode")
			telemetryStartTime := time.Now().Add(-8 * 24 * time.Hour)
			msgRE := regexp.MustCompile(".*Would you like to enable Go telemetry?")
			respond := func(m *protocol.ShowMessageRequestParams) (*protocol.MessageActionItem, error) {
				if msgRE.MatchString(m.Message) {
					for _, item := range m.Actions {
						if item.Title == test.response {
							return &item, nil
						}
					}
					if test.response != "" {
						t.Errorf("action item %q not found", test.response)
					}
				}
				return nil, nil
			}
			WithOptions(
				Modes(Default), // no need to run this in all modes
				EnvVars{
					server.GoplsConfigDirEnvvar:                  t.TempDir(),
					server.FakeTelemetryModefileEnvvar:           modeFile,
					server.GoTelemetryGoplsClientStartTimeEnvvar: strconv.FormatInt(telemetryStartTime.Unix(), 10),
					server.GoTelemetryGoplsClientTokenEnvvar:     "1", // always sample because samplingPerMille >= 1.
				},
				Settings{
					"telemetryPrompt": true,
				},
				MessageResponder(respond),
			).Run(t, src, func(t *testing.T, env *Env) {
				var postConditions []Expectation
				if test.wantMsg != "" {
					postConditions = append(postConditions, ShownMessage(test.wantMsg))
				}
				env.OnceMet(
					CompletedWork(server.TelemetryPromptWorkTitle, 1, true),
					postConditions...,
				)
				gotMode := ""
				if contents, err := os.ReadFile(modeFile); err == nil {
					gotMode = string(contents)
				} else if !os.IsNotExist(err) {
					t.Fatal(err)
				}
				if gotMode != test.wantMode {
					t.Errorf("after prompt, mode=%s, want %s", gotMode, test.wantMode)
				}

				// We increment the acceptance counter when checking the prompt file
				// before prompting, so start a second, transient gopls session and
				// verify that the acceptance counter is incremented.
				env2 := ConnectGoplsEnv(t, env.Ctx, env.Sandbox, env.Editor.Config(), env.Server)
				env2.Await(CompletedWork(server.TelemetryPromptWorkTitle, 1, true))
				if err := env2.Editor.Close(env2.Ctx); err != nil {
					t.Errorf("closing second editor: %v", err)
				}

				gotCounts := readCounts(t)
				for k := range gotCounts {
					gotCounts[k] -= initialCounts[k]
				}
				if diff := cmp.Diff(test.wantCounts, gotCounts); diff != "" {
					t.Errorf("counter mismatch (-want +got):\n%s", diff)
				}
			})
		})
	}
}

// Test that we stop asking about telemetry after the user ignores the question
// 5 times.
func TestTelemetryPrompt_GivingUp(t *testing.T) {
	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {
}
`

	// For this test, we want to share state across gopls sessions.
	modeFile := filepath.Join(t.TempDir(), "mode")
	telemetryStartTime := time.Now().Add(-30 * 24 * time.Hour)
	configDir := t.TempDir()

	const maxPrompts = 5 // internal prompt limit defined by gopls

	for i := 0; i < maxPrompts+1; i++ {
		WithOptions(
			Modes(Default), // no need to run this in all modes
			EnvVars{
				server.GoplsConfigDirEnvvar:                  configDir,
				server.FakeTelemetryModefileEnvvar:           modeFile,
				server.GoTelemetryGoplsClientStartTimeEnvvar: strconv.FormatInt(telemetryStartTime.Unix(), 10),
				server.GoTelemetryGoplsClientTokenEnvvar:     "1", // always sample because samplingPerMille >= 1.
			},
			Settings{
				"telemetryPrompt": true,
			},
		).Run(t, src, func(t *testing.T, env *Env) {
			wantPrompt := i < maxPrompts
			expectation := ShownMessageRequest(".*Would you like to enable Go telemetry?")
			if !wantPrompt {
				expectation = Not(expectation)
			}
			env.OnceMet(
				CompletedWork(server.TelemetryPromptWorkTitle, 1, true),
				expectation,
			)
		})
	}
}

// Test that gopls prompts for telemetry only when it is supposed to.
func TestTelemetryPrompt_Conditions_Command(t *testing.T) {
	const src = `
-- go.mod --
module mod.com

go 1.12
-- main.go --
package main

func main() {
}
`
	modeFile := filepath.Join(t.TempDir(), "mode")
	telemetryStartTime := time.Now().Add(-8 * 24 * time.Hour)
	WithOptions(
		Modes(Default), // no need to run this in all modes
		EnvVars{
			server.GoplsConfigDirEnvvar:                  t.TempDir(),
			server.FakeTelemetryModefileEnvvar:           modeFile,
			server.GoTelemetryGoplsClientStartTimeEnvvar: fmt.Sprintf("%d", telemetryStartTime.Unix()),
			server.GoTelemetryGoplsClientTokenEnvvar:     "1", // always sample because samplingPerMille >= 1.
		},
		Settings{
			// off because we are testing
			// if we can trigger the prompt with command.
			"telemetryPrompt": false,
		},
	).Run(t, src, func(t *testing.T, env *Env) {
		cmd := command.NewMaybePromptForTelemetryCommand("prompt")
		var err error
		env.ExecuteCommand(&protocol.ExecuteCommandParams{
			Command: cmd.Command,
		}, &err)
		if err != nil {
			t.Fatal(err)
		}
		expectation := ShownMessageRequest(".*Would you like to enable Go telemetry?")
		env.OnceMet(
			CompletedWork(server.TelemetryPromptWorkTitle, 2, true),
			expectation,
		)
	})
}