// Copyright 2015 The Vanadium 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 tooldata

import (
	"encoding/xml"
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"v.io/jiri"
	"v.io/jiri/project"
	"v.io/x/lib/envvar"
	"v.io/x/lib/set"
)

// Config holds configuration common to jiri tools.
type Config struct {
	// apiCheckProjects identifies the set of project names for which
	// the API check is required.
	apiCheckProjects map[string]struct{}
	// copyrightCheckProjects identifies the set of project names for
	// which the copyright check is required.
	copyrightCheckProjects map[string]struct{}
	// goWorkspaces identifies JIRI_ROOT subdirectories that contain a
	// Go workspace.
	goWorkspaces []string
	// jenkinsMatrixJobs identifies the set of matrix (multi-configutation) jobs
	// in Jenkins.
	jenkinsMatrixJobs map[string]JenkinsMatrixJobInfo
	// projectTests maps jiri projects to sets of tests that should be
	// executed to test changes in the given project.
	projectTests map[string][]string
	// testDependencies maps tests to sets of tests that the given test
	// depends on.
	testDependencies map[string][]string
	// testGroups maps test group labels to sets of tests that the label
	// identifies.
	testGroups map[string][]string
	// testParts maps test names to lists of strings that identify
	// different parts of a test. If a list L has n elements, then the
	// corresponding test has n+1 parts: the first n parts are identified
	// by L[0] to L[n-1]. The last part is whatever is left.
	testParts map[string][]string
	// vdlWorkspaces identifies JIRI_ROOT subdirectories that contain
	// a VDL workspace.
	vdlWorkspaces []string
}

// ConfigOpt is an interface for Config factory options.
type ConfigOpt interface {
	configOpt()
}

// APICheckProjectsOpt is the type that can be used to pass the Config
// factory a API check projects option.
type APICheckProjectsOpt map[string]struct{}

func (APICheckProjectsOpt) configOpt() {}

// CopyrightCheckProjectsOpt is the type that can be used to pass the
// Config factory a copyright check projects option.
type CopyrightCheckProjectsOpt map[string]struct{}

func (CopyrightCheckProjectsOpt) configOpt() {}

// GoWorkspacesOpt is the type that can be used to pass the Config
// factory a Go workspace option.
type GoWorkspacesOpt []string

func (GoWorkspacesOpt) configOpt() {}

// JenkinsMatrixJobsOpt is the type that can be used to pass the Config factory
// a Jenkins matrix jobs option.
type JenkinsMatrixJobsOpt map[string]JenkinsMatrixJobInfo

func (JenkinsMatrixJobsOpt) configOpt() {}

// ProjectTestsOpt is the type that can be used to pass the Config
// factory a project tests option.
type ProjectTestsOpt map[string][]string

func (ProjectTestsOpt) configOpt() {}

// TestDependenciesOpt is the type that can be used to pass the Config
// factory a test dependencies option.
type TestDependenciesOpt map[string][]string

func (TestDependenciesOpt) configOpt() {}

// TestGroupsOpt is the type that can be used to pass the Config
// factory a test groups option.
type TestGroupsOpt map[string][]string

func (TestGroupsOpt) configOpt() {}

// TestPartsOpt is the type that can be used to pass the Config
// factory a test parts option.
type TestPartsOpt map[string][]string

func (TestPartsOpt) configOpt() {}

// VDLWorkspacesOpt is the type that can be used to pass the Config
// factory a VDL workspace option.
type VDLWorkspacesOpt []string

func (VDLWorkspacesOpt) configOpt() {}

// NewConfig is the Config factory.
func NewConfig(opts ...ConfigOpt) *Config {
	var c Config
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case APICheckProjectsOpt:
			c.apiCheckProjects = map[string]struct{}(typedOpt)
		case CopyrightCheckProjectsOpt:
			c.copyrightCheckProjects = map[string]struct{}(typedOpt)
		case GoWorkspacesOpt:
			c.goWorkspaces = []string(typedOpt)
		case JenkinsMatrixJobsOpt:
			c.jenkinsMatrixJobs = map[string]JenkinsMatrixJobInfo(typedOpt)
		case ProjectTestsOpt:
			c.projectTests = map[string][]string(typedOpt)
		case TestDependenciesOpt:
			c.testDependencies = map[string][]string(typedOpt)
		case TestGroupsOpt:
			c.testGroups = map[string][]string(typedOpt)
		case TestPartsOpt:
			c.testParts = map[string][]string(typedOpt)
		case VDLWorkspacesOpt:
			c.vdlWorkspaces = []string(typedOpt)
		}
	}
	return &c
}

// APICheckProjects returns the set of project names for which the API
// check is required.
func (c Config) APICheckProjects() map[string]struct{} {
	return c.apiCheckProjects
}

// CopyrightCheckProjects returns the set of project names for which
// the copyright check is required.
func (c Config) CopyrightCheckProjects() map[string]struct{} {
	return c.copyrightCheckProjects
}

// GroupTests returns a list of Jenkins tests associated with the
// given test groups.
func (c Config) GroupTests(groups []string) []string {
	testSet := map[string]struct{}{}
	testGroups := c.testGroups
	for _, group := range groups {
		if testGroup, ok := testGroups[group]; ok {
			set.String.Union(testSet, set.String.FromSlice(testGroup))
		}
	}
	tests := set.String.ToSlice(testSet)
	sort.Strings(tests)
	return tests
}

// GoWorkspaces returns the Go workspaces included in the config.
func (c Config) GoWorkspaces() []string {
	return c.goWorkspaces
}

// JenkinsMatrixJobs returns the set of Jenkins matrix jobs.
func (c Config) JenkinsMatrixJobs() map[string]JenkinsMatrixJobInfo {
	return c.jenkinsMatrixJobs
}

// Projects returns a list of projects included in the config.
func (c Config) Projects() []string {
	var projects []string
	for project, _ := range c.projectTests {
		projects = append(projects, project)
	}
	sort.Strings(projects)
	return projects
}

// ProjectTests returns a list of Jenkins tests associated with the
// given projects by the config.
func (c Config) ProjectTests(projects []string) []string {
	testSet := map[string]struct{}{}
	testGroups := c.testGroups
	for _, project := range projects {
		for _, test := range c.projectTests[project] {
			if testGroup, ok := testGroups[test]; ok {
				set.String.Union(testSet, set.String.FromSlice(testGroup))
			} else {
				testSet[test] = struct{}{}
			}
		}
	}
	tests := set.String.ToSlice(testSet)
	sort.Strings(tests)
	return tests
}

// TestDependencies returns a list of dependencies for the given test.
func (c Config) TestDependencies(test string) []string {
	return c.testDependencies[test]
}

// TestParts returns a list of strings that identify different test parts.
func (c Config) TestParts(test string) []string {
	return c.testParts[test]
}

// VDLWorkspaces returns the VDL workspaces included in the config.
func (c Config) VDLWorkspaces() []string {
	return c.vdlWorkspaces
}

// GoPath computes and returns the GOPATH environment variable based on the
// current jiri configuration.
func (c Config) GoPath(jirix *jiri.X) string {
	projects, err := project.LocalProjects(jirix, project.FastScan)
	if err != nil {
		return ""
	}
	path := pathHelper(jirix, projects, c.goWorkspaces, "")
	return "GOPATH=" + envvar.JoinTokens(path, ":")
}

// VDLPath computes and returns the VDLPATH environment variable based on the
// current jiri configuration.
func (c Config) VDLPath(jirix *jiri.X) string {
	projects, err := project.LocalProjects(jirix, project.FastScan)
	if err != nil {
		return ""
	}
	path := pathHelper(jirix, projects, c.vdlWorkspaces, "src")
	return "VDLPATH=" + envvar.JoinTokens(path, ":")
}

// pathHelper is a utility function for determining paths for project workspaces.
func pathHelper(jirix *jiri.X, projects project.Projects, workspaces []string, suffix string) []string {
	path := []string{}
	for _, workspace := range workspaces {
		absWorkspace := filepath.Join(jirix.Root, workspace, suffix)
		// Only append an entry to the path if the workspace is rooted
		// under a jiri project that exists locally or vice versa.
		for _, project := range projects {
			// We check if <project.Path> is a prefix of <absWorkspace> to
			// account for Go workspaces nested under a single jiri project,
			// such as: $JIRI_ROOT/release/projects/chat/go.
			//
			// We check if <absWorkspace> is a prefix of <project.Path> to
			// account for Go workspaces that span multiple jiri projects,
			// such as: $JIRI_ROOT/release/go.
			if strings.HasPrefix(absWorkspace, project.Path) || strings.HasPrefix(project.Path, absWorkspace) {
				if _, err := jirix.NewSeq().Stat(filepath.Join(absWorkspace)); err == nil {
					path = append(path, absWorkspace)
					break
				}
			}
		}
	}
	return path
}

type configSchema struct {
	APICheckProjects       []string                `xml:"apiCheckProjects>project"`
	CopyrightCheckProjects []string                `xml:"copyrightCheckProjects>project"`
	GoWorkspaces           []string                `xml:"goWorkspaces>workspace"`
	JenkinsMatrixJobs      jenkinsMatrixJobsSchema `xml:"jenkinsMatrixJobs>job"`
	ProjectTests           testGroupSchemas        `xml:"projectTests>project"`
	TestDependencies       dependencyGroupSchemas  `xml:"testDependencies>test"`
	TestGroups             testGroupSchemas        `xml:"testGroups>group"`
	TestParts              partGroupSchemas        `xml:"testParts>test"`
	VDLWorkspaces          []string                `xml:"vdlWorkspaces>workspace"`
	XMLName                xml.Name                `xml:"config"`
}

type dependencyGroupSchema struct {
	Name         string   `xml:"name,attr"`
	Dependencies []string `xml:"dependency"`
}

type dependencyGroupSchemas []dependencyGroupSchema

func (d dependencyGroupSchemas) Len() int           { return len(d) }
func (d dependencyGroupSchemas) Swap(i, j int)      { d[i], d[j] = d[j], d[i] }
func (d dependencyGroupSchemas) Less(i, j int) bool { return d[i].Name < d[j].Name }

type JenkinsMatrixJobInfo struct {
	HasArch  bool `xml:"arch,attr"`
	HasOS    bool `xml:"OS,attr"`
	HasParts bool `xml:"parts,attr"`
	// ShowOS determines whether to show OS label in job summary.
	// It is possible that a job (e.g. jiri-go-race) has an OS axis but
	// the axis only has a single value in order to constrain where its
	// sub-builds run. In such cases, we do not want to show the OS label.
	ShowOS bool   `xml:"showOS,attr"`
	Name   string `xml:",chardata"`
}

type jenkinsMatrixJobsSchema []JenkinsMatrixJobInfo

func (jobs jenkinsMatrixJobsSchema) Len() int           { return len(jobs) }
func (jobs jenkinsMatrixJobsSchema) Swap(i, j int)      { jobs[i], jobs[j] = jobs[j], jobs[i] }
func (jobs jenkinsMatrixJobsSchema) Less(i, j int) bool { return jobs[i].Name < jobs[j].Name }

type partGroupSchema struct {
	Name  string   `xml:"name,attr"`
	Parts []string `xml:"part"`
}

type partGroupSchemas []partGroupSchema

func (p partGroupSchemas) Len() int           { return len(p) }
func (p partGroupSchemas) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p partGroupSchemas) Less(i, j int) bool { return p[i].Name < p[j].Name }

type testGroupSchema struct {
	Name  string   `xml:"name,attr"`
	Tests []string `xml:"test"`
}

type testGroupSchemas []testGroupSchema

func (p testGroupSchemas) Len() int           { return len(p) }
func (p testGroupSchemas) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p testGroupSchemas) Less(i, j int) bool { return p[i].Name < p[j].Name }

// LoadConfig returns the configuration stored in the tools
// configuration file.
func LoadConfig(jirix *jiri.X) (*Config, error) {
	configPath, err := ConfigFilePath(jirix)
	if err != nil {
		return nil, err
	}
	return loadConfig(jirix, configPath)
}

func loadConfig(jirix *jiri.X, path string) (*Config, error) {
	configBytes, err := jirix.NewSeq().ReadFile(path)
	if err != nil {
		return nil, err
	}
	var data configSchema
	if err := xml.Unmarshal(configBytes, &data); err != nil {
		return nil, fmt.Errorf("Unmarshal(%v) failed: %v", string(configBytes), err)
	}
	config := &Config{
		apiCheckProjects:       map[string]struct{}{},
		copyrightCheckProjects: map[string]struct{}{},
		goWorkspaces:           []string{},
		jenkinsMatrixJobs:      map[string]JenkinsMatrixJobInfo{},
		projectTests:           map[string][]string{},
		testDependencies:       map[string][]string{},
		testGroups:             map[string][]string{},
		testParts:              map[string][]string{},
		vdlWorkspaces:          []string{},
	}
	config.apiCheckProjects = set.String.FromSlice(data.APICheckProjects)
	config.copyrightCheckProjects = set.String.FromSlice(data.CopyrightCheckProjects)
	for _, workspace := range data.GoWorkspaces {
		config.goWorkspaces = append(config.goWorkspaces, workspace)
	}
	sort.Strings(config.goWorkspaces)
	for _, job := range data.JenkinsMatrixJobs {
		config.jenkinsMatrixJobs[job.Name] = job
	}
	for _, project := range data.ProjectTests {
		config.projectTests[project.Name] = project.Tests
	}
	for _, test := range data.TestDependencies {
		config.testDependencies[test.Name] = test.Dependencies
	}
	for _, group := range data.TestGroups {
		config.testGroups[group.Name] = group.Tests
	}
	for _, test := range data.TestParts {
		config.testParts[test.Name] = test.Parts
	}
	for _, workspace := range data.VDLWorkspaces {
		config.vdlWorkspaces = append(config.vdlWorkspaces, workspace)
	}
	sort.Strings(config.vdlWorkspaces)
	return config, nil
}

// SaveConfig writes the given configuration to the tools
// configuration file.
func SaveConfig(jirix *jiri.X, config *Config) error {
	configPath, err := ConfigFilePath(jirix)
	if err != nil {
		return err
	}
	return saveConfig(jirix, config, configPath)
}

func saveConfig(jirix *jiri.X, config *Config, path string) error {
	var data configSchema
	data.APICheckProjects = set.String.ToSlice(config.apiCheckProjects)
	sort.Strings(data.APICheckProjects)
	data.CopyrightCheckProjects = set.String.ToSlice(config.copyrightCheckProjects)
	sort.Strings(data.CopyrightCheckProjects)
	for _, workspace := range config.goWorkspaces {
		data.GoWorkspaces = append(data.GoWorkspaces, workspace)
	}
	sort.Strings(data.GoWorkspaces)
	for _, job := range config.jenkinsMatrixJobs {
		data.JenkinsMatrixJobs = append(data.JenkinsMatrixJobs, job)
	}
	sort.Sort(data.JenkinsMatrixJobs)
	for name, tests := range config.projectTests {
		data.ProjectTests = append(data.ProjectTests, testGroupSchema{
			Name:  name,
			Tests: tests,
		})
	}
	sort.Sort(data.ProjectTests)
	for name, dependencies := range config.testDependencies {
		data.TestDependencies = append(data.TestDependencies, dependencyGroupSchema{
			Name:         name,
			Dependencies: dependencies,
		})
	}
	sort.Sort(data.TestDependencies)
	for name, tests := range config.testGroups {
		data.TestGroups = append(data.TestGroups, testGroupSchema{
			Name:  name,
			Tests: tests,
		})
	}
	sort.Sort(data.TestGroups)
	for name, parts := range config.testParts {
		data.TestParts = append(data.TestParts, partGroupSchema{
			Name:  name,
			Parts: parts,
		})
	}
	sort.Sort(data.TestParts)
	for _, workspace := range config.vdlWorkspaces {
		data.VDLWorkspaces = append(data.VDLWorkspaces, workspace)
	}
	sort.Strings(data.VDLWorkspaces)
	bytes, err := xml.MarshalIndent(data, "", "  ")
	if err != nil {
		return fmt.Errorf("MarshalIndent(%v) failed: %v", data, err)
	}
	s := jirix.NewSeq()
	if err := s.MkdirAll(filepath.Dir(path), os.FileMode(0755)).
		WriteFile(path, bytes, os.FileMode(0644)).Done(); err != nil {
		return err
	}
	return nil
}