package main

import (
	"bytes"
	"context"
	"errors"
	"go/ast"
	"go/parser"
	"go/token"
	"log"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/carlosframework/platform/internal/console"
	"github.com/carlosframework/platform/internal/mail"
	"github.com/carlosframework/platform/internal/release"
)

func TestClaimLegacySweepRefusesEnabled(t *testing.T) {
	for _, enabled := range []bool{false, true} {
		t.Run(map[bool]string{false: "off", true: "on"}[enabled], func(t *testing.T) {
			ctx := context.Background()
			s := release.NewDirStore(t.TempDir())
			key := mail.LegacyKey("bab", "web")
			for _, k := range []string{key, mail.Key("bab", "web")} {
				if _, err := s.Put(ctx, k, []byte(`{"schema":1,"app":"web","id":"app"}`), ""); err != nil {
					t.Fatal(err)
				}
			}
			st, err := console.Open(filepath.Join(t.TempDir(), "console.db"))
			if err != nil {
				t.Fatal(err)
			}
			defer st.Close()
			var logs bytes.Buffer
			old := log.Writer()
			log.SetOutput(&logs)
			defer log.SetOutput(old)
			sweepLegacyMail(enabled, s, st)
			_, _, err = s.Get(ctx, key)
			if enabled {
				if err != nil {
					t.Errorf("enabled sweep deleted legacy object: %v", err)
				}
				if logs.Len() == 0 || strings.Count(strings.TrimSpace(logs.String()), "\n") != 0 {
					t.Errorf("want one refusal log: %q", logs.String())
				}
			} else if !errors.Is(err, os.ErrNotExist) {
				t.Errorf("flag-off sweep did not delete migrated object: %v", err)
			}
		})
	}
}

func rawStoreUsesAfterRuntime(source string) ([]string, error) {
	fs := token.NewFileSet()
	f, err := parser.ParseFile(fs, "main.go", source, 0)
	if err != nil {
		return nil, err
	}
	var uses []string
	for _, decl := range f.Decls {
		fn, ok := decl.(*ast.FuncDecl)
		if !ok {
			continue
		}
		var configured token.Pos
		ast.Inspect(fn, func(n ast.Node) bool {
			if call, ok := n.(*ast.CallExpr); ok {
				if sel, ok := call.Fun.(*ast.SelectorExpr); ok && sel.Sel.Name == "ConfigureClaimRuntime" {
					configured = call.End()
				}
			}
			if configured != 0 && n != nil && n.Pos() > configured {
				if id, ok := n.(*ast.Ident); ok && (id.Name == "rel" || id.Name == "openStore" || id.Name == "optionalStore") {
					uses = append(uses, fs.Position(id.Pos()).String()+":"+id.Name)
				}
			}
			return true
		})
	}
	return uses, nil
}

func TestClaimStartupRawStoreCensus(t *testing.T) {
	files, err := filepath.Glob("*.go")
	if err != nil {
		t.Fatal(err)
	}
	for _, file := range files {
		if strings.HasSuffix(file, "_test.go") {
			continue
		}
		raw, err := os.ReadFile(file)
		if err != nil {
			t.Fatal(err)
		}
		uses, err := rawStoreUsesAfterRuntime(string(raw))
		if err != nil {
			t.Fatal(err)
		}
		if len(uses) != 0 {
			t.Errorf("%s: raw store after ConfigureClaimRuntime: %v", file, uses)
		}
	}
	for _, door := range []string{"rel.Delete(ctx, key)", "openStore().Delete(ctx, key)", "optionalStore().Delete(ctx, key)"} {
		uses, err := rawStoreUsesAfterRuntime("package main; func main(){srv.ConfigureClaimRuntime(ctx); " + door + "}")
		if err != nil || len(uses) == 0 {
			t.Fatalf("missed injected raw door %s: %v %v", door, uses, err)
		}
	}
}